fix: bound branch follower gate evidence

scripts/native/cicd/branch-follower-gate.mjs

@@ -87,6 +87,7 @@ async function ciTaskRunEvidence(commit) {
       name: pipelineRef,
       taskCount: Array.isArray(pipeline?.spec?.tasks) ? pipeline.spec.tasks.length : null,
       tasks: Array.isArray(pipeline?.spec?.tasks) ? pipeline.spec.tasks.slice(0, 12).map((task) => ({ name: str(task?.name), runAfter: Array.isArray(task?.runAfter) ? task.runAfter.slice(0, 6) : [] })) : [],
+      tasksTruncated: Array.isArray(pipeline?.spec?.tasks) ? pipeline.spec.tasks.length > 12 : false,
     },
     taskRuns: taskSummary,
   };
@@ -264,22 +265,73 @@ function taskRunsSummary(list) {
       taskName: str(item?.metadata?.labels?.["tekton.dev/pipelineTask"]) || str(item?.spec?.taskRef?.name),
       status: str(condition.status) || "Unknown",
       reason: str(condition.reason),
+      startTime: str(item?.status?.startTime),
+      completionTime: str(item?.status?.completionTime),
       durationSeconds: durationSeconds(item?.status?.startTime, item?.status?.completionTime),
     };
   });
   const failed = rows.filter((item) => item.status === "False");
   const active = rows.filter((item) => item.status !== "True" && item.status !== "False");
-  const slow = rows.filter((item) => typeof item.durationSeconds === "number" && item.durationSeconds >= slowTaskSeconds);
+  const slow = rows
+    .filter((item) => typeof item.durationSeconds === "number" && item.durationSeconds >= slowTaskSeconds)
+    .sort((left, right) => (right.durationSeconds || 0) - (left.durationSeconds || 0));
+  const timeline = rows.slice().sort(compareTaskRunRows);
+  const performance = taskRunPerformance(rows);
   return {
     count: rows.length,
     slowThresholdSeconds: slowTaskSeconds,
     failedCount: failed.length,
     activeCount: active.length,
     slowCount: slow.length,
-    failedItems: failed.slice(0, 5),
-    activeItems: active.slice(0, 5),
-    slowItems: slow.slice(0, 5),
-    items: rows.slice(0, 12),
+    failedItems: failed.slice(0, 6).map(compactNamedTaskRunRow),
+    activeItems: active.slice(0, 6).map(compactNamedTaskRunRow),
+    slowItems: slow.slice(0, 6).map(compactNamedTaskRunRow),
+    timeline: timeline.slice(0, 16).map((item) => compactTimelineTaskRunRow(item, performance.firstStart)),
+    timelineTruncated: timeline.length > 16,
+    performance,
+  };
+}
+
+function taskRunPerformance(rows) {
+  const starts = rows.map((item) => Date.parse(item.startTime || "")).filter((value) => Number.isFinite(value));
+  const finishes = rows.map((item) => Date.parse(item.completionTime || "")).filter((value) => Number.isFinite(value));
+  const durations = rows.map((item) => item.durationSeconds).filter((value) => typeof value === "number");
+  const firstStart = starts.length === 0 ? null : new Date(Math.min(...starts)).toISOString();
+  const lastCompletion = finishes.length === 0 ? null : new Date(Math.max(...finishes)).toISOString();
+  return {
+    firstStart,
+    lastCompletion,
+    spanSeconds: firstStart && lastCompletion ? durationSeconds(firstStart, lastCompletion) : null,
+    taskDurationSumSeconds: durations.length === 0 ? null : Math.round(durations.reduce((sum, value) => sum + value, 0) * 10) / 10,
+    maxTaskDurationSeconds: durations.length === 0 ? null : Math.max(...durations),
+  };
+}
+
+function compareTaskRunRows(left, right) {
+  const leftTime = Date.parse(left.startTime || "");
+  const rightTime = Date.parse(right.startTime || "");
+  if (Number.isFinite(leftTime) && Number.isFinite(rightTime) && leftTime !== rightTime) return leftTime - rightTime;
+  if (Number.isFinite(leftTime)) return -1;
+  if (Number.isFinite(rightTime)) return 1;
+  return String(left.name || "").localeCompare(String(right.name || ""));
+}
+
+function compactNamedTaskRunRow(item) {
+  return {
+    name: item.name,
+    taskName: item.taskName,
+    status: item.status,
+    reason: item.reason,
+    durationSeconds: item.durationSeconds,
+  };
+}
+
+function compactTimelineTaskRunRow(item, firstStart) {
+  return {
+    taskName: item.taskName,
+    status: item.status,
+    startOffsetSeconds: firstStart && item.startTime ? durationSeconds(firstStart, item.startTime) : null,
+    durationSeconds: item.durationSeconds,
   };
 }
 

scripts/native/cicd/taskrun-drilldown.mjs

@@ -60,6 +60,7 @@ async function main() {
   const taskRunSteps = stepRows(status);
   const containers = mergeContainerRows(taskRunSteps, podStatuses).slice(0, maxContainers);
   const logContainers = selectLogContainers(containers);
+  const includeLogTails = process.env.INCLUDE_LOG_TAILS === "true" || condition?.status !== "True";
   const logs = [];
   const perContainerBytes = Math.max(1, Math.floor(maxLogBytes / Math.max(1, logContainers.length)));
   for (const container of logContainers) {
@@ -75,7 +76,7 @@ async function main() {
       container: name,
       lineCount: text.length === 0 ? 0 : text.split(/\r?\n/u).filter((line) => line.length > 0).length,
       bytes: Buffer.byteLength(text, "utf8"),
-      tail: text,
+      ...(includeLogTails || read.ok === false ? { tail: text } : {}),
       nodeCicdTiming: lastNodeCicdTiming(text),
     });
   }