valent-pipeline 0.5.5 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "valent-pipeline",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "description": "v3 multi-agent AI pipeline for software development lifecycle",
   "type": "module",
   "bin": {

package/src/board/public/app.js

@@ -90,9 +90,16 @@ function statusKind(status, column) {
 /* ---------- Chips ----------------------------------------------------------------------- */
 function statusChip(story) {
   const k = statusKind(story.status, story.column);
-  return h('span', { class: `chip chip--status ${k.cls}`, title: `status: ${k.label}` },
+  // When the status was inferred from on-disk artifacts (backlog status lags an in-flight groom),
+  // mark it so the board reads honestly: a dotted chip + a title explaining the real backlog state.
+  const inferred = story.status_source === 'artifacts';
+  const title = inferred
+    ? `status: ${k.label} (inferred from artifacts — backlog still says ${story.backlog_status || 'pending'})`
+    : `status: ${k.label}`;
+  return h('span', { class: `chip chip--status ${k.cls}${inferred ? ' chip--inferred' : ''}`, title },
     h('span', { class: 'chip__icon', 'aria-hidden': 'true' }, k.icon),
     k.label,
+    inferred ? h('span', { class: 'chip__inferred-mark', 'aria-hidden': 'true', title: 'inferred' }, '~') : null,
   );
 }
 

package/src/board/public/styles.css

@@ -457,6 +457,11 @@ body {
 .chip--status.is-idle { color: var(--ink-muted); background: var(--idle-soft); border-color: transparent; }
 .chip--status.is-warn { color: var(--warn); background: var(--warn-soft); border-color: transparent; }
 
+/* Inferred status — derived from on-disk artifacts because the backlog status lags an active
+   groom. Dashed outline + a faint "~" mark signals "best-effort, not yet persisted". */
+.chip--status.chip--inferred { border: 1px dashed currentColor; }
+.chip__inferred-mark { opacity: 0.6; font-weight: 600; margin-left: 1px; }
+
 /* ---------- Backlog list ---------------------------------------------------------------- */
 .backlog {
   max-width: 1100px;

package/src/lib/board.js

@@ -60,6 +60,30 @@ export function columnForStatus(status) {
   return STATUS_TO_COLUMN.get(status) || 'other'
 }
 
+/**
+ * Grooming artifacts, most-advanced phase first. Their presence means a story is mid-groom even
+ * when the backlog `status` still says `pending` — the Workflow path (plan.workflow.js) grooms
+ * the batch in-memory and only persists `status: groomed` at the very end, so the backlog status
+ * lags reality during a live groom (and there is often no pipeline-state.json at all). The board
+ * is a projection, so it infers the grooming phase from the artifacts the groom agents have
+ * already written, exactly as it overlays the live current_story over a lagging backlog.
+ */
+const GROOMING_ARTIFACT_STATUS = [
+  ['readiness-review.md', 'readiness-review'],
+  ['qa-test-spec.md', 'test-case-development'],
+  ['uxa-spec.md', 'ux-spec'],
+  ['reqs-brief.md', 'requirements-spec'],
+]
+
+/** The most-advanced grooming status implied by present artifacts, or null if none. */
+export function inferGroomingStatus(artifacts) {
+  if (!Array.isArray(artifacts)) return null
+  for (const [file, status] of GROOMING_ARTIFACT_STATUS) {
+    if (artifacts.includes(file)) return status
+  }
+  return null
+}
+
 /** Story points, tolerating either field name (matches sprint.js `pointsOf`). */
 function pointsOf(item) {
   const p = item.points ?? item.story_points
@@ -74,10 +98,29 @@ function depsOf(item) {
 /** Normalize one backlog item into a board story (stable shape regardless of input quirks). */
 function normalizeStory(item, artifactsByStory) {
   const id = item.id
-  const status = item.status || 'pending'
+  const backlogStatus = item.status || 'pending'
+  const artifacts = (artifactsByStory && artifactsByStory[id]) || []
+
+  // Reflect an in-flight groom the backlog status hasn't caught up to: if a story still reads
+  // `pending` (its column would be Backlog) but grooming artifacts already exist on disk, surface
+  // the inferred grooming phase so it shows in Grooming instead of sitting in Backlog. An explicit
+  // forward status (groomed/sprint-planned/development/…/shipped) always wins — only `pending` is
+  // upgraded, and `status_source` records that the status was derived, not read from the backlog.
+  let status = backlogStatus
+  let statusSource = 'backlog'
+  if (columnForStatus(backlogStatus) === 'backlog') {
+    const inferred = inferGroomingStatus(artifacts)
+    if (inferred) {
+      status = inferred
+      statusSource = 'artifacts'
+    }
+  }
+
   return {
     id,
     status,
+    backlog_status: backlogStatus,
+    status_source: statusSource,
     column: columnForStatus(status),
     depends_on: depsOf(item),
     points: pointsOf(item),
@@ -88,7 +131,7 @@ function normalizeStory(item, artifactsByStory) {
     active: false, // set true below if it matches current_story
     phase: null, // overlaid from current_story when active
     branch: null,
-    artifacts: (artifactsByStory && artifactsByStory[id]) || [],
+    artifacts,
     cost: null, // { tokens, agent_ms, invocations, roles:[...] } when an audit report is supplied
   }
 }