yadflow 1.4.0 → 2.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yadflow",
-  "version": "1.4.0",
-  "description": "Gated, team, multi-repo SDLC workflow: author → review → build with a PR-driven review gate and a zero-dependency CLI (setup, gate, commit, open-pr, repo). A BMAD module + 17 skills.",
+  "version": "2.0.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, repo). A BMAD module + 17 yad-* skills.",
   "type": "module",
   "author": "AbdelRahman Nasr",
   "license": "MIT",
@@ -14,13 +14,14 @@
     "url": "https://github.com/abdelrahmannasr/yadflow/issues"
   },
   "bin": {
-    "sdlc": "bin/sdlc.mjs"
+    "yad": "bin/yad.mjs"
   },
   "files": [
     "bin/",
     "cli/",
     "!cli/test.mjs",
     "skills/",
+    "docs/index.html",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -33,12 +34,15 @@
     "provenance": true
   },
   "scripts": {
-    "sdlc": "node bin/sdlc.mjs",
+    "yad": "node bin/yad.mjs",
     "test": "node --test cli/test.mjs",
+    "diagrams": "npx -y @mermaid-js/mermaid-cli -i docs/diagrams/sdlc-overview.mmd -o docs/diagrams/sdlc-overview.svg -b transparent && npx -y @mermaid-js/mermaid-cli -i docs/diagrams/review-loop.mmd -o docs/diagrams/review-loop.svg -b transparent",
     "prepublishOnly": "npm test"
   },
   "keywords": [
     "sdlc",
+    "yad",
+    "yadflow",
     "bmad",
     "workflow",
     "cli",

package/skills/sdlc/config.yaml

@@ -11,7 +11,7 @@ product_root: "{project-root}"
 epics_folder: "{project-root}/epics"
 
 # Core configuration values (inherited convention from _bmad/config.toml).
-project_name: sdlc-workflow
+project_name: yadflow
 communication_language: English
 document_output_language: English
 output_folder: "{project-root}/_bmad-output"
@@ -25,15 +25,15 @@ defaults:
   front_steps_locked: true
   # Each front authoring step opens its own branch at the start of the step (the <step> is the step id:
   # analysis | epic | architecture | ui-design | stories). Git/greenfield-safe; distinct from the
-  # bridge's review branch (hub.artifact_branch). See sdlc-author-epic/references/state-schema.md.
+  # bridge's review branch (hub.artifact_branch). See yad-epic/references/state-schema.md.
   front_authoring_branch: "<step>/EP-<slug>"
 
 # Team review gate defaults (build plan §3 piece 2, §4).
 review_gate:
   default_reviewers: 1          # non-owner reviewers required (in addition to 1 owner) => owner + 1 reviewer
   escalate_when: [contract, auth, payments]   # escalate to domain owners
-  # PR-driven automation (the `sdlc gate` CLI). With a hub platform, the review rides the per-step
-  # PR/MR: `sdlc gate sync` maps platform reviews/threads into the file ledger and the step
+  # PR-driven automation (the `yad gate` CLI). With a hub platform, the review rides the per-step
+  # PR/MR: `yad gate sync` maps platform reviews/threads into the file ledger and the step
   # AUTO-ADVANCES on merge, once (a) the reviewer rule is met, (b) every comment thread is resolved,
   # and (c) the review PR/MR is merged. The merge is the human approval act, so front steps still never
   # machine_advance. The file ledger stays the source of truth; no platform / no gh|glab => file-only.
@@ -44,13 +44,13 @@ review_gate:
 
 # Build half (Phase 3). Code repos are SEPARATE git repos (one .git each), not subfolders
 # of the product repo — faithful to "per-repo specs in each code repo, contract singular in the
-# product repo" (phase-3-build-plan.md, Cross-cutting). Documentation-as-config for sdlc-spec (Step A).
+# product repo" (phase-3-build-plan.md, Cross-cutting). Documentation-as-config for yad-spec (Step A).
 build:
   code_repos_root: "{project-root}/demo-repos"   # throwaway demo code repos for this build half
   feature_id: story_id          # specs/<story-id>/ — pinned to the permanent story ID, not Spec Kit's auto-slug
   spec_layout: speckit          # follow Spec Kit's native spec/plan/tasks layout
   speckit_ceremony: [specify, clarify, plan, analyze, checklist, tasks]   # heavy run, once per story per repo
-  # Step B (sdlc-implement) — the light per-task loop. One atomic task = one branch = one PR/MR.
+  # Step B (yad-implement) — the light per-task loop. One atomic task = one branch = one PR/MR.
   branch_convention: "feat/<story-id>-<task-id>-<short-slug>"   # e.g. feat/EP-istifta-inquiries-S01-T01-create-inquiry
   commit_task_trailer: "Task: <story-id>-<task-id>"             # final commit trailer; anchors the spec-link check (Step C)
   contract_change_trailer: "Contract-Change: yes"              # ONLY when the locked contract surface is touched (routes back to architecture gate)
@@ -59,7 +59,7 @@ build:
   # + no trailing period; proper nouns/acronyms keep their case.
   commit_subject_style: "<type>: <lowercase imperative description, no trailing period>"   # types: feat|fix|docs|refactor|test|perf|build|ci|chore|revert
   pr_title_style: same_as_commit_subject                       # one atomic task = one branch = one PR/MR; title defaults to the task's commit subject
-  # Commit ownership + per-commit AI co-author (sdlc-implement installs the .gitmessage template).
+  # Commit ownership + per-commit AI co-author (yad-implement installs the .gitmessage template).
   # The human git author OWNS the commit; the assisting AI is recorded per-commit as a Co-Authored-By
   # trailer, chosen by the owner from `ai_coauthor.allowed`. The AI is never the author. `none` is an
   # explicit human-only choice. Trailer order is Task: -> Contract-Change: (if any) -> Co-Authored-By:.
@@ -73,30 +73,30 @@ build:
       - { id: cursor,     name: "Cursor",             email: "noreply@cursor.com" }
       - { id: coderabbit, name: "CodeRabbit",         email: "noreply@coderabbit.ai" }
       - { id: none,       name: "(no AI assistance)", email: "" }
-  # Step C (sdlc-checks) — the three CI gates that must pass before merge. CI-agnostic bash in checks/.
+  # Step C (yad-checks) — the three CI gates that must pass before merge. CI-agnostic bash in checks/.
   gates: [spec-link, contract-check, build-test-lint]
-  ci_platforms: [github, gitlab]   # both wired from skills/sdlc-checks/templates/; GitHub is this product repo's platform
+  ci_platforms: [github, gitlab]   # both wired from skills/yad-checks/templates/; GitHub is this product repo's platform
   contract_surface_glob: "specs/*/contracts/**"   # the repo's quoted contract slice; a diff here needs Contract-Change + a re-locked contract
-  # Step D (sdlc-pr-template) — platform-matched PR/MR template + risk routing.
+  # Step D (yad-pr-template) — platform-matched PR/MR template + risk routing.
   pr_templates:
     github: ".github/pull_request_template.md"
     gitlab: ".gitlab/merge_request_templates/Default.md"
-    hub:                                # front-half artifact-review PR/MR on the product hub (sdlc-pr-template repo:hub)
+    hub:                                # front-half artifact-review PR/MR on the product hub (yad-pr-template repo:hub)
       github: ".github/pull_request_template.md"
       gitlab: ".gitlab/merge_request_templates/Default.md"
-  risk_levels: [low, medium, high]   # high (or a contract/auth/payments surface) routes to domain owners (sdlc-review-gate escalation)
-  # Step E (sdlc-ship) — AI review (advisory) + engineer review (the human gate) + ship.
+  risk_levels: [low, medium, high]   # high (or a contract/auth/payments surface) routes to domain owners (yad-review-gate escalation)
+  # Step E (yad-ship) — AI review (advisory) + engineer review (the human gate) + ship.
   ai_review: coderabbit            # advisory first pass; never the authority (.coderabbit.yaml)
   build_log: "epics/EP-<slug>/.sdlc/build-log.json"   # append-only ship ledger (back-half analogue of approvals.json)
   story_build_states: [in-build, shipped]   # in-build = some tasks shipped; shipped = all tasks in tasks.md shipped
-  # Backfill (sdlc-backfill) — specs for already-built features in an existing repo.
+  # Backfill (yad-backfill) — specs for already-built features in an existing repo.
   backfill:
     tool: repomix                  # the one true CLI subprocess: `npx repomix@latest` (Phase 0 / RESEARCH-NOTES §3)
     pack_flags: "--compress --include <globs> --include-logs --style markdown"   # one feature at a time; Secretlint by default
     spec_location: "specs/backfill/<feature>/spec.md"   # draft (verified: false) until a human approves
     gate_scope: touched-features   # block a change only until the features it touches have approved specs
 
-# Code context (sdlc-connect-repos) — the front/"brain" phases are made code-aware. Code repos are
+# Code context (yad-connect-repos) — the front/"brain" phases are made code-aware. Code repos are
 # connected to the product hub once (or any time a new repo is added), and an AI-readable picture of
 # each is cached so epic/architecture/ui/stories consider what already exists in the code. The product
 # repo is the FRONT-PHASE TOOLCHAIN HUB: repomix (and Impeccable) are installed/run here and target the
@@ -110,18 +110,18 @@ code_context:
   staleness: head-sha                                 # stale when a repo's HEAD != registry syncedHead
   refresh: human                                      # a stale repo is a HUMAN decision: front-phase
                                                       # skills FLAG it and stop (pointing at
-                                                      # `sdlc repo refresh <repo>`) — they never silently
-                                                      # re-pack. `sdlc repo list` shows fresh/stale;
-                                                      # `sdlc repo refresh` and `sdlc check --fix` re-pack.
+                                                      # `yad repo refresh <repo>`) — they never silently
+                                                      # re-pack. `yad repo list` shows fresh/stale;
+                                                      # `yad repo refresh` and `yad check --fix` re-pack.
   load_in_front_phases: true                          # epic, architecture, ui-design, stories read the maps
-  # Auth: `sdlc-connect-repos` clones/fetches as the LOCAL user (SSH key or git credential helper),
+  # Auth: `yad-connect-repos` clones/fetches as the LOCAL user (SSH key or git credential helper),
   # works for both github and gitlab (and self-hosted), and stores NO tokens in the registry.
   platforms: [github, gitlab]
 
-# Hub platform + front-half review bridge (sdlc-connect-repos `detect-hub`; sdlc-review-gate + sdlc-hub-bridge).
+# Hub platform + front-half review bridge (yad-connect-repos `detect-hub`; yad-review-gate + yad-hub-bridge).
 # The product hub is itself a git repo on a platform. With the bridge enabled, the front-half review/
 # comment/approval cycle runs through a real PR/MR on the hub: a review PR is opened per artifact, reviewers
-# approve/comment on the platform (their own gh/glab auth — NO stored tokens), and `sdlc-review-gate action: sync`
+# approve/comment on the platform (their own gh/glab auth — NO stored tokens), and `yad-review-gate action: sync`
 # pulls that state into the file ledger (approvals.json/reviews/*.md) and runs the UNCHANGED gate predicate.
 # The file ledger stays the source of truth. Degrades to the file-only gate when there is no platform / no CLI.
 hub:
@@ -130,11 +130,11 @@ hub:
   bridge: true                                         # master enable; false => file-only front gates everywhere
   platforms: [github, gitlab]                          # detected from the hub's own `git remote get-url origin`
   artifact_branch: "review/EP-<slug>/<artifact-base>"  # branch a review PR is opened on, per artifact
-  # roster (in hub.json) maps a platform login -> sdlc name + role; domain-owners are DERIVED from
+  # roster (in hub.json) maps a platform login -> yad name + role; domain-owners are DERIVED from
   # repos.json (a roster name that equals a repo's domain_owner owns that repo's domain) — never duplicated.
 
 # Phase 4 (automation) — the SECOND dial made real. Until Phase 4 nothing read this dial; the
-# orchestrator (sdlc-run) now does. Governing rule: automation is EARNED per step, with trust-log
+# orchestrator (yad-run) now does. Governing rule: automation is EARNED per step, with trust-log
 # evidence, and is reversible in one move (phase-4-build-plan.md §"one principle"). Front states are
 # never listed in back_steps and can never be flipped — the engineer keeps authority over decisions.
 automation:
@@ -152,5 +152,5 @@ automation:
   # merge gate.
   locked_steps: [analysis, epic, architecture, ui-design, stories, engineer-review]
   # Kill switch (phase-4-build-plan.md §Safety): true => every step forced to human_approve
-  # system-wide, no per-step edits. One line, instantly reversible. Toggle via `sdlc-run action: kill`.
+  # system-wide, no per-step edits. One line, instantly reversible. Toggle via `yad-run action: kill`.
   kill_switch: false

package/skills/sdlc/install.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Install the hand-authored `sdlc` BMAD module into the IDE skill dirs.
+# Install the hand-authored `yad` BMAD module into the IDE skill dirs.
 #
 # Source of truth: {project-root}/skills/  (survives `bmad-method` updates).
 # This script copies the sdlc-* skills into the four IDE locations the BMAD installer uses,
@@ -11,7 +11,7 @@ set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$ROOT"
 
-SKILLS=(sdlc-author-analysis sdlc-author-epic sdlc-author-architecture sdlc-author-ui sdlc-author-stories sdlc-connect-repos sdlc-spec sdlc-implement sdlc-checks sdlc-pr-template sdlc-review-comments sdlc-hub-bridge sdlc-ship sdlc-backfill sdlc-run sdlc-review-gate sdlc-status)
+SKILLS=(yad-analysis yad-epic yad-architecture yad-ui yad-stories yad-connect-repos yad-spec yad-implement yad-checks yad-pr-template yad-review-comments yad-hub-bridge yad-ship yad-backfill yad-run yad-review-gate yad-status)
 
 echo "Installing sdlc module from $ROOT/skills ..."
 

package/skills/sdlc/module-help.csv

@@ -1,17 +1,17 @@
 module,skill,display-name,menu-code,description,action,args,phase,preceded-by,followed-by,required,output-location,outputs
-SDLC Workflow,sdlc-author-epic,Author Epic,AE,"Front state 1: shape an idea with analyst then pm into epic.md; assign EP-<slug> ID and seed .sdlc state. Never auto-advances.",,{idea: one-line feature idea},1-front,,sdlc-review-gate,true,epics/EP-<slug>/,epic.md state.json
-SDLC Workflow,sdlc-review-gate,Team Review Gate,RG,"Reusable review+approve gate for all four reviews. Shares an artifact for review, records comments and approvals as files, enforces owner + 1 reviewer (escalates on contract/auth/payments; per-repo routing for stories), advances state only when approved.",,{artifact: file under the epic} {action: open|comment|approve|advance},1-front,,,true,epics/EP-<slug>/reviews/,reviews/*.md approvals.json state.json
-SDLC Workflow,sdlc-author-architecture,Author Architecture,AA,"Front state 3: with the architect author architecture.md and the locked contract.md; hash-lock the contract surface. Never auto-advances.",,{epic: EP-<slug>},1-front,sdlc-review-gate,sdlc-review-gate,true,epics/EP-<slug>/,architecture.md contract.md contract-lock.json state.json
-SDLC Workflow,sdlc-author-ui,Author UI Design,AU,"Front state 5: with the ux-designer author ui-design.md and DESIGN.md, driving Impeccable slash-commands when installed. Never auto-advances.",,{epic: EP-<slug>},1-front,sdlc-review-gate,sdlc-review-gate,true,epics/EP-<slug>/,ui-design.md DESIGN.md state.json
-SDLC Workflow,sdlc-author-stories,Author Stories,AS,"Front state 7: with the pm break the epic into repo-tagged stories with stable EP-<slug>-S0N IDs, one file each under stories/. Never auto-advances.",,{epic: EP-<slug>},1-front,sdlc-review-gate,sdlc-review-gate,true,epics/EP-<slug>/stories/,stories/EP-<slug>-S0N.md state.json
-SDLC Workflow,sdlc-connect-repos,Connect Code Repos,CR,"Setup/maintenance: connect code repos to the product hub so the front/brain phases are code-aware. Registers each repo (GitHub or GitLab, local-user auth, no stored tokens) in .sdlc/repos.json and caches a Repomix pack + a lightweight code-map (existing endpoints/events/data-models/modules, secret-scanned). Idempotent and refreshable; staleness tracked by HEAD sha. Run at setup or any time a new repo is added. Not a gated state — never touches epic state or approvals.",,{action: connect|refresh|list|disconnect} {repo: <name>} {path: <path-or-absolute>} {git_url: <ssh-or-https>} {domain_owner: <who>},0-setup,,sdlc-author-epic,false,.sdlc/,repos.json code-context/<repo>/pack.md code-context/<repo>/code-map.md
-SDLC Workflow,sdlc-spec,Author Spec,SP,"Build-half Step A: for one ready-for-build story and one of its repos, run the heavy Spec Kit ceremony once (specify→clarify→plan→analyze→checklist→tasks) inside that code repo, writing specs/<story-id>/ in Spec Kit's layout (drives /speckit.* when installed, else hand-authors and records speckit: not-installed). References the locked contract; never re-invents the surface. Writes link.md back to the story. Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <one of story.repos>},3-build,sdlc-review-gate,,false,demo-repos/<repo>/specs/<story-id>/,spec.md research.md data-model.md contracts/ plan.md tasks.md link.md
-SDLC Workflow,sdlc-implement,Implement Task,IM,"Build-half Step B: with the dev lens, implement ONE atomic task from a story's tasks.md as a small diff (<=3 files) on its own branch feat/<story>-<task>-<slug> in the code repo. Diff stays inside the task's declared files (flag and STOP if it grows beyond them). Commit ends with a Task: <story>-<task> trailer; add Contract-Change: yes only when the locked contract surface is touched (routes back to the architecture gate). Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <one of story.repos>} {task: T0N},3-build,sdlc-spec,,false,demo-repos/<repo>/,branch+commit per atomic task
-SDLC Workflow,sdlc-checks,Check Gates,CK,"Build-half Step C: wire and run the three production-safety CI gates on a code repo — spec-link (every change links a real story/spec via its Task trailer), contract-check (a contract-surface change without Contract-Change + an updated re-locked contract FAILS and routes back to the architecture gate), and build/test/lint. CI-agnostic bash invoked by GitHub Actions and GitLab CI. Blocking in CI; the human still owns the merge. Never auto-advances.",,{repo: <one of an epic's repos>} {action: wire|run} {base: target branch},3-build,sdlc-implement,,false,demo-repos/<repo>/,checks/*.sh .github/workflows/sdlc-checks.yml .gitlab-ci.yml
-SDLC Workflow,sdlc-pr-template,PR/MR Template,PT,"Build-half Step D: detect a code repo's platform and commit the matching PR/MR template (.github/pull_request_template.md or .gitlab/merge_request_templates/Default.md) with an Impact & Risk block. A high risk level (or a touched contract/auth/payments surface) routes the review to domain owners — the same escalation sdlc-review-gate applies. risk-route.sh prints the required reviewers from a PR body. Never auto-advances.",,{repo: <one of an epic's repos>} {action: wire|route} {body: PR description file},3-build,sdlc-checks,,false,demo-repos/<repo>/,.github/pull_request_template.md .gitlab/merge_request_templates/Default.md checks/risk-route.sh
-SDLC Workflow,sdlc-review-comments,Review Comment Templates,RC,"Install platform-matched PR/MR review-comment scaffolds (committed REVIEW_COMMENTS.md) into a code repo or the product hub, so reviewers leave structured, attributable feedback whose **name (role)** headers map cleanly into the SDLC file ledger. GitHub Saved Replies / GitLab comment templates are per-user, so a committed doc is the repo-level mechanism. Never auto-advances.",,{repo: <one of an epic's repos | hub>} {action: wire},3-build,,,false,<repo>/.github|.gitlab/,REVIEW_COMMENTS.md
-SDLC Workflow,sdlc-hub-bridge,Hub Review Bridge,HB,"The templated PR/MR bridge for the front-half review gate: when the product hub has a platform (.sdlc/hub.json), open a review PR/MR on the hub for an authored artifact, set required reviewers/labels from the routing rule, and provide the read-only gh/glab recipes sdlc-review-gate's sync uses to pull platform comments + approvals into the file ledger. Local-user auth, no stored tokens; file ledger stays the source of truth; degrades to file-only when no platform/CLI. Never auto-advances.",,{epic: EP-<slug>} {artifact: epic.md|architecture.md|ui-design.md|stories/} {action: open|route},1-front,sdlc-review-gate,sdlc-review-gate,false,epics/EP-<slug>/.sdlc/,hub-prs.json
-SDLC Workflow,sdlc-ship,Review & Ship,SH,"Build-half Step E: wire an advisory AI first-pass (CodeRabbit) on the PR, record the human engineer review with the same human_approve discipline as the front gates (owner + 1 reviewer, escalating to domain owners on high risk / contract / auth / payments), and on merge record the ship in epics/<epic>/.sdlc/build-log.json and update the story state. AI review is advisory, never the authority; the human owns the merge. Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {task: T0N} {repo: <repo>} {action: ai-review|approve|ship},3-build,sdlc-pr-template,,false,epics/EP-<slug>/.sdlc/,build-log.json story-status
-SDLC Workflow,sdlc-backfill,Backfill Specs,BF,"Build-half Step G: generate specs for already-built features in an existing repo. Confirm Repomix (npx repomix CLI), pack ONE feature (compress + git logs, secret-scan), feed to AI with a 'describe what exists, do not invent' prompt, write a DRAFT spec marked verified: false. Human approval (reuse sdlc-review-gate) makes it real. Boundary auto-proposed and human-confirmed. A change is blocked only until the features it touches have approved specs. Never auto-advances.",,{repo: <repo>} {feature: <name + globs>} {action: pack|draft|approve|gate},3-build,,,false,demo-repos/<repo>/specs/backfill/<feature>/,spec.md backfill-check.sh
-SDLC Workflow,sdlc-run,Run (Automation),RN,"Phase 4 orchestrator: drive a story's back-half loop (spec→tasks→implement→checks) in one code repo, reading each step's automation dial from build-state — on machine_advance it advances on its own, on human_approve it stops for a human. Records every run in the trust log. Realizes Step B (a clean checks pass auto-advances to the engineer review when earned; any FAIL / scope overrun / contract touch HALTS). set-dial earns/reverts a step's automation (machine_advance gated by the trust threshold; front states and engineer-review refused); kill/unkill toggles the system-wide kill switch. Front states and the human merge gate never auto-advance.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <repo>} {action: run|set-dial|kill|unkill} {step: <back-step>} {to: human_approve|machine_advance},4-automate,sdlc-spec,sdlc-ship,false,epics/EP-<slug>/.sdlc/,build-state/<story-id>.json trust-log.json
-SDLC Workflow,sdlc-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-epic,Author Epic,AE,"Front state 1: shape an idea with analyst then pm into epic.md; assign EP-<slug> ID and seed .sdlc state. Never auto-advances.",,{idea: one-line feature idea},1-front,,yad-review-gate,true,epics/EP-<slug>/,epic.md state.json
+SDLC Workflow,yad-review-gate,Team Review Gate,RG,"Reusable review+approve gate for all four reviews. Shares an artifact for review, records comments and approvals as files, enforces owner + 1 reviewer (escalates on contract/auth/payments; per-repo routing for stories), advances state only when approved.",,{artifact: file under the epic} {action: open|comment|approve|advance},1-front,,,true,epics/EP-<slug>/reviews/,reviews/*.md approvals.json state.json
+SDLC Workflow,yad-architecture,Author Architecture,AA,"Front state 3: with the architect author architecture.md and the locked contract.md; hash-lock the contract surface. Never auto-advances.",,{epic: EP-<slug>},1-front,yad-review-gate,yad-review-gate,true,epics/EP-<slug>/,architecture.md contract.md contract-lock.json state.json
+SDLC Workflow,yad-ui,Author UI Design,AU,"Front state 5: with the ux-designer author ui-design.md and DESIGN.md, driving Impeccable slash-commands when installed. Never auto-advances.",,{epic: EP-<slug>},1-front,yad-review-gate,yad-review-gate,true,epics/EP-<slug>/,ui-design.md DESIGN.md state.json
+SDLC Workflow,yad-stories,Author Stories,AS,"Front state 7: with the pm break the epic into repo-tagged stories with stable EP-<slug>-S0N IDs, one file each under stories/. Never auto-advances.",,{epic: EP-<slug>},1-front,yad-review-gate,yad-review-gate,true,epics/EP-<slug>/stories/,stories/EP-<slug>-S0N.md state.json
+SDLC Workflow,yad-connect-repos,Connect Code Repos,CR,"Setup/maintenance: connect code repos to the product hub so the front/brain phases are code-aware. Registers each repo (GitHub or GitLab, local-user auth, no stored tokens) in .sdlc/repos.json and caches a Repomix pack + a lightweight code-map (existing endpoints/events/data-models/modules, secret-scanned). Idempotent and refreshable; staleness tracked by HEAD sha. Run at setup or any time a new repo is added. Not a gated state — never touches epic state or approvals.",,{action: connect|refresh|list|disconnect} {repo: <name>} {path: <path-or-absolute>} {git_url: <ssh-or-https>} {domain_owner: <who>},0-setup,,yad-epic,false,.sdlc/,repos.json code-context/<repo>/pack.md code-context/<repo>/code-map.md
+SDLC Workflow,yad-spec,Author Spec,SP,"Build-half Step A: for one ready-for-build story and one of its repos, run the heavy Spec Kit ceremony once (specify→clarify→plan→analyze→checklist→tasks) inside that code repo, writing specs/<story-id>/ in Spec Kit's layout (drives /speckit.* when installed, else hand-authors and records speckit: not-installed). References the locked contract; never re-invents the surface. Writes link.md back to the story. Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <one of story.repos>},3-build,yad-review-gate,,false,demo-repos/<repo>/specs/<story-id>/,spec.md research.md data-model.md contracts/ plan.md tasks.md link.md
+SDLC Workflow,yad-implement,Implement Task,IM,"Build-half Step B: with the dev lens, implement ONE atomic task from a story's tasks.md as a small diff (<=3 files) on its own branch feat/<story>-<task>-<slug> in the code repo. Diff stays inside the task's declared files (flag and STOP if it grows beyond them). Commit ends with a Task: <story>-<task> trailer; add Contract-Change: yes only when the locked contract surface is touched (routes back to the architecture gate). Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <one of story.repos>} {task: T0N},3-build,yad-spec,,false,demo-repos/<repo>/,branch+commit per atomic task
+SDLC Workflow,yad-checks,Check Gates,CK,"Build-half Step C: wire and run the three production-safety CI gates on a code repo — spec-link (every change links a real story/spec via its Task trailer), contract-check (a contract-surface change without Contract-Change + an updated re-locked contract FAILS and routes back to the architecture gate), and build/test/lint. CI-agnostic bash invoked by GitHub Actions and GitLab CI. Blocking in CI; the human still owns the merge. Never auto-advances.",,{repo: <one of an epic's repos>} {action: wire|run} {base: target branch},3-build,yad-implement,,false,demo-repos/<repo>/,checks/*.sh .github/workflows/yad-checks.yml .gitlab-ci.yml
+SDLC Workflow,yad-pr-template,PR/MR Template,PT,"Build-half Step D: detect a code repo's platform and commit the matching PR/MR template (.github/pull_request_template.md or .gitlab/merge_request_templates/Default.md) with an Impact & Risk block. A high risk level (or a touched contract/auth/payments surface) routes the review to domain owners — the same escalation yad-review-gate applies. risk-route.sh prints the required reviewers from a PR body. Never auto-advances.",,{repo: <one of an epic's repos>} {action: wire|route} {body: PR description file},3-build,yad-checks,,false,demo-repos/<repo>/,.github/pull_request_template.md .gitlab/merge_request_templates/Default.md checks/risk-route.sh
+SDLC Workflow,yad-review-comments,Review Comment Templates,RC,"Install platform-matched PR/MR review-comment scaffolds (committed REVIEW_COMMENTS.md) into a code repo or the product hub, so reviewers leave structured, attributable feedback whose **name (role)** headers map cleanly into the SDLC file ledger. GitHub Saved Replies / GitLab comment templates are per-user, so a committed doc is the repo-level mechanism. Never auto-advances.",,{repo: <one of an epic's repos | hub>} {action: wire},3-build,,,false,<repo>/.github|.gitlab/,REVIEW_COMMENTS.md
+SDLC Workflow,yad-hub-bridge,Hub Review Bridge,HB,"The templated PR/MR bridge for the front-half review gate: when the product hub has a platform (.sdlc/hub.json), open a review PR/MR on the hub for an authored artifact, set required reviewers/labels from the routing rule, and provide the read-only gh/glab recipes yad-review-gate's sync uses to pull platform comments + approvals into the file ledger. Local-user auth, no stored tokens; file ledger stays the source of truth; degrades to file-only when no platform/CLI. Never auto-advances.",,{epic: EP-<slug>} {artifact: epic.md|architecture.md|ui-design.md|stories/} {action: open|route},1-front,yad-review-gate,yad-review-gate,false,epics/EP-<slug>/.sdlc/,hub-prs.json
+SDLC Workflow,yad-ship,Review & Ship,SH,"Build-half Step E: wire an advisory AI first-pass (CodeRabbit) on the PR, record the human engineer review with the same human_approve discipline as the front gates (owner + 1 reviewer, escalating to domain owners on high risk / contract / auth / payments), and on merge record the ship in epics/<epic>/.sdlc/build-log.json and update the story state. AI review is advisory, never the authority; the human owns the merge. Never auto-advances.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {task: T0N} {repo: <repo>} {action: ai-review|approve|ship},3-build,yad-pr-template,,false,epics/EP-<slug>/.sdlc/,build-log.json story-status
+SDLC Workflow,yad-backfill,Backfill Specs,BF,"Build-half Step G: generate specs for already-built features in an existing repo. Confirm Repomix (npx repomix CLI), pack ONE feature (compress + git logs, secret-scan), feed to AI with a 'describe what exists, do not invent' prompt, write a DRAFT spec marked verified: false. Human approval (reuse yad-review-gate) makes it real. Boundary auto-proposed and human-confirmed. A change is blocked only until the features it touches have approved specs. Never auto-advances.",,{repo: <repo>} {feature: <name + globs>} {action: pack|draft|approve|gate},3-build,,,false,demo-repos/<repo>/specs/backfill/<feature>/,spec.md backfill-check.sh
+SDLC Workflow,yad-run,Run (Automation),RN,"Phase 4 orchestrator: drive a story's back-half loop (spec→tasks→implement→checks) in one code repo, reading each step's automation dial from build-state — on machine_advance it advances on its own, on human_approve it stops for a human. Records every run in the trust log. Realizes Step B (a clean checks pass auto-advances to the engineer review when earned; any FAIL / scope overrun / contract touch HALTS). set-dial earns/reverts a step's automation (machine_advance gated by the trust threshold; front states and engineer-review refused); kill/unkill toggles the system-wide kill switch. Front states and the human merge gate never auto-advance.",,{epic: EP-<slug>} {story: EP-<slug>-S0N} {repo: <repo>} {action: run|set-dial|kill|unkill} {step: <back-step>} {to: human_approve|machine_advance},4-automate,yad-spec,yad-ship,false,epics/EP-<slug>/.sdlc/,build-state/<story-id>.json trust-log.json
+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,,

package/skills/{sdlc-author-analysis → yad-analysis}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: sdlc-author-analysis
+name: yad-analysis
 description: 'Optional front state 1 of the gated SDLC. With the analyst, pressure-test a feature idea and write the discovery brief into analysis.md. Assigns the EP-<slug> ID and seeds .sdlc/ state (the 10-step chain that puts analysis before epic). Never auto-advances — hands off to the team review gate. Optional: if skipped, the epic step does this shaping inline. Use when the user says "analyse the idea", "start with analysis", or "author the analysis".'
 ---
 
@@ -8,10 +8,10 @@ description: 'Optional front state 1 of the gated SDLC. With the analyst, pressu
 **Goal:** Produce a human-authored, AI-assisted `analysis.md` — the analyst's discovery brief that
 shapes the feature **before** the epic — assign its stable `EP-<slug>` ID, and initialise the per-epic
 state machine in `.sdlc/`. This is a **front state**: human-authored with AI assist and **never
-auto-advances**. When the analysis is drafted, control passes to `sdlc-review-gate`.
+auto-advances**. When the analysis is drafted, control passes to `yad-review-gate`.
 
 This step is **optional**. When it runs, it is the entry point: it assigns the ID and seeds the
-**10-step** chain (`analysis` before `epic`). When it is **skipped**, `sdlc-author-epic` does the same
+**10-step** chain (`analysis` before `epic`). When it is **skipped**, `yad-epic` does the same
 analyst shaping inline and seeds the **8-step** chain — no behaviour change for teams that skip it.
 
 This skill enforces the build plan's core rules: all state lives in files; IDs are generated by the
@@ -28,7 +28,7 @@ engine (never typed by hand); front steps are locked to `human_approve`.
 ### Step 1 — Get the idea
 Ask the user for a one-line feature idea if not provided. If `.sdlc/state.json` already exists for the
 target epic, analysis was already seeded (or the epic is past it) — stop and point the user at
-`sdlc-status`. The entry point seeds state exactly once.
+`yad-status`. The entry point seeds state exactly once.
 
 ### Step 2 — Shape the idea (assist: analyst)
 Adopt the **analyst** lens (`bmad-agent-analyst`, Mary) to pressure-test the idea in depth: who is the
@@ -43,7 +43,7 @@ connected repo** (the epic's `repos` are not chosen yet), load the lightweight c
 
 - **Greenfield-safe:** if `repos.json` is absent or empty, note "no repos connected" and proceed.
 - **Staleness:** if a repo's current HEAD (`git -C <path> rev-parse HEAD`) ≠ its registry `syncedHead`,
-  warn and suggest `sdlc repo refresh <repo>` (a human decision — flag and stop, never auto-refresh);
+  warn and suggest `yad repo refresh <repo>` (a human decision — flag and stop, never auto-refresh);
   stamp `code-context: stale` in the frontmatter.
 - **Traceability:** record which maps you loaded in the analysis frontmatter `code-context:` field.
 
@@ -122,15 +122,15 @@ Notes:
 
 ### Step 7 — Stop at the gate (do NOT advance)
 Report: epic ID, the path to `analysis.md`, and that the next action is **review** via
-`sdlc-review-gate` (base rule: owner + 1 reviewer). **Never mark the analysis-review step approved
+`yad-review-gate` (base rule: owner + 1 reviewer). **Never mark the analysis-review step approved
 here** — only real reviewers do that through the gate. Front states do not auto-advance. When the
-analysis gate passes, control moves to `sdlc-author-epic`, which reads `analysis.md` as input. When the
-hub has a platform, the gate opens a review PR on the hub (via `sdlc-hub-bridge`) and
-`sdlc-review-gate action: sync` pulls platform approvals/comments into the ledger; otherwise the review
+analysis gate passes, control moves to `yad-epic`, which reads `analysis.md` as input. When the
+hub has a platform, the gate opens a review PR on the hub (via `yad-hub-bridge`) and
+`yad-review-gate action: sync` pulls platform approvals/comments into the ledger; otherwise the review
 is recorded file-only.
 
 ## Reference
 - State schema, the two chain shapes, and the authoring-branch procedure:
-  `../sdlc-author-epic/references/state-schema.md`.
-- The epic step that consumes this analysis: `../sdlc-author-epic/SKILL.md`.
-- Connecting code repos + the code-context the brain reads: `../sdlc-connect-repos/SKILL.md`.
+  `../yad-epic/references/state-schema.md`.
+- The epic step that consumes this analysis: `../yad-epic/SKILL.md`.
+- Connecting code repos + the code-context the brain reads: `../yad-connect-repos/SKILL.md`.

package/skills/{sdlc-author-architecture → yad-architecture}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: sdlc-author-architecture
+name: yad-architecture
 description: 'Front state 3 of the gated SDLC. With the architect, author architecture.md and the locked contract.md (the shared cross-repo surface), then hash-lock the contract surface into .sdlc/contract-lock.json. Reads epic.md as input. Never auto-advances — hands off to the team review gate (which escalates on the contract risk tag). Use when the user says "author the architecture" or after the epic gate passes.'
 ---
 
@@ -8,7 +8,7 @@ description: 'Front state 3 of the gated SDLC. With the architect, author archit
 **Goal:** Produce a human-authored, AI-assisted `architecture.md` and the **locked** `contract.md`
 for an approved epic, then record a hash-lock of the contract surface so a later contract-check can
 detect drift. This is a **front state**: human-authored with AI assist, **never auto-advances**.
-When both artifacts are drafted, control passes to `sdlc-review-gate`, which **escalates** this review
+When both artifacts are drafted, control passes to `yad-review-gate`, which **escalates** this review
 by default (the architecture step carries `risk_tags: ["contract"]`).
 
 This skill enforces the build plan's core rules: all state lives in files; the contract holds only the
@@ -25,11 +25,11 @@ shared cross-repo surface at charter altitude; front steps stay locked to `human
 ### Step 1 — Resolve the epic and check the gate
 Resolve the `EP-<slug>` (ask if not provided). Read `{project-root}/epics/EP-<slug>/.sdlc/state.json`.
 Only proceed when `currentStep == "architecture"` and that step's `status == "in_progress"` (the epic
-review must already have passed). If not, stop and point the user at `sdlc-status` / the gate.
+review must already have passed). If not, stop and point the user at `yad-status` / the gate.
 
 ### Step 1b — Open the authoring branch
 Open the architecture authoring branch `architecture/EP-<slug>` per the shared procedure
-(`../sdlc-author-epic/references/state-schema.md` → "Authoring branches"): git-safe (skip with a note
+(`../yad-epic/references/state-schema.md` → "Authoring branches"): git-safe (skip with a note
 if `{project-root}` is not a git work tree), check out the branch if it exists, else create it from the
 hub's default branch. Author and commit `architecture.md` / `contract.md` / `contract-lock.json` on it.
 This is **distinct** from the bridge's `review/…` branch.
@@ -44,17 +44,17 @@ Read the registry `{project-root}/.sdlc/repos.json` (`config.yaml` `code_context
 **and**, because this phase locks the contract, the full pack `.../pack.md` when you need depth on the
 existing **endpoints, events, and data models**. This is the context that stops the architecture from
 re-defining or contradicting what is already built. (`pack.md` is **not committed** — if it is absent
-locally, regenerate it with `sdlc repo refresh <repo>`; the committed `code-map.md`
+locally, regenerate it with `yad repo refresh <repo>`; the committed `code-map.md`
 is always present.)
 
 - **Greenfield-safe:** if `repos.json` is absent/empty, note "no repos connected" and proceed — design
   from scratch as before.
 - **Staleness:** if a repo's current HEAD ≠ its registry `syncedHead`, warn and suggest
-  `sdlc repo refresh <repo>` (a human decision — flag and stop, never auto-refresh); stamp
+  `yad repo refresh <repo>` (a human decision — flag and stop, never auto-refresh); stamp
   `code-context: stale` in the frontmatter.
 - **Traceability:** record the loaded maps in the `code-context:` frontmatter of both `architecture.md`
   and `contract.md`.
-- For an area not in the code-map, do a live on-demand read (`sdlc-connect-repos`
+- For an area not in the code-map, do a live on-demand read (`yad-connect-repos`
   `references/code-context.md`).
 
 ### Step 3 — Author the architecture (assist: architect)
@@ -167,14 +167,14 @@ real reviewers approve, through the gate.
 
 ### Step 7 — Stop at the gate (do NOT advance)
 Report: the paths to `architecture.md`, `contract.md`, and `contract-lock.json`; the contract hash;
-and that the next action is **review** via `sdlc-review-gate`. Note that this review **escalates**
+and that the next action is **review** via `yad-review-gate`. Note that this review **escalates**
 (risk tag `contract`): it needs owner + 1 reviewer **plus a domain owner for each touched repo**.
 **Never record approval here.** Front states do not auto-advance. When the hub has a platform, the gate
-opens a review PR on the hub (via `sdlc-hub-bridge`, labelled per touched repo) and
-`sdlc-review-gate action: sync` pulls platform approvals/comments into the ledger; a contract re-lock
+opens a review PR on the hub (via `yad-hub-bridge`, labelled per touched repo) and
+`yad-review-gate action: sync` pulls platform approvals/comments into the ledger; a contract re-lock
 invalidates prior platform approvals too. Otherwise the review is recorded file-only.
 
 ## Reference
 - Contract surface, altitude rule, and hashing recipe: `references/contract-format.md`.
-- State schema and field meanings: `../sdlc-author-epic/references/state-schema.md`.
-- Connecting code repos + the code-context cross-checked here: `../sdlc-connect-repos/SKILL.md`.
+- State schema and field meanings: `../yad-epic/references/state-schema.md`.
+- Connecting code repos + the code-context cross-checked here: `../yad-connect-repos/SKILL.md`.

package/skills/{sdlc-author-architecture → yad-architecture}/references/contract-format.md

@@ -59,7 +59,7 @@ awk '/CONTRACT-SURFACE:BEGIN/{f=1;next} /CONTRACT-SURFACE:END/{f=0} f' \
 
 ## Interaction with the review gate
 
-- The `architecture-review` step carries `risk_tags: ["contract"]`, so `sdlc-review-gate` **escalates**
+- The `architecture-review` step carries `risk_tags: ["contract"]`, so `yad-review-gate` **escalates**
   it: owner + 1 reviewer **plus** one `domain-owner` approval per repo in the epic's `repos`.
 - **Staleness:** if the surface block is edited after approvals are recorded, the recomputed hash will
   not match the lock — approvals are stale and the gate drops back to `comment`. Re-lock (Step 5 of the

package/skills/{sdlc-backfill → yad-backfill}/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: sdlc-backfill
-description: 'Build-half Step G of the gated SDLC — backfill: generate specs for already-built features in an existing repo so new work does not break them. Confirm Repomix (the one true CLI subprocess: npx repomix), pack ONE feature at a time (compress + git logs, secret-scan), feed it to AI with a "describe what exists, do not invent" prompt, and write a DRAFT spec marked unverified. Require human approval (reuse sdlc-review-gate) before the spec counts as real. Boundary is auto-proposed from the project convention and human-confirmed. A change is blocked only until the features IT touches have approved specs. Use when the user says "backfill specs", "document an existing feature", or "spec the legacy code".'
+name: yad-backfill
+description: 'Build-half Step G of the gated SDLC — backfill: generate specs for already-built features in an existing repo so new work does not break them. Confirm Repomix (the one true CLI subprocess: npx repomix), pack ONE feature at a time (compress + git logs, secret-scan), feed it to AI with a "describe what exists, do not invent" prompt, and write a DRAFT spec marked unverified. Require human approval (reuse yad-review-gate) before the spec counts as real. Boundary is auto-proposed from the project convention and human-confirmed. A change is blocked only until the features IT touches have approved specs. Use when the user says "backfill specs", "document an existing feature", or "spec the legacy code".'
 ---
 
 # SDLC — Backfill (existing-code specs)
@@ -65,7 +65,7 @@ behaviour.
 
 ### Step 4 — `approve` (human approval — reuse the gate)
 A human reads the draft against the real code and approves it with the same `human_approve` discipline
-as `sdlc-review-gate` (owner + 1 reviewer). On approval set the frontmatter `verified: true` and record
+as `yad-review-gate` (owner + 1 reviewer). On approval set the frontmatter `verified: true` and record
 the approver(s) + date. Only a `verified: true` backfill spec counts as real.
 
 ### Step 5 — `gate` (block changes per touched feature)
@@ -87,5 +87,5 @@ auto-advances; a human owns the approval.
 
 ## Reference
 - The "describe what exists" prompt, the spec shape, and the gate: `references/backfill.md`.
-- The human approval discipline reused: `../sdlc-review-gate/SKILL.md`.
+- The human approval discipline reused: `../yad-review-gate/SKILL.md`.
 - Repomix flags: `RESEARCH-NOTES.md` §3.

package/skills/{sdlc-backfill → yad-backfill}/references/backfill.md

@@ -45,7 +45,7 @@ generated: <YYYY-MM-DD>
 ---
 ```
 
-`verified: false` until a human approves (the `sdlc-review-gate` discipline: owner + 1 reviewer). On
+`verified: false` until a human approves (the `yad-review-gate` discipline: owner + 1 reviewer). On
 approval, set `verified: true` and record the approver(s) + date. Only a `verified: true` backfill spec
 counts as real.
 
@@ -62,5 +62,5 @@ A change is blocked **only until the features it touches** have approved specs
 - For each `src/<feature>/` the diff touches, if `specs/backfill/<feature>/spec.md` exists it must be
   `verified: true`; otherwise **FAIL** (run backfill + approve for that feature first).
 - A feature with **no** `specs/backfill/<feature>/` is not this gate's concern (it is either
-  forward-spec'd via `sdlc-spec`, or not yet being backfilled).
+  forward-spec'd via `yad-spec`, or not yet being backfilled).
 - Fails closed on an unresolvable base ref, like the other gates.

package/skills/{sdlc-backfill → yad-backfill}/templates/checks/backfill-check.sh

@@ -33,7 +33,7 @@ while IFS= read -r f; do
     echo "PASS [backfill]: ${f} has an approved (verified) backfill spec."
   else
     echo "FAIL [backfill]: ${f} is being backfilled but its spec is not yet human-approved (verified: true)."
-    echo "  -> run sdlc-backfill approve for ${spec} before changing this feature."
+    echo "  -> run yad-backfill approve for ${spec} before changing this feature."
     rc=1
   fi
 done <<EOF

package/skills/{sdlc-checks → yad-checks}/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: sdlc-checks
+name: yad-checks
 description: 'Build-half Step C of the gated SDLC — the production-safety check gates. Wire and run the CI gates on a code repo: spec-link (every change links a real story/spec via its Task trailer), contract-check (a diff that changes the contract surface without a Contract-Change + an updated, re-locked contract FAILS and routes back to the architecture gate), build/test/lint, and verified-commits (no unverified commits from unverified users — platform-Verified signature + roster-allowlisted author, on the hub and every repo). The gates are CI-agnostic bash, invoked by GitHub Actions and GitLab CI. Use when the user says "wire the check gates", "run the gates", "require signed commits", or "set up CI checks" for a repo.'
 ---
 
@@ -9,7 +9,7 @@ description: 'Build-half Step C of the gated SDLC — the production-safety chec
 in CI on every PR/MR and must pass before merge (build plan §C). Each is a small, separate check:
 
 1. **spec-link** — the change links a real story/spec: its commits carry a `Task: <story>-<task>`
-   trailer (the convention `sdlc-implement` writes) whose `<story>` resolves to `specs/<story>/link.md`.
+   trailer (the convention `yad-implement` writes) whose `<story>` resolves to `specs/<story>/link.md`.
    No unlinked code reaches merge.
 2. **contract-check** — if the diff changes the **contract surface** (the repo's quoted slice under
    `specs/<story>/contracts/`) without a `Contract-Change: yes` trailer **and** an updated, re-locked
@@ -36,15 +36,15 @@ and GitLab CI. This step is **by hand** in Phase 3 — run the gates with the sk
 - Canonical gate sources live in this skill's `templates/` (the source of truth that gets installed
   into each code repo):
   - `templates/checks/{spec-link,contract-check,build-test-lint,verified-commits}.sh`
-  - `templates/github/sdlc-verified-commits.yml` + `templates/gitlab/sdlc-verified-commits.gitlab-ci.yml`
-    → the standalone hub-side verified-commits CI (installed by `sdlc check --fix` with the hub wiring)
-  - `templates/github/sdlc-checks.yml` → installs to `.github/workflows/sdlc-checks.yml` (marked `# sdlc-managed: sdlc-checks`)
-  - `templates/gitlab/sdlc-checks.gitlab-ci.yml` → includable fragment, installs to `.gitlab/ci/sdlc-checks.yml`
+  - `templates/github/yad-verified-commits.yml` + `templates/gitlab/yad-verified-commits.gitlab-ci.yml`
+    → the standalone hub-side verified-commits CI (installed by `yad check --fix` with the hub wiring)
+  - `templates/github/yad-checks.yml` → installs to `.github/workflows/yad-checks.yml` (marked `# yad-managed: yad-checks`)
+  - `templates/gitlab/yad-checks.gitlab-ci.yml` → includable fragment, installs to `.gitlab/ci/yad-checks.yml`
   - `templates/gitlab/gitlab-ci.include-root.yml` → minimal root written only when no root `.gitlab-ci.yml` exists
   - `templates/gitlab/.gitlab-ci.yml` → legacy standalone root (greenfield single-file option)
 - The gates depend on the conventions from earlier steps: the `Task:`/`Contract-Change:` commit
-  trailers (`sdlc-implement`), the `specs/<story>/link.md` + `contracts/` slice (`sdlc-spec`), and the
-  locked `contract.md` (`sdlc-author-architecture`).
+  trailers (`yad-implement`), the `specs/<story>/link.md` + `contracts/` slice (`yad-spec`), and the
+  locked `contract.md` (`yad-architecture`).
 
 ## Inputs
 
@@ -67,22 +67,22 @@ Copy from this skill's `templates/`:
   there first; the principle is **additive: never edit a foreign CI file**.
 
   **GitHub** (detect by any `.github/workflows/*.y*ml`): our gates live in their own
-  `.github/workflows/sdlc-checks.yml`, which GitHub runs independently of every other workflow, so
+  `.github/workflows/yad-checks.yml`, which GitHub runs independently of every other workflow, so
   "merge" reduces to "do not collide on the path".
-  - No file at our path → copy `templates/github/sdlc-checks.yml` verbatim.
-  - A file at our path whose **first line is `# sdlc-managed: sdlc-checks`** → it is ours; refresh it
+  - No file at our path → copy `templates/github/yad-checks.yml` verbatim.
+  - A file at our path whose **first line is `# yad-managed: yad-checks`** → it is ours; refresh it
     (no-op if unchanged). 
   - A **foreign** file occupies that path/name → write to a non-colliding filename
-    (`sdlc-checks.gen.yml`) and ensure its `name:` does not clash. Never merge jobs into a foreign
+    (`yad-checks.gen.yml`) and ensure its `name:` does not clash. Never merge jobs into a foreign
     workflow; never edit one.
 
   **GitLab** (detect by a root `.gitlab-ci.yml` and/or `.gitlab/ci/*.yml`): install the includable
-  fragment `templates/gitlab/sdlc-checks.gitlab-ci.yml` → `<repo>/.gitlab/ci/sdlc-checks.yml` (its jobs
+  fragment `templates/gitlab/yad-checks.gitlab-ci.yml` → `<repo>/.gitlab/ci/yad-checks.yml` (its jobs
   carry `needs: []` and no `stage:`, so a foreign root `stages:` cannot break or reorder them).
   - No root `.gitlab-ci.yml` → write `templates/gitlab/gitlab-ci.include-root.yml` to
     `<repo>/.gitlab-ci.yml` (a minimal root that only `include:`s our fragment).
   - Root exists → read its top-level `include:`. Add the `include:` key if absent; append
-    `- local: '.gitlab/ci/sdlc-checks.yml'` if the key exists but the entry is missing; **no-op** if it
+    `- local: '.gitlab/ci/yad-checks.yml'` if the key exists but the entry is missing; **no-op** if it
     is already listed. Touch nothing else in the root.
   - If the existing YAML cannot be parsed safely → **STOP** and print the exact include snippet for the
     human to paste (graceful degradation — never guess-edit a pipeline you cannot parse).
@@ -92,8 +92,8 @@ Copy from this skill's `templates/`:
 - Ensure `<repo>/package.json` defines `lint`, `build`, `test` scripts (see `references/check-gates.md`
   for the canonical scripts). **Only ADD a missing script; never overwrite an existing one.**
 
-Re-running `wire` is **idempotent** — markers (`# sdlc-managed: sdlc-checks`,
-`# sdlc-managed-include: sdlc-checks`) and the include-entry check make a second run a no-op.
+Re-running `wire` is **idempotent** — markers (`# yad-managed: yad-checks`,
+`# yad-managed-include: yad-checks`) and the include-entry check make a second run a no-op.
 Commit the wiring on the repo's default branch (it is shared infrastructure, not a task diff).
 
 **The hub is wired the same way.** `repo: hub` wires the hub repo itself (platform from `.sdlc/hub.json`)
@@ -116,9 +116,9 @@ human engineer review (Step E) still own the merge. This skill never edits the e
 
 - **Run standalone** (the Phase 3 default): **stop** here. A clean pass does not advance anything; a
   human takes the next step.
-- **Run by the orchestrator** (`sdlc-run`, Phase 4): this skill still just reports PASS/FAIL — the
+- **Run by the orchestrator** (`yad-run`, Phase 4): this skill still just reports PASS/FAIL — the
   *advance decision* is the orchestrator's, read from the `checks` step's `automation` dial. On a clean
-  pass with `checks` earned to `machine_advance`, `sdlc-run` advances to `engineer-review` on its own;
+  pass with `checks` earned to `machine_advance`, `yad-run` advances to `engineer-review` on its own;
   on any FAIL it halts and pulls in a human (build plan §B). **What the gates check is unchanged** —
   only who decides to proceed after a clean pass.
 
@@ -134,5 +134,5 @@ human engineer review (Step E) still own the merge. This skill never edits the e
 
 ## Reference
 - Gate definitions, the canonical scripts, CI wiring, and the convention map: `references/check-gates.md`.
-- Commit-trailer conventions the gates read: `../sdlc-implement/references/implement-conventions.md`.
-- Contract surface + hash recipe: `../sdlc-author-architecture/references/contract-format.md`.
+- Commit-trailer conventions the gates read: `../yad-implement/references/implement-conventions.md`.
+- Contract surface + hash recipe: `../yad-architecture/references/contract-format.md`.