@nanobpm/nano-workforce 0.206.4 → 0.207.0

package/operations/retryIncident.test.ts

@@ -0,0 +1,280 @@
+// Tests for POST /app/api/actions/incident/retry — operationId `retryIncident` (issue #931).
+//
+// The app-owned, RECORD-AWARE incident-retry door. Before it, unsticking an incident-parked loop
+// meant hand-calling engine REST — `PATCH /v2/jobs/<k> {changeset:{retries:1}}` + `POST
+// /v2/incidents/<k>/resolution` — with no app door at all (the two observed incidents on merlin sat
+// dead for 1.3h / 5h partly because nothing surfaced them and nothing offered the retry). This
+// delegate wraps exactly that two-call remedy in one operator action:
+//   1. resolve the ACTIVE incident on the tracked record's instance (404 when no tracked record
+//      owns the key — we never retry an instance we don't track; 409 when the instance carries no
+//      active incident — nothing to retry),
+//   2. bump the failed job's retries (a JOB_NO_RETRIES incident parks until the job has retries
+//      again) and resolve the incident,
+//   3. clear the mirrored incident columns off the record row immediately, so the `/status` row
+//      leaves `incident` on the action's return instead of waiting out a poll tick.
+import { test } from "node:test";
+import { assert, assertEquals } from "#test-assert";
+import type { AppApi } from "@nanobpm/urban";
+import { noopLog } from "../test/log.ts";
+import { withTrackingViews } from "../test/trackingViews.ts";
+
+/** The engine base every test here targets — set BEFORE the delegate module is (lazily) imported,
+ *  since the engine REST address is resolved at module load. */
+const ENGINE = "http://engine.test/v2";
+process.env["CAMUNDA_REST_ADDRESS"] = ENGINE;
+/** A shared secret IS configured for every test here: the door is reached by the declarative
+ *  "Retry incident" page action, which cannot attach `x-hook-secret`, so the door must stay
+ *  reachable without it (PR #938 review) — every header-less call below proves it does. */
+process.env["NANO_PR_WEBHOOK_SECRET"] = "s3cret";
+
+const { default: handler } = await import("./retryIncident.ts");
+
+interface EngineCall {
+  method: string;
+  url: string;
+  body?: unknown;
+}
+
+/** A fetch stub serving the engine's Camunda-8 v2 REST surface for one instance: the ACTIVE
+ *  incident search, the job retries PATCH, and the incident resolution POST. */
+function engineFetch(
+  byInstance: Record<string, unknown[]>,
+  calls: EngineCall[],
+  opts: { failPatch?: boolean; failResolve?: boolean } = {},
+) {
+  return (url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    const u = typeof url === "string" ? url : url.toString();
+    const json = (body: unknown, status = 200) =>
+      status === 204
+        ? new Response(null, { status: 204 })
+        : new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+    if (u.endsWith("/incidents/search")) {
+      const body = JSON.parse(String(init?.body ?? "{}")) as { filter?: { processInstanceKey?: string } };
+      calls.push({ method: "POST", url: u, body });
+      return Promise.resolve(json({ items: byInstance[body.filter?.processInstanceKey ?? ""] ?? [] }));
+    }
+    const jobPatch = u.match(/\/jobs\/([^/]+)$/);
+    if (jobPatch && init?.method === "PATCH") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      calls.push({ method: "PATCH", url: u, body });
+      return Promise.resolve(opts.failPatch ? json({ detail: "no such job" }, 404) : json({}, 204));
+    }
+    const resolution = u.match(/\/incidents\/([^/]+)\/resolution$/);
+    if (resolution) {
+      calls.push({ method: "POST", url: u });
+      return Promise.resolve(opts.failResolve ? json({ detail: "engine unhappy" }, 500) : json({}, 204));
+    }
+    throw new Error(`unexpected fetch: ${init?.method ?? "GET"} ${u}`);
+  };
+}
+
+function memTable(rows: any[], key: string) {
+  return {
+    get: (k: any) => Promise.resolve(rows.find((r) => r[key] === k) ?? null),
+    all: () => Promise.resolve([...rows]),
+    find: (q: any) =>
+      Promise.resolve(rows.filter((r) => Object.entries(q).every(([f, v]) => r[f] === v))),
+    findOne: (q: any) =>
+      Promise.resolve(rows.find((r) => Object.entries(q).every(([f, v]) => r[f] === v)) ?? null),
+    insert: (r: any) => {
+      rows.push(r);
+      return Promise.resolve(r);
+    },
+    update: (k: any, patch: any) => {
+      const r = rows.find((x) => x[key] === k);
+      if (r) Object.assign(r, patch);
+      return Promise.resolve(r);
+    },
+    delete: (k: any) => {
+      for (let i = rows.length - 1; i >= 0; i--) if (rows[i][key] === k) rows.splice(i, 1);
+      return Promise.resolve();
+    },
+  };
+}
+
+function prRow(over: Record<string, unknown> = {}) {
+  return {
+    pr_key: "owner/repo#1",
+    repo: "owner/repo",
+    number: 1,
+    url: "https://github.com/owner/repo/pull/1",
+    title: "t",
+    status: "converging",
+    current_round: 1,
+    process_key: "PI-1",
+    incident_key: "598235",
+    incident_type: "JOB_NO_RETRIES",
+    incident_message: 'agent "nano-coder" failed: idle',
+    incident_since: "2026-11-09T01:00:00.000Z",
+    updated_at: "2024-01-01",
+    ...over,
+  };
+}
+
+function memApp(stores: Record<string, { rows: any[]; key: string }>): AppApi {
+  return {
+    data: {
+      table: withTrackingViews((name: string, key: string) => memTable(stores[name]?.rows ?? [], stores[name]?.key ?? key)),
+      hasDefaultSource: () => true,
+    },
+    log: noopLog(),
+  } as unknown as AppApi;
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: test-only invocation shim for the delegate.
+async function call(app: AppApi, body: unknown, headers: Record<string, string> = {}): Promise<any> {
+  const req = { method: "POST", path: "/app/api/actions/incident/retry", headers: new Headers(headers) };
+  // biome-ignore lint/suspicious/noExplicitAny: test-only invocation shim for the delegate.
+  return await handler({ req: req as any, params: {}, query: {}, body } as any, app);
+}
+
+const ACTIVE_INCIDENT = {
+  incidentKey: "598235",
+  errorType: "JOB_NO_RETRIES",
+  errorMessage: 'agent "nano-coder" failed: idle',
+  state: "ACTIVE",
+  creationTime: "2026-11-09T01:00:00.000Z",
+  jobKey: "595995",
+};
+
+test("a missing/non-string processInstanceKey → 400 and never touches the engine", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-1": [ACTIVE_INCIDENT] }, calls) as typeof fetch;
+  const app = memApp({ pull_requests: { rows: [prRow()], key: "pr_key" } });
+  try {
+    assertEquals((await call(app, {})).status, 400);
+    assertEquals((await call(app, { processInstanceKey: "  " })).status, 400);
+    assertEquals((await call(app, { processInstanceKey: 2985 })).status, 400);
+    assertEquals((await call(app, undefined)).status, 400);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(calls.length, 0, "no engine call without a valid key");
+});
+
+test("a key no tracked record owns → 404 and never touches the engine", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({}, calls) as typeof fetch;
+  const app = memApp({ pull_requests: { rows: [prRow()], key: "pr_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-UNKNOWN" });
+    assertEquals(res.status, 404);
+    assertEquals(res.body.ok, false);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(calls.length, 0, "an untracked key never reaches the engine");
+});
+
+test("an instance with no ACTIVE incident → 409 (nothing to retry), no mutation", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-1": [] }, calls) as typeof fetch;
+  const row = prRow({ incident_key: null, incident_type: null, incident_message: null, incident_since: null });
+  const app = memApp({ pull_requests: { rows: [row], key: "pr_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-1" });
+    assertEquals(res.status, 409);
+    assertEquals(res.body.ok, false);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(calls.length, 1, "only the incident search ran");
+  assertEquals(calls[0].url.endsWith("/incidents/search"), true);
+});
+
+test("the happy path: bumps the failed job's retries, resolves the incident, and clears the mirrored row", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-1": [ACTIVE_INCIDENT] }, calls) as typeof fetch;
+  const row = prRow();
+  const app = memApp({ pull_requests: { rows: [row], key: "pr_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-1" });
+    assertEquals(res.status, 200);
+    assertEquals(res.body.ok, true);
+    assertEquals(res.body.processInstanceKey, "PI-1");
+    assertEquals(res.body.incidentKey, "598235");
+    assertEquals(res.body.jobKey, "595995");
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  // Exactly the manual remedy, in order: search → PATCH retries → POST resolution.
+  assertEquals(calls.map((c) => `${c.method} ${c.url}`), [
+    "POST http://engine.test/v2/incidents/search",
+    "PATCH http://engine.test/v2/jobs/595995",
+    "POST http://engine.test/v2/incidents/598235/resolution",
+  ]);
+  assertEquals(calls[1].body, { changeset: { retries: 1 } });
+  // The mirrored row columns clear immediately — the /status row leaves `incident` on return.
+  assertEquals(row.incident_key, null);
+  assertEquals(row.incident_type, null);
+  assertEquals(row.incident_message, null);
+  assertEquals(row.incident_since, null);
+});
+
+test("a retries-bump failure → 502 and the incident is NOT resolved (no half-applied remedy)", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-1": [ACTIVE_INCIDENT] }, calls, { failPatch: true }) as typeof fetch;
+  const row = prRow();
+  const app = memApp({ pull_requests: { rows: [row], key: "pr_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-1" });
+    assertEquals(res.status, 502);
+    assertEquals(res.body.ok, false);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(
+    calls.some((c) => c.url.endsWith("/resolution")),
+    false,
+    "the incident is left ACTIVE when the job could not be given retries",
+  );
+  // The row keeps its incident mirror — the incident is still real.
+  assertEquals(row.incident_key, "598235");
+});
+
+test("a resolution failure after a successful retries bump → 502, row keeps the mirror (the next poll reconciles)", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-1": [ACTIVE_INCIDENT] }, calls, { failResolve: true }) as typeof fetch;
+  const row = prRow();
+  const app = memApp({ pull_requests: { rows: [row], key: "pr_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-1" });
+    assertEquals(res.status, 502);
+    assertEquals(res.body.ok, false);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(row.incident_key, "598235", "the mirror stays until the engine confirms resolution");
+});
+
+test("a delivery-graph run's incident retries through the same door", async () => {
+  const calls: EngineCall[] = [];
+  const prevFetch = globalThis.fetch;
+  globalThis.fetch = engineFetch({ "PI-DG-1": [ACTIVE_INCIDENT] }, calls) as typeof fetch;
+  const run = {
+    run_key: "dg-1",
+    status: "running",
+    process_key: "PI-DG-1",
+    incident_key: "598235",
+    incident_type: "JOB_NO_RETRIES",
+    incident_message: "delivery node job exhausted retries",
+    incident_since: "2026-11-09T03:00:00.000Z",
+    updated_at: "t0",
+  };
+  const app = memApp({ delivery_graph_runs: { rows: [run], key: "run_key" } });
+  try {
+    const res = await call(app, { processInstanceKey: "PI-DG-1" });
+    assertEquals(res.status, 200);
+    assertEquals(res.body.ok, true);
+  } finally {
+    globalThis.fetch = prevFetch;
+  }
+  assertEquals(run.incident_key, null);
+  assertEquals(run.incident_since, null);
+});

package/operations/retryIncident.ts

@@ -0,0 +1,201 @@
+// POST /app/api/actions/incident/retry → operationId `retryIncident` (issue #931).
+//
+// The app-owned, RECORD-AWARE incident-retry door. A convergence/merge/delivery instance parked on
+// an engine incident used to need a hand-run engine-REST remedy — `PATCH /v2/jobs/<k>
+// {changeset:{retries:1}}` to give the failed job a retry, then `POST /v2/incidents/<k>/resolution`
+// — which is exactly what the two merlin incidents (nano-bpm#1452 loop 576515, nano-workforce#930
+// loop 594789) sat waiting on for hours. This delegate wraps that two-call remedy in ONE operator
+// action the UI's per-row "Retry incident" button and an operator/agent can call:
+//
+//   1. Resolve the tracked record owning `processInstanceKey` (the SAME `resolveTrackedInstance`
+//      the cancel door uses, issue #705) — a key no tracked record owns is a clean 404 no-op; we
+//      never retry an instance we don't track.
+//   2. Read the instance's OLDEST ACTIVE incident off the engine (`fetchActiveIncident`, the SAME
+//      reader the poller's `pollIncidents` pass mirrors from, so the door and the mirror can never
+//      disagree about WHICH incident is being retried). No active incident → 409 (nothing to
+//      retry — it may already be resolved).
+//   3. Bump the failed job's retries (a `JOB_NO_RETRIES` incident parks until the job can be
+//      retried) and resolve the incident. A failed bump aborts BEFORE the resolution — resolving
+//      without retries would re-incident instantly, a half-applied remedy.
+//   4. Clear the mirrored `incident_*` columns off the record row immediately, so the `/status`
+//      row leaves `incident` on the action's return rather than waiting out a poll tick (the next
+//      `pollIncidents` pass re-mirrors if the engine still reports an active incident — the row
+//      can never lie for more than a tick).
+//
+// The runtime validates the body against openapi.yaml (`processInstanceKey` required).
+//
+// This door is INTENTIONALLY UNGUARDED by the optional NANO_PR_WEBHOOK_SECRET / x-hook-secret
+// header (PR #938 review). Its primary caller is the declarative per-row "Retry incident" page
+// action (home / overview / delivery-graphs), and the `@nanobpm/urban` page runtime structurally
+// cannot attach a custom header — a guard here would 401 every button press on a secured
+// deployment, making the one-click remedy dead exactly where it is needed (the same reasoning as
+// `saveToLibrary`). The posture matches the runtime's built-in `/app/actions/cancel` page action the
+// same rows already expose, which is a strictly MORE destructive, equally unguarded UI mutation.
+// The blast radius is bounded by construction: only an instance a tracked record owns (404
+// otherwise) with an ACTIVE engine incident (409 otherwise) is touched, and the only effect is the
+// retry the incident is already waiting for. The door remains operator-only: it is excluded from
+// the projected MCP tool surface (`x-mcp`, see app/mcpExclusions.test.ts).
+
+import type { DataLayer } from "@nanobpm/urban";
+import { resolveEngineAddress } from "../app/enginePreflight.ts";
+import { resolveTrackedInstance } from "../app/instanceTracking.ts";
+import { fetchActiveIncident, type IncidentSearchItem } from "../app/service.ts";
+import { envVar } from "../app/version.ts";
+import { defineOperation } from "../nano-generated/operations.ts";
+
+// The engine REST base + auth the remedy calls run against, resolved ONCE at module load exactly as
+// main.ts wires the poller (`resolveEngineAddress` — CAMUNDA_REST_ADDRESS wins, else
+// NANOBPMN_BASE_URL + /v2 — and the CAMUNDA_TOKEN bearer).
+const ENGINE_BASE = resolveEngineAddress().restAddress.replace(/\/+$/, "");
+const ENGINE_HEADERS: Record<string, string> = { "content-type": "application/json" };
+{
+  const token = envVar("CAMUNDA_TOKEN");
+  if (token) ENGINE_HEADERS.authorization = `Bearer ${token}`;
+}
+
+/** The mirrored incident columns cleared off the record row after a confirmed resolution — the
+ *  same all-four null write `pollIncidents`' clearing path makes, so the two can never drift. */
+const INCIDENT_CLEARED = {
+  incident_key: null,
+  incident_type: null,
+  incident_message: null,
+  incident_since: null,
+} as const;
+
+export default defineOperation("retryIncident", async ({ body }, app) => {
+  if (!app.data) {
+    app.log.warn("retryIncident: no data source configured — cannot resolve the record");
+    return { status: 503, body: { error: "no data source configured" } };
+  }
+
+  // Require a STRING key (mirrors cancelInstance): engine keys are 64-bit and a numeric JSON value
+  // would already have lost precision before it reached us — reject rather than coerce.
+  const raw = body && typeof body === "object" ? body.processInstanceKey : undefined;
+  const processInstanceKey = typeof raw === "string" ? raw.trim() : "";
+  if (!processInstanceKey) {
+    return { status: 400, body: { error: "processInstanceKey is required and must be a string" } };
+  }
+
+  // Resolve which tracked aggregate (PR / delivery run / …) this key belongs to BEFORE touching the
+  // engine. A key that maps to NO tracked record is a clean 404 no-op — we never retry an instance
+  // we don't track (mirrors cancelInstance, issue #705).
+  const record = await resolveTrackedInstance(app.data, processInstanceKey);
+  if (!record) {
+    app.log.warn("retryIncident: no tracked record for processInstanceKey — no-op", { processInstanceKey });
+    return {
+      status: 404,
+      body: { ok: false, processInstanceKey, error: "no tracked record for processInstanceKey" },
+    };
+  }
+
+  // Read the instance's OLDEST ACTIVE incident off the engine — the SAME reader the poller mirrors
+  // from, so the door retries exactly the incident the row shows. `undefined` = transport unhappy →
+  // 502 (unknown, retry the action); `null` = no active incident → 409 (nothing to retry).
+  let active: IncidentSearchItem | null | undefined;
+  try {
+    active = await fetchActiveIncident(ENGINE_BASE, ENGINE_HEADERS, processInstanceKey);
+  } catch (err) {
+    app.log.warn("retryIncident: incident search failed", { processInstanceKey, error: String(err) });
+    return { status: 502, body: { ok: false, processInstanceKey, error: `incident search failed: ${String(err)}` } };
+  }
+  if (active === undefined) {
+    return { status: 502, body: { ok: false, processInstanceKey, error: "engine incident search unavailable" } };
+  }
+  if (!active?.incidentKey) {
+    return { status: 409, body: { ok: false, processInstanceKey, error: "no active incident on this instance" } };
+  }
+  const incidentKey = active.incidentKey;
+  const jobKey = active.jobKey ?? null;
+
+  // The remedy, in order: give the failed job a retry, THEN resolve the incident. A failed bump
+  // aborts before the resolution — resolving a JOB_NO_RETRIES incident without retries would
+  // re-incident instantly, a half-applied remedy that reads as success.
+  if (jobKey) {
+    const patch = await fetch(`${ENGINE_BASE}/jobs/${jobKey}`, {
+      method: "PATCH",
+      headers: ENGINE_HEADERS,
+      body: JSON.stringify({ changeset: { retries: 1 } }),
+    });
+    if (!patch.ok) {
+      app.log.warn("retryIncident: job retries bump failed", { processInstanceKey, jobKey, status: patch.status });
+      return {
+        status: 502,
+        body: {
+          ok: false,
+          processInstanceKey,
+          incidentKey,
+          jobKey,
+          error: `job retries bump failed (engine ${patch.status}) — incident left ACTIVE`,
+        },
+      };
+    }
+  }
+  const resolution = await fetch(`${ENGINE_BASE}/incidents/${incidentKey}/resolution`, {
+    method: "POST",
+    headers: ENGINE_HEADERS,
+  });
+  if (!resolution.ok) {
+    app.log.warn("retryIncident: incident resolution failed", { processInstanceKey, incidentKey, status: resolution.status });
+    return {
+      status: 502,
+      body: {
+        ok: false,
+        processInstanceKey,
+        incidentKey,
+        jobKey,
+        error: `incident resolution failed (engine ${resolution.status}) — the mirror stays until the engine confirms`,
+      },
+    };
+  }
+
+  // The engine confirmed the resolution: clear the mirrored columns off the record row NOW so the
+  // `/status` row leaves `incident` on this action's return. The next pollIncidents pass re-mirrors
+  // if the engine still reports an active incident, so this can never paper over a real one. The
+  // record row is the one `resolveTrackedInstance` matched on the tracking VIEW — re-read it off
+  // the base table by the SAME instance key, then update by the table's primary key.
+  const cleared = await clearMirroredIncident(app.data, record.table, processInstanceKey);
+  if (!cleared) {
+    app.log.warn("retryIncident: resolved but the mirrored row could not be cleared (the next poll reconciles)", {
+      processInstanceKey,
+      table: record.table,
+    });
+  }
+
+  app.log.info("retryIncident: incident resolved and job retried", { processInstanceKey, incidentKey, jobKey });
+  return { status: 200, body: { ok: true, processInstanceKey, incidentKey, jobKey } };
+});
+
+/** Clear the four mirrored incident columns off the tracked record owning `processInstanceKey`.
+ *  Only the incident-watched aggregates carry the columns (PRs since #94/#931, delivery-graph runs
+ *  since #931); any other tracked table has no mirror to clear and is a no-op. Returns false when
+ *  the row could not be found/updated (the next poll reconciles regardless). */
+async function clearMirroredIncident(
+  data: DataLayer,
+  table: string,
+  processInstanceKey: string,
+): Promise<boolean> {
+  const pkField = incidentMirrorPrimaryKeyFor(table);
+  if (!pkField) return true; // not an incident-watched aggregate — nothing to clear
+  const rows = await data.table<Record<string, unknown>>(table, pkField).find({ process_key: processInstanceKey });
+  const row = rows[0];
+  if (!row) return false;
+  const pk = row[pkField];
+  if (typeof pk !== "string" && typeof pk !== "number") return false;
+  await data.table(table, pkField).update(pk, { ...INCIDENT_CLEARED, updated_at: new Date().toISOString() });
+  return true;
+}
+
+/** The primary-key field of an incident-watched aggregate, or null for a tracked table that carries
+ *  no incident mirror (plans, feature_runs, plan_conformance, delivery_units — nothing to clear
+ *  there). Keyed off the SAME table name `resolveTrackedInstance` resolved, so the write can never
+ *  drift from the tracked aggregate's identity column. */
+function incidentMirrorPrimaryKeyFor(table: string): string | null {
+  switch (table) {
+    case "pull_requests":
+      return "pr_key";
+    case "delivery_graph_runs":
+      return "run_key";
+    default:
+      return null;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.206.4",
+  "version": "0.207.0",
   "description": "Nano Workforce — an Agent Graph Orchestration application for Agentic SDLC: durable BPMN processes that coordinate a graph of AI agents across the software delivery lifecycle.",
   "type": "module",
   "main": "main.ts",

package/pages/delivery-graphs.page.json

@@ -149,7 +149,7 @@
           { "label": "All", "filter": [] }
         ],
         "columns": [
-          { "field": "title", "template": "{{title}}", "header": "Graph", "subtitleField": "run_key", "truncate": true, "width": "16%", "link": { "kind": "page", "page": "delivery-graph-detail", "keyField": "run_key" } },
+          { "field": "title", "template": "{{title}}", "header": "Graph", "subtitleField": "run_key", "truncate": true, "width": "13%", "link": { "kind": "page", "page": "delivery-graph-detail", "keyField": "run_key" } },
           { "field": "status", "header": "Status", "truncate": true, "width": "10%", "link": { "kind": "processExplorer", "keyField": "process_key" } },
           { "field": "process_key", "header": "Agent", "template": "Transcript", "truncate": true, "width": "5%", "link": { "kind": "page", "page": "cockpit", "keyField": "process_key" } },
           { "field": "process_key", "header": "Instance", "width": "8%", "truncate": true, "link": { "kind": "processExplorer", "keyField": "process_key" } },
@@ -170,10 +170,11 @@
             "stateField": "stage_state",
             "locus": { "field": "process_key", "link": { "kind": "processExplorer", "keyField": "process_key" } }
           },
-          { "field": "park_label", "header": "Parked", "truncate": true, "width": "12%" },
+          { "field": "park_label", "header": "Parked", "truncate": true, "width": "9%" },
           { "field": "node_count", "header": "Nodes", "width": "5%" },
           { "field": "human_node_count", "header": "Human", "width": "5%" },
           { "field": "side_effect_count", "header": "Effects", "width": "6%" },
+          { "field": "incident_message", "header": "Incident", "truncate": true, "width": "6%", "badge": { "tone": "danger", "label": "1" } },
           { "field": "created_at", "header": "Dispatched", "width": "7%", "truncate": true, "format": "datetime" },
           { "field": "updated_at", "header": "Updated", "width": "6%", "truncate": true, "format": "datetime" }
         ],
@@ -181,10 +182,22 @@
           "fields": [
             { "field": "process_definition_id", "label": "Definition" },
             { "field": "digest", "label": "Digest" },
-            { "field": "phase_node_id", "label": "Parked node" }
+            { "field": "phase_node_id", "label": "Parked node" },
+            { "field": "incident_message", "label": "Incident" },
+            { "field": "incident_type", "label": "Incident type" },
+            { "field": "incident_since", "label": "Incident since" }
           ]
         },
         "rowActions": [
+          {
+            "label": "Retry incident",
+            "confirm": "Retry the engine incident parking this delivery run? This gives the failed job a retry and resolves the incident.",
+            "showWhenField": "incident_key",
+            "action": {
+              "path": "/app/api/actions/incident/retry",
+              "body": { "processInstanceKey": "{{row.process_key}}" }
+            }
+          },
           {
             "label": "Save to library",
             "confirm": "Save this dispatched delivery graph to the reusable library? Its stored graph is copied into the Library (source: from-dispatched) so it can be reused later.",

package/pages/home.page.json

@@ -231,6 +231,17 @@
           }
         ],
         "rowActions": [
+          {
+            "label": "Retry incident",
+            "confirm": "Retry the engine incident parking this PR's run? This gives the failed job a retry and resolves the incident.",
+            "showWhenField": "incident_key",
+            "action": {
+              "path": "/app/api/actions/incident/retry",
+              "body": {
+                "processInstanceKey": "{{row.process_key}}"
+              }
+            }
+          },
           {
             "label": "Cancel",
             "confirm": "Cancel this PR's review run?",
@@ -281,6 +292,14 @@
               "field": "incident_key",
               "label": "Incident key"
             },
+            {
+              "field": "incident_type",
+              "label": "Incident type"
+            },
+            {
+              "field": "incident_since",
+              "label": "Incident since"
+            },
             {
               "field": "merged_at",
               "label": "Merged at"

package/pages/overview.page.json

@@ -135,6 +135,15 @@
           { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
+          {
+            "label": "Retry incident",
+            "confirm": "Retry the engine incident parking this PR's run? This gives the failed job a retry and resolves the incident.",
+            "showWhenField": "incident_key",
+            "action": {
+              "path": "/app/api/actions/incident/retry",
+              "body": { "processInstanceKey": "{{row.process_key}}" }
+            }
+          },
           {
             "label": "Dismiss",
             "confirm": "Dismiss this finished PR? It acknowledges the terminal pull request and files it under History.",