@valescoagency/runway 0.14.3 → 0.15.0

package/README.md

@@ -218,6 +218,13 @@ export LINEAR_API_KEY=lin_api_...
 # export RUNWAY_READY_LABEL="ready-for-agent"
 # export RUNWAY_HITL_LABEL="ready-for-human"
 # export RUNWAY_MAX_ITERATIONS=5
+# export RUNWAY_SHEPHERD_ENABLED=true                # VA-460: opt into post-PR shepherd loop (default off)
+# export RUNWAY_SHEPHERD_MAX_ITERATIONS=3            # VA-464: max fix attempts per PR before HITL
+# export RUNWAY_SHEPHERD_MAX_WALL_SECONDS=3600       # VA-464: wall-clock budget per PR before HITL
+# export RUNWAY_SHEPHERD_POLL_INTERVAL_SECONDS=15    # VA-460: polling cadence for the shepherd loop
+# export RUNWAY_PR_REVIEWER_BOT_LOGIN="runway-reviewer-bot"
+#   VA-463: GitHub login of the adversarial PR-reviewer agent.
+#   Unset → all PR comments routed to the human-feedback path.
 # export RUNWAY_COMMENT_AUTHOR_ALLOWLIST="Reviewer Bot,Jane Reviewer"
 #   optional, comma-separated Linear user names whose comments on a
 #   re-queued issue surface as "Review feedback from prior attempts"
@@ -541,7 +548,7 @@ These are tractable, just not v1.
 
 ## Status
 
-0.14.3 — production-shaped and dogfooded against live Linear queues.
+0.15.0 — production-shaped and dogfooded against live Linear queues.
 The end-to-end pipeline (init → run → review → PR) is stable; surface
 may still shift as the orchestrator's policy and iteration mechanics
 mature. See [CHANGELOG.md](./CHANGELOG.md) for per-release detail.

package/dist/config.js

@@ -45,6 +45,23 @@ const configEffect = EConfig.all({
     metaFilterThresholdsJson: EConfig.option(EConfig.string("RUNWAY_META_FILTER_THRESHOLDS")),
     runwayRepoProjectName: EConfig.option(EConfig.string("RUNWAY_REPO_PROJECT_NAME")),
     metaWeeklyModel: EConfig.option(EConfig.string("RUNWAY_META_WEEKLY_MODEL")),
+    // VA-460: feature gate; default `false` for the first ship so the
+    // composer's post-finalize behavior is unchanged until VA-461..463
+    // wire the subscriptions.
+    shepherdEnabled: EConfig.boolean("RUNWAY_SHEPHERD_ENABLED").pipe(EConfig.withDefault(false)),
+    shepherdPollIntervalSeconds: EConfig.integer("RUNWAY_SHEPHERD_POLL_INTERVAL_SECONDS").pipe(EConfig.withDefault(15), EConfig.validate({
+        message: "RUNWAY_SHEPHERD_POLL_INTERVAL_SECONDS must be a positive integer",
+        validation: (n) => n > 0,
+    })),
+    prReviewerBotLogin: EConfig.option(EConfig.string("RUNWAY_PR_REVIEWER_BOT_LOGIN")),
+    shepherdMaxIterations: EConfig.integer("RUNWAY_SHEPHERD_MAX_ITERATIONS").pipe(EConfig.withDefault(3), EConfig.validate({
+        message: "RUNWAY_SHEPHERD_MAX_ITERATIONS must be a positive integer",
+        validation: (n) => n > 0,
+    })),
+    shepherdMaxWallSeconds: EConfig.integer("RUNWAY_SHEPHERD_MAX_WALL_SECONDS").pipe(EConfig.withDefault(3600), EConfig.validate({
+        message: "RUNWAY_SHEPHERD_MAX_WALL_SECONDS must be a positive integer",
+        validation: (n) => n > 0,
+    })),
 }).pipe(Effect.map((raw) => ({
     linearApiKey: raw.linearApiKey,
     opServiceAccountToken: Option.getOrUndefined(raw.opServiceAccountToken),
@@ -66,6 +83,11 @@ const configEffect = EConfig.all({
     metaFilterThresholds: parseMetaFilterThresholdsJson(Option.getOrUndefined(raw.metaFilterThresholdsJson)),
     runwayRepoProjectName: Option.getOrUndefined(raw.runwayRepoProjectName),
     metaWeeklyModel: Option.getOrUndefined(raw.metaWeeklyModel),
+    shepherdEnabled: raw.shepherdEnabled,
+    shepherdPollIntervalSeconds: raw.shepherdPollIntervalSeconds,
+    prReviewerBotLogin: Option.getOrUndefined(raw.prReviewerBotLogin),
+    shepherdMaxIterations: raw.shepherdMaxIterations,
+    shepherdMaxWallSeconds: raw.shepherdMaxWallSeconds,
 })));
 /**
  * VA-359: Context tag for the resolved RunwayConfig. Provided by

package/dist/dashboard/projector.js

@@ -148,6 +148,16 @@ function strArrayAttr(v) {
  * in lock-step with `orchestrator.ts`.
  */
 export const DRAIN_STARTED_LOG = "drain.started";
+/**
+ * VA-465: log body strings the shepherd loop emits at three points.
+ * Each carries structured attributes the projector reads to update
+ * the `shepherding_prs` table. Kept in lock-step with `shepherd.ts`'s
+ * `Effect.logInfo` call sites — drift between the two means the
+ * sub-card stops rendering for the affected lifecycle event.
+ */
+export const SHEPHERD_ITERATION_START_LOG = "shepherd.iteration.start";
+export const SHEPHERD_ITERATION_END_LOG = "shepherd.iteration.end";
+export const SHEPHERD_ENDED_LOG = "shepherd.ended";
 /**
  * VA-455: scan an OTLP logs payload for `drain.started` markers.
  * Each match becomes an `ActiveDrainMarker` carrying the drain's
@@ -188,6 +198,86 @@ export function extractActiveDrainMarkers(payload) {
     }
     return out;
 }
+/**
+ * VA-465: scan an OTLP logs payload for shepherd lifecycle markers.
+ * Three body strings produce three marker kinds; each is tagged so
+ * the server can dispatch to the right storage method. Records
+ * missing trace_id, a recognised body, or a timestamp are dropped —
+ * we won't fabricate any of those.
+ *
+ * Attribute reading is lenient: the gateway encodes numbers as
+ * strings via OTLP's `stringValue`, so we re-parse with
+ * `Number.parseInt`. Missing attributes get sensible defaults
+ * (e.g., empty subscription, null max_iterations) rather than
+ * causing the marker to be dropped — a partial marker is still
+ * useful for the dashboard.
+ */
+export function extractShepherdMarkers(payload) {
+    const out = [];
+    for (const rl of payload.resourceLogs ?? []) {
+        for (const sl of rl.scopeLogs ?? []) {
+            for (const rec of sl.logRecords ?? []) {
+                const body = rec.body?.stringValue;
+                if (body !== SHEPHERD_ITERATION_START_LOG &&
+                    body !== SHEPHERD_ITERATION_END_LOG &&
+                    body !== SHEPHERD_ENDED_LOG) {
+                    continue;
+                }
+                const traceId = rec.traceId?.trim();
+                if (!traceId)
+                    continue;
+                const ts = rec.timeUnixNano ?? rec.observedTimeUnixNano;
+                if (!ts)
+                    continue;
+                const attrs = attributesToStringMap(rec.attributes);
+                const prNumber = Number.parseInt(attrs.pr ?? "", 10);
+                if (!Number.isFinite(prNumber))
+                    continue;
+                if (body === SHEPHERD_ITERATION_START_LOG) {
+                    const iteration = Number.parseInt(attrs.iteration ?? "", 10);
+                    if (!Number.isFinite(iteration))
+                        continue;
+                    const maxIter = Number.parseInt(attrs.maxIterations ?? "", 10);
+                    out.push({
+                        kind: "iteration.start",
+                        traceId,
+                        prNumber,
+                        subscription: attrs.subscription ?? "",
+                        iteration,
+                        maxIterations: Number.isFinite(maxIter) ? maxIter : null,
+                        description: attrs.description ?? "",
+                        timestampUnixNano: ts,
+                    });
+                }
+                else if (body === SHEPHERD_ITERATION_END_LOG) {
+                    const outcome = attrs.outcome === "hitl" ? "hitl" : "fixed";
+                    out.push({
+                        kind: "iteration.end",
+                        traceId,
+                        prNumber,
+                        outcome,
+                        detail: attrs.detail ?? "",
+                        timestampUnixNano: ts,
+                    });
+                }
+                else {
+                    const raw = attrs.outcome;
+                    const outcome = raw === "merged" || raw === "ready" || raw === "hitl"
+                        ? raw
+                        : "hitl"; // Conservative fallback — terminal hitl is the safe default.
+                    out.push({
+                        kind: "ended",
+                        traceId,
+                        prNumber,
+                        outcome,
+                        timestampUnixNano: ts,
+                    });
+                }
+            }
+        }
+    }
+    return out;
+}
 /**
  * VA-388: project an OTLP logs payload into `LogRecordRow`s. Records
  * without a trace_id are dropped — every Effect log emitted under

package/dist/dashboard/server.js

@@ -1,12 +1,21 @@
 import { createServer } from "node:http";
 import { createLinearAdapter, startLinearSync, } from "./linear-sync.js";
 import { createEventBus } from "./events.js";
-import { extractActiveDrainMarkers, projectLogs, projectPayload, } from "./projector.js";
+import { extractActiveDrainMarkers, extractShepherdMarkers, projectLogs, projectPayload, } from "./projector.js";
 import { createStorage, } from "./storage.js";
 import { META_REVIEW_PAGE_SIZE, renderDetailView, renderIssueProcessRows, renderListView, renderLogsSection, renderMetaReviewDetailView, renderMetaReviewListView, } from "./views.js";
 // VA-389: phase spans we surface on the detail page's timeline.
 // Anything else stays in raw_spans for debugging but isn't rendered.
-const DETAIL_PHASE_NAMES = ["review", "pushBranch", "openPullRequest"];
+const DETAIL_PHASE_NAMES = [
+    "review",
+    "pushBranch",
+    "openPullRequest",
+    // VA-460: shepherd span — emitted by runShepherdPass when
+    // `config.shepherdEnabled=true`. Surfaced alongside review so the
+    // operator sees post-finalize loop time on the timeline. Missing
+    // for any issue process whose drain ran without the feature gate.
+    "shepherd",
+];
 const ISSUE_DETAIL_RE = /^\/issue\/([^/?#]+)\/([^/?#]+)\/?$/;
 // VA-387: canonical detail route. `:id` is the issue process span_id;
 // the lookup falls back to the (trace_id, span_id) pair only for
@@ -247,6 +256,39 @@ async function handleOtlpLogs(req, res, storage, events) {
     for (const m of extractActiveDrainMarkers(payload)) {
         storage.markDrainActive(m);
     }
+    // VA-465: shepherd lifecycle markers drive the per-PR sub-card.
+    // Three log bodies map to three storage methods — see
+    // `extractShepherdMarkers` for the body strings.
+    for (const m of extractShepherdMarkers(payload)) {
+        if (m.kind === "iteration.start") {
+            storage.markShepherdIterationStart({
+                traceId: m.traceId,
+                prNumber: m.prNumber,
+                subscription: m.subscription,
+                iteration: m.iteration,
+                maxIterations: m.maxIterations,
+                description: m.description,
+                timestampUnixNano: m.timestampUnixNano,
+            });
+        }
+        else if (m.kind === "iteration.end") {
+            storage.markShepherdIterationEnd({
+                traceId: m.traceId,
+                prNumber: m.prNumber,
+                outcome: m.outcome,
+                detail: m.detail,
+                timestampUnixNano: m.timestampUnixNano,
+            });
+        }
+        else {
+            storage.markShepherdEnded({
+                traceId: m.traceId,
+                prNumber: m.prNumber,
+                outcome: m.outcome,
+                timestampUnixNano: m.timestampUnixNano,
+            });
+        }
+    }
     for (const r of projectLogs(payload)) {
         storage.appendLogRecord(r);
         // VA-391: the SSE detail-pane stream live-tails the Logs section
@@ -380,12 +422,19 @@ function handleListView(req, res, storage, linearEnabled, linearWorkspace) {
     // `drains` row). `null` becomes the "Idle — no active drain"
     // state in views.
     const activeDrain = storage.getActiveDrain();
+    // VA-465: when a drain is active, surface its in-flight shepherding
+    // PRs as a sub-strip under the drain strip. Idle drain → no
+    // shepherd rows to query.
+    const activeShepherding = activeDrain
+        ? storage.getActiveShepherding(activeDrain.traceId)
+        : [];
     const html = renderListView({
         rows,
         linearEnabled,
         todoQueue,
         snapshotsByIdentifier,
         activeDrain,
+        activeShepherding,
         filterState,
         recentDrains,
         isFiltered: isFilteredState(filterState),

package/dist/dashboard/storage.js

@@ -159,6 +159,31 @@ const SCHEMA = `
 
   CREATE INDEX IF NOT EXISTS idx_meta_reviews_kind_created
     ON meta_reviews(kind, created_at DESC);
+
+  -- VA-465: per-PR shepherding state surfaced as a sub-card under the
+  -- active-drain card. One row per (trace_id, pr_number); the watcher
+  -- loop may iterate multiple times per PR before exiting. State
+  -- transitions acting -> ready/merged/hitl; the latter three are
+  -- terminal and set ended_unix_nano. The projector's three
+  -- shepherd.* log markers feed this table; the list view reads
+  -- getActiveShepherding(traceId) (non-terminal rows only).
+  CREATE TABLE IF NOT EXISTS shepherding_prs (
+    trace_id TEXT NOT NULL,
+    pr_number INTEGER NOT NULL,
+    subscription TEXT,
+    iteration INTEGER,
+    max_iterations INTEGER,
+    state TEXT NOT NULL,
+    description TEXT,
+    started_unix_nano TEXT NOT NULL,
+    last_seen_unix_nano TEXT NOT NULL,
+    ended_unix_nano TEXT,
+    inserted_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (trace_id, pr_number)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_shepherding_prs_trace_active
+    ON shepherding_prs(trace_id, ended_unix_nano);
 `;
 const DEFAULT_AGGREGATE_WINDOW = 30;
 /**
@@ -673,6 +698,98 @@ export function createStorage(path, opts = {}) {
     const markDrainActive = (m) => {
         markActiveDrainStmt.run(m.traceId, m.spanId, m.startTimeUnixNano, m.lastSeenUnixNano);
     };
+    // VA-465: shepherd-state prepared statements.
+    //
+    // `markShepherdIterationStartStmt` inserts on first iteration or
+    // updates an existing row to bump the iteration / subscription /
+    // description / last_seen. The CONFLICT branch only overwrites
+    // when (a) the row isn't already terminated AND (b) the incoming
+    // timestamp is newer than the stored last_seen — protects against
+    // out-of-order batch arrival.
+    const markShepherdIterationStartStmt = db.prepare(`
+    INSERT INTO shepherding_prs (
+      trace_id, pr_number, subscription, iteration, max_iterations,
+      state, description, started_unix_nano, last_seen_unix_nano
+    ) VALUES (?, ?, ?, ?, ?, 'acting', ?, ?, ?)
+    ON CONFLICT (trace_id, pr_number) DO UPDATE SET
+      subscription = excluded.subscription,
+      iteration = excluded.iteration,
+      max_iterations = COALESCE(excluded.max_iterations, shepherding_prs.max_iterations),
+      state = 'acting',
+      description = excluded.description,
+      last_seen_unix_nano = excluded.last_seen_unix_nano
+    WHERE shepherding_prs.ended_unix_nano IS NULL
+      AND CAST(shepherding_prs.last_seen_unix_nano AS INTEGER)
+        < CAST(excluded.last_seen_unix_nano AS INTEGER)
+  `);
+    // `markShepherdIterationEndStmt` bumps last_seen + description on
+    // a row that exists. UPDATE-only (no INSERT) — an end without a
+    // start is dropped silently.
+    const markShepherdIterationEndStmt = db.prepare(`
+    UPDATE shepherding_prs
+    SET description = ?, last_seen_unix_nano = ?
+    WHERE trace_id = ? AND pr_number = ?
+      AND ended_unix_nano IS NULL
+      AND CAST(last_seen_unix_nano AS INTEGER) < CAST(? AS INTEGER)
+  `);
+    // `markShepherdEndedStmt` terminates the row. The CASE WHEN guard
+    // protects against a stale end-marker arriving after a fresher
+    // start (which can happen with batched OTLP flushes).
+    const markShepherdEndedStmt = db.prepare(`
+    INSERT INTO shepherding_prs (
+      trace_id, pr_number, state, started_unix_nano,
+      last_seen_unix_nano, ended_unix_nano
+    ) VALUES (?, ?, ?, ?, ?, ?)
+    ON CONFLICT (trace_id, pr_number) DO UPDATE SET
+      state = excluded.state,
+      last_seen_unix_nano = excluded.last_seen_unix_nano,
+      ended_unix_nano = excluded.ended_unix_nano
+    WHERE shepherding_prs.ended_unix_nano IS NULL
+      OR CAST(shepherding_prs.ended_unix_nano AS INTEGER)
+        < CAST(excluded.ended_unix_nano AS INTEGER)
+  `);
+    const getActiveShepherdingStmt = db.prepare(`
+    SELECT
+      trace_id, pr_number, subscription, iteration, max_iterations,
+      state, description, started_unix_nano, last_seen_unix_nano,
+      ended_unix_nano
+    FROM shepherding_prs
+    WHERE trace_id = ? AND ended_unix_nano IS NULL
+    ORDER BY CAST(started_unix_nano AS INTEGER) ASC
+  `);
+    const markShepherdIterationStart = (m) => {
+        markShepherdIterationStartStmt.run(m.traceId, m.prNumber, m.subscription, m.iteration, m.maxIterations, m.description, m.timestampUnixNano, m.timestampUnixNano);
+    };
+    const markShepherdIterationEnd = (m) => {
+        markShepherdIterationEndStmt.run(m.detail, m.timestampUnixNano, m.traceId, m.prNumber, m.timestampUnixNano);
+    };
+    const markShepherdEnded = (m) => {
+        // VA-465: only `merged` terminates the row (sets ended_unix_nano
+        // → excluded from getActiveShepherding). `ready` and `hitl`
+        // leave ended_unix_nano NULL so the sub-strip continues to
+        // render them as "ready, awaiting human merge" / "HITL — needs
+        // human attention" rows while the drain is still active. The
+        // rows naturally disappear when the drain ends, since the list
+        // view only queries getActiveShepherding when activeDrain is
+        // non-null.
+        const endedNano = m.outcome === "merged" ? m.timestampUnixNano : null;
+        markShepherdEndedStmt.run(m.traceId, m.prNumber, m.outcome, m.timestampUnixNano, m.timestampUnixNano, endedNano);
+    };
+    const getActiveShepherding = (traceId) => {
+        const rows = getActiveShepherdingStmt.all(traceId);
+        return rows.map((r) => ({
+            traceId: r.trace_id,
+            prNumber: r.pr_number,
+            subscription: r.subscription,
+            iteration: r.iteration,
+            maxIterations: r.max_iterations,
+            state: r.state,
+            description: r.description,
+            startedUnixNano: r.started_unix_nano,
+            lastSeenUnixNano: r.last_seen_unix_nano,
+            endedUnixNano: r.ended_unix_nano,
+        }));
+    };
     const saveIssueProcess = (p) => {
         insertIssueProcess.run(p.traceId, p.spanId, p.parentSpanId, p.issueIdentifier, p.issueId, p.issueTitle, 
         // VA-387: labels round-trip as a JSON array string. Keeping them
@@ -950,6 +1067,10 @@ export function createStorage(path, opts = {}) {
         appendLogRecord,
         streamLogsFor,
         getActiveDrain,
+        markShepherdIterationStart,
+        markShepherdIterationEnd,
+        markShepherdEnded,
+        getActiveShepherding,
         saveMetaReview,
         listMetaReviews,
         countMetaReviews,

package/dist/dashboard/views.js

@@ -69,7 +69,11 @@ export function renderListView(input) {
         : "";
     // VA-391: drain summary strip renders ABOVE the queue + run list
     // so the operator sees in-flight progress at the top of the page.
-    const drainStrip = renderDrainStrip(vm.activeDrain ?? null);
+    // VA-465: when the drain is active AND has shepherding PRs, a
+    // sub-strip lists each PR's current state below the drain strip.
+    const activeShepherding = vm.activeShepherding ?? [];
+    const drainStrip = renderDrainStrip(vm.activeDrain ?? null) +
+        renderShepherdSubStrip(vm.activeDrain ?? null, activeShepherding);
     // VA-392: filter chips render between the drain strip and the table
     // so the operator can narrow the run list without leaving the page.
     const filterChips = renderFilterChips(filterState, recentDrains);
@@ -100,6 +104,20 @@ export function renderListView(input) {
     .drain-strip .strip-counter strong { color: #e5e5e5; }
     .drain-strip .counter-hitl   strong { color: #facc15; }
     .drain-strip .counter-err    strong { color: #f87171; }
+    /* VA-465: shepherd sub-strip — one row per PR being shepherded. */
+    .shepherd-strip { margin: -10px 0 16px; padding: 0; display: flex; flex-direction: column; gap: 4px; }
+    .shepherd-row { padding: 6px 12px; border: 1px solid #2a2a30;
+                    border-top: none; border-radius: 0 0 4px 4px;
+                    background: #0a0f1c; display: flex; gap: 12px;
+                    align-items: center; font-size: 0.9em; }
+    .shepherd-row .strip-label { color: #9ca3af; }
+    .shepherd-row .shepherd-pr { color: #93c5fd; font-weight: 600; }
+    .shepherd-row .shepherd-iter { color: #d4d4d8; }
+    .shepherd-row .shepherd-state { color: #e5e5e5; }
+    .shepherd-state-ready  { border-color: #4ade80; }
+    .shepherd-state-merged { border-color: #4ade80; opacity: 0.7; }
+    .shepherd-state-hitl   { border-color: #facc15; }
+    .shepherd-state-acting { border-color: #60a5fa; }
     .filters { margin: 0 0 16px; display: flex; flex-direction: column;
                gap: 6px; font-size: 12px; }
     .filter-row { display: flex; align-items: center; gap: 8px;
@@ -166,6 +184,51 @@ export function renderListView(input) {
  * when one is active; otherwise emits the explicit "Idle" indicator
  * so the operator can tell at a glance that no drain is running.
  */
+/**
+ * VA-465: sub-strip under the active-drain card showing per-PR
+ * shepherding state. One row per PR. Empty when no drain is active
+ * or no shepherding rows exist — returns an empty string so the
+ * markup has no orphan container.
+ */
+function renderShepherdSubStrip(active, shepherding) {
+    if (!active || shepherding.length === 0)
+        return "";
+    const lines = shepherding
+        .map((s) => {
+        const stateLabel = shepherdStateLabel(s);
+        return `<div class="shepherd-row shepherd-state-${s.state}">
+        <span class="strip-label">Shepherding</span>
+        <span class="shepherd-pr">PR #${s.prNumber}</span>
+        ${s.iteration !== null
+            ? `<span class="shepherd-iter">iter ${s.iteration}${s.maxIterations !== null ? `/${s.maxIterations}` : ""}</span>`
+            : ""}
+        <span class="shepherd-state">${escapeHtml(stateLabel)}</span>
+      </div>`;
+    })
+        .join("");
+    return `<div class="shepherd-strip">${lines}</div>`;
+}
+function shepherdStateLabel(s) {
+    switch (s.state) {
+        case "acting":
+            // The subscription + description tell the operator WHAT is
+            // happening — a rebase, a CI re-impl, a reviewer-feedback fix.
+            // Both are best-effort; missing ones collapse to the bare verb.
+            if (s.description)
+                return s.description;
+            return s.subscription
+                ? `acting on ${s.subscription}`
+                : "acting";
+        case "ready":
+            return "ready, awaiting human merge";
+        case "merged":
+            return "merged";
+        case "hitl":
+            return "HITL — needs human attention";
+        default:
+            return s.state;
+    }
+}
 function renderDrainStrip(active) {
     if (!active) {
         return `<div class="drain-strip idle">Idle — no active drain</div>`;
@@ -454,6 +517,8 @@ export function renderDetailView(vm) {
     .timeline .phase-implement { background: #60a5fa; }
     .timeline .phase-review    { background: #facc15; }
     .timeline .phase-finalize  { background: #4ade80; }
+    /* VA-460: shepherd phase (post-finalize PR loop). */
+    .timeline .phase-shepherd  { background: #a78bfa; }
     .timeline-legend { font-size: 11px; color: #9ca3af; margin-bottom: 16px; }
     .iter-row td { background: #16161a; padding-left: 32px; }
     .iter-status { font-weight: 600; }
@@ -569,6 +634,17 @@ function computePhases(vm) {
         const endNs = maxBigInt(finalize.map((p) => parseNs(p.endTimeUnixNano)));
         phases.push({ name: "finalize", startNs, endNs });
     }
+    // VA-460: shepherd phase runs after finalize when the feature gate
+    // is on. Only present for drains with `shepherdEnabled=true`; pre-
+    // gate issue processes show the original three phases unchanged.
+    const shepherd = vm.phaseSpans.find((p) => p.name === "shepherd");
+    if (shepherd) {
+        phases.push({
+            name: "shepherd",
+            startNs: parseNs(shepherd.startTimeUnixNano),
+            endNs: parseNs(shepherd.endTimeUnixNano),
+        });
+    }
     return phases;
 }
 function renderPhaseTimeline(phases) {