yadflow 3.11.1 → 3.12.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [3.12.0](https://github.com/abdelrahmannasr/yadflow/compare/v3.11.1...v3.12.0) (2026-07-11)
+
+
+### Features
+
+* render an epic's kind as its noun in next/thread/status ([42e80e1](https://github.com/abdelrahmannasr/yadflow/commit/42e80e19e20e129a2a3941c85db6777a66ab00cc))
+
 ## [3.11.1](https://github.com/abdelrahmannasr/yadflow/compare/v3.11.0...v3.11.1) (2026-07-11)
 
 

package/cli/epic-state.mjs

@@ -755,6 +755,13 @@ export function readFrontmatter(file) {
 
 const asList = (v) => (Array.isArray(v) ? v : v ? [v] : []);
 
+// The human-facing noun for a lineage kind. Presentation only — the artifact is always an epic
+// (`EP-<slug>`); this just renders WHAT KIND of work it is so `yad next`/`yad thread`/`yad status`
+// read as "Defect EP-…" / "Change request EP-…" instead of a generic "Epic". `feature` (and any
+// unknown/absent kind) falls back to "Epic". A bug is a defect (kind:defect) — no separate noun.
+export const KIND_NOUN = { feature: 'Epic', change: 'Change request', defect: 'Defect', hotfix: 'Hotfix' };
+export const kindNoun = (kind) => KIND_NOUN[kind] || 'Epic';
+
 // The lineage of an epic from epic.md frontmatter. `kind` defaults to `feature` (genesis) when absent,
 // so an un-migrated genesis epic behaves as the thread root. Greenfield/missing-safe.
 export function epicLineage(root, epic) {

package/cli/next.mjs

@@ -13,7 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { c, log, ok, info, warn, hand, fail, readJSON, exists } from './lib.mjs';
 import { PROJECT_FILES } from './manifest.mjs';
-import { epicRoot, loadLedger, nextAction, preconditionsMet, isValidEpicId, DISCOVERY_EPIC } from './epic-state.mjs';
+import { epicRoot, loadLedger, nextAction, preconditionsMet, isValidEpicId, epicLineage, kindNoun, DISCOVERY_EPIC } from './epic-state.mjs';
 
 // Is solo mode on? Persisted in hub.json by setup (Phase C/D); default false. Read defensively so a
 // missing/old hub.json never breaks the driver.
@@ -102,7 +102,10 @@ function actionLine(a, { solo } = {}) {
 
 // Full, friendly printout for a single epic.
 function printAction(a, { solo } = {}) {
-  log(`\n  ${c.bold(a.epicId || '(epic)')} ${c.dim(`— ${a.why}`)}`);
+  // Prefix the id with the kind noun (Defect / Change request / Hotfix / Epic) so a glance says what
+  // kind of work this is. The discovery front-zero is not a feature epic — leave it un-prefixed.
+  const noun = a.lineageKind && a.epicId !== DISCOVERY_EPIC ? `${kindNoun(a.lineageKind)} ` : '';
+  log(`\n  ${c.bold(`${noun}${a.epicId || '(epic)'}`)} ${c.dim(`— ${a.why}`)}`);
   // In the build half with live lanes, print each story/repo's next sub-step + remaining chain instead
   // of the single static hint; otherwise the one actionable line.
   if (a.kind === 'build' && a.builds?.length) printBuildLanes(a.builds);
@@ -139,7 +142,10 @@ function generalNext(root, { all } = {}) {
     return;
   }
 
-  const actions = featureEpics.map((id) => nextAction(loadLedger(epicRoot(root, id)), { epic: id }));
+  const actions = featureEpics.map((id) => ({
+    ...nextAction(loadLedger(epicRoot(root, id)), { epic: id }),
+    lineageKind: epicLineage(root, id).kind,
+  }));
   if (discoveryOpen) printAction(discoveryAction, { solo });   // an unfinished discovery comes first
 
   if (featureEpics.length === 1 || all) {
@@ -148,7 +154,7 @@ function generalNext(root, { all } = {}) {
   }
   // Several epics — list each with a one-liner, then point at the per-epic / --all views.
   log(`\n  ${c.bold(`${featureEpics.length} epics`)} ${c.dim('— next action each:')}`);
-  for (const a of actions) log(`    ${c.cyan(a.epicId)}  ${actionLine(a, { solo })}`);
+  for (const a of actions) log(`    ${c.cyan(`${kindNoun(a.lineageKind)} ${a.epicId}`)}  ${actionLine(a, { solo })}`);
   info(c.dim(`detail: ${c.bold('yad next <epic>')}  •  all at once: ${c.bold('yad next --all')}`));
 }
 
@@ -183,5 +189,8 @@ export async function runNext(root, { epic, check, all } = {}) {
     process.exitCode = 1;
     return;
   }
-  printAction(nextAction(loadLedger(epicDir), { epic }), { solo: isSolo(root) });
+  printAction(
+    { ...nextAction(loadLedger(epicDir), { epic }), lineageKind: epicLineage(root, epic).kind },
+    { solo: isSolo(root) },
+  );
 }

package/cli/thread.mjs

@@ -7,7 +7,7 @@ import fs from 'node:fs';
 import { c, log, ok, info, warn, hand, readJSON, exists } from './lib.mjs';
 import { readShips } from './ledger.mjs';
 import {
-  epicRoot, isValidEpicId, epicLineage, readFrontmatter, isStubEpic,
+  epicRoot, isValidEpicId, epicLineage, readFrontmatter, isStubEpic, kindNoun,
   resolveThread, threadEpics, resolveCurrentArtifacts, resolveCurrentStories, THREAD_ARTIFACT_BASES,
 } from './epic-state.mjs';
 
@@ -73,7 +73,10 @@ export function threadSummary(root, threadOrEpic) {
   };
 }
 
-const KIND_TAG = { feature: c.green('feature'), change: c.cyan('change'), defect: c.yellow('defect'), hotfix: c.red('hotfix') };
+// Colour a node's kind noun for the tree render. The noun words live in one place (`kindNoun`); this
+// only layers the per-kind colour on top, so the two never drift. Unknown kind → uncoloured noun.
+const KIND_COLOR = { feature: c.green, change: c.cyan, defect: c.yellow, hotfix: c.red };
+const kindTag = (kind) => (KIND_COLOR[kind] || ((s) => s))(kindNoun(kind));
 
 export async function runThread(root, { epic, json = false } = {}) {
   if (!epic) {
@@ -103,7 +106,7 @@ export async function runThread(root, { epic, json = false } = {}) {
   log(c.bold(`\nThread ${s.thread}`) + c.dim('  (genesis → tip)'));
   if (s.broken) log(c.red(`  ✗ broken lineage: ${s.broken}`));
   for (const n of s.nodes) {
-    const tag = KIND_TAG[n.kind] || n.kind;
+    const tag = kindTag(n.kind);
     const seal = n.sealed ? c.dim(' [sealed]') : '';
     const stub = n.stub ? c.yellow(' [stub · backfill pending]') : '';
     const dep = n.depth ? c.dim(` ${n.depth}`) : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yadflow",
-  "version": "3.11.1",
+  "version": "3.12.0",
   "description": "Yadflow — the gated, team, multi-repo SDLC: author → review → build with a PR-driven review gate and a zero-dependency `yad` CLI (setup, gate, commit, open-pr, ship, repo, thread, reconcile). A BMAD module + 38 yad-* skills.",
   "type": "module",
   "author": "AbdelRahman Nasr",

package/skills/yad-status/SKILL.md

@@ -35,8 +35,11 @@ Do not modify any of them.
 ### Step 3 — Report
 Print, in this order:
 
-1. **Epic:** `epicId`, `status` from `epic.md` frontmatter, `currentStep`, and `repos` (the touched
-   domains).
+1. **Header:** render the kind noun from `epic.md` frontmatter `kind` — **Change request** (`change`),
+   **Defect** (`defect`), **Hotfix** (`hotfix`), or **Epic** (`feature`, and the default when `kind` is
+   absent) — followed by `epicId`, then `status` from `epic.md` frontmatter, `currentStep`, and `repos`
+   (the touched domains). Example: `Defect EP-istifta-queue-filter — draft @ stories`. A bug is a defect
+   (`kind: defect`) — there is no separate noun. This is presentation only; the artifact is still an epic.
 2. **Steps table** — for every front step in `steps[]` order (10, or 12 when the optional analysis step
    was run): `id`, `type`, `status`, `assistance`, `automation`, `locked`, and `risk_tags`. Mark the
    `currentStep` with `→`. The gating chain is `[analysis → analysis-review →] epic → epic-review →

package/skills/yad-timeline/SKILL.md

@@ -48,7 +48,9 @@ deterministically; theme from the design system). The thread maps onto the shell
   = what it re-authored, its side-effects = the ships it produced + any contract re-lock.
 - **System components** = the artifacts (epic/architecture/contract/ui/stories/test-cases), each labelled
   with the epic that currently **owns** it (from the resolved map).
-- Colour nodes by `kind` (feature/change/defect/hotfix); mark sealed epics and open debt.
+- Label and colour nodes by `kind` — render each node's kind noun (**Change request** / **Defect** /
+  **Hotfix** / **Epic** for feature) alongside its id, not the generic word "epic"; mark sealed epics and
+  open debt. (A bug is a defect — `kind: defect`. Presentation only; every node is still an epic.)
 
 ### Step 4 — Emit `thread-resolved.md` (the current-truth map — derived, non-authoritative)
 Write `epics/<thread>/thread-resolved.md`: for each artifact base, the **owning epic** (the latest in the
@@ -58,7 +60,7 @@ is the file the next `yad-change` / `yad-epic` reads as "the feature's current t
 
 ### Step 5 — Emit `TIMELINE.md` + (optional) deploy
 Write a short `epics/<thread>/TIMELINE.md` (the chain, what each node changed, ships, open debt) for a
-plain-text read. On `action: deploy`, `yad docs deploy` the site (build-only when no target).
+plain-text read — head each node with its kind noun (Change request / Defect / Hotfix / Epic) + id. On `action: deploy`, `yad docs deploy` the site (build-only when no target).
 
 ## Hard rules