@nanobpm/nano-workforce 0.193.1 → 0.194.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.194.0](https://github.com/nanobpm/nano-workforce/compare/v0.193.2...v0.194.0) (2026-09-30)
+
+### Features
+
+* **cockpit:** collapse agent-history turns behind a timestamped heading ([#832](https://github.com/nanobpm/nano-workforce/issues/832)) ([812907d](https://github.com/nanobpm/nano-workforce/commit/812907d13c49dc8a008bb8682d7d58f04c8ba323)), closes [#831](https://github.com/nanobpm/nano-workforce/issues/831)
+
+## [0.193.2](https://github.com/nanobpm/nano-workforce/compare/v0.193.1...v0.193.2) (2026-09-29)
+
+### Bug Fixes
+
+* **convergence:** heal PR rows stuck at status=escalated after escalation answered ([#829](https://github.com/nanobpm/nano-workforce/issues/829)) ([235a004](https://github.com/nanobpm/nano-workforce/commit/235a004f73ec1b27f52b5dfe88e2f2a28c1d99e8)), closes [#642](https://github.com/nanobpm/nano-workforce/issues/642) [#828](https://github.com/nanobpm/nano-workforce/issues/828) [#828](https://github.com/nanobpm/nano-workforce/issues/828) [#828](https://github.com/nanobpm/nano-workforce/issues/828) [#828](https://github.com/nanobpm/nano-workforce/issues/828)
+
 ## [0.193.1](https://github.com/nanobpm/nano-workforce/compare/v0.193.0...v0.193.1) (2026-09-28)
 
 ### Bug Fixes

package/app/agentic/cockpit/agent-history-render.test.ts

@@ -63,6 +63,8 @@ test("renderAgentHistory renders turns with role, text, tool calls and per-turn
         text: "on it",
         toolCalls: [{ toolCallId: "t-1", toolName: "grep", elementId: "tool" }],
         metrics: "12 in \u00b7 4 out \u00b7 900ms",
+        producedAt: "2024-05-01T12:34:56.789Z",
+        time: "12:34:56",
       },
     ],
   };
@@ -78,6 +80,28 @@ test("renderAgentHistory renders turns with role, text, tool calls and per-turn
   assert.equal(host.byClass("cockpit-agent-turn-metrics")[0]?.text(), "12 in \u00b7 4 out \u00b7 900ms");
 });
 
+test("renderAgentHistory renders each turn collapsed: a <details> whose <summary> heading carries the timestamp (#831)", () => {
+  const host = new FakeElement("div");
+  renderAgentHistory(host, doc, {
+    agentInstanceKey: "ai-1",
+    count: 1,
+    turns: [{ historyItemKey: "h-1", loopIteration: 1, role: "ASSISTANT", text: "on it", toolCalls: [], producedAt: "2024-05-01T12:34:56.789Z", time: "12:34:56" }],
+  });
+  const turn = host.byClass("cockpit-agent-turn")[0];
+  assert.equal(turn?.tagName, "details");
+  // Collapsed by default: no `open` attribute — the native <summary> toggles it on click.
+  assert.equal(turn?.getAttribute("open"), undefined);
+  const heading = host.byClass("cockpit-agent-turn-meta")[0];
+  assert.equal(heading?.tagName, "summary");
+  const time = host.byClass("cockpit-agent-turn-time")[0];
+  assert.equal(time?.tagName, "time");
+  assert.equal(time?.text(), "12:34:56");
+  assert.equal(time?.getAttribute("datetime"), "2024-05-01T12:34:56.789Z");
+  // The details body sits inside the collapsible turn, not in the heading.
+  const body = host.byClass("cockpit-agent-turn-body")[0];
+  assert.equal(body?.byClass("cockpit-agent-turn-text")[0]?.text(), "on it");
+});
+
 test("renderAgentHistory renders an empty history state", () => {
   const host = new FakeElement("div");
   renderAgentHistory(host, doc, { agentInstanceKey: "ai-9", count: 0, turns: [] });

package/app/agentic/cockpit/agent-history-render.ts

@@ -106,19 +106,32 @@ export function renderAgentSessions(
   return { root };
 }
 
+/**
+ * One turn as a native collapsible: a `<details>` (collapsed by default — no `open`) whose `<summary>`
+ * heading (role, iteration, timestamp, metrics) toggles the turn's details body on click (#831).
+ */
 function turnBlock(doc: DocumentLike, t: AgentTurnView): ElementLike {
-  const block = el(doc, "div", "cockpit-agent-turn");
+  const block = el(doc, "details", "cockpit-agent-turn");
   block.setAttribute("data-history-item-key", t.historyItemKey);
   block.setAttribute("data-role", t.role);
   block.setAttribute("data-loop-iteration", String(t.loopIteration));
 
-  const meta = el(doc, "div", "cockpit-agent-turn-meta");
+  const meta = el(doc, "summary", "cockpit-agent-turn-meta");
   meta.appendChild(el(doc, "span", "cockpit-agent-turn-role", t.role));
   meta.appendChild(el(doc, "span", "cockpit-agent-turn-iter", `#${t.loopIteration}`));
+  if (t.time !== undefined) {
+    const time = el(doc, "time", "cockpit-agent-turn-time", t.time);
+    if (t.producedAt !== undefined) {
+      time.setAttribute("datetime", t.producedAt);
+      time.setAttribute("title", t.producedAt);
+    }
+    meta.appendChild(time);
+  }
   if (t.metrics !== undefined) meta.appendChild(el(doc, "span", "cockpit-agent-turn-metrics", t.metrics));
   block.appendChild(meta);
 
-  if (t.text !== "") block.appendChild(el(doc, "pre", "cockpit-agent-turn-text", t.text));
+  const body = el(doc, "div", "cockpit-agent-turn-body");
+  if (t.text !== "") body.appendChild(el(doc, "pre", "cockpit-agent-turn-text", t.text));
 
   if (t.toolCalls.length > 0) {
     const tools = el(doc, "ul", "cockpit-agent-turn-tools");
@@ -127,8 +140,9 @@ function turnBlock(doc: DocumentLike, t: AgentTurnView): ElementLike {
       li.setAttribute("data-tool-call-id", call.toolCallId);
       tools.appendChild(li);
     }
-    block.appendChild(tools);
+    body.appendChild(tools);
   }
+  block.appendChild(body);
   return block;
 }
 

package/app/agentic/cockpit/agent-history-view.test.ts

@@ -96,6 +96,22 @@ test("agentHistoryView projects turns in transport order with text, tool calls a
   assert.equal(view.turns[1]?.metrics, "12 in \u00b7 4 out \u00b7 900ms");
 });
 
+test("agentHistoryView carries each turn's producedAt timestamp (absent when unreported)", () => {
+  const view = agentHistoryView({
+    agentInstanceKey: "ai-1",
+    count: 2,
+    records: [
+      { historyItemKey: "h-0", agentInstanceKey: "ai-1", loopIteration: 0, role: "USER", commitStatus: "COMMITTED", content: [], toolCalls: [], producedAt: "2024-05-01T12:34:56.789Z" },
+      { historyItemKey: "h-1", agentInstanceKey: "ai-1", loopIteration: 1, role: "ASSISTANT", commitStatus: "COMMITTED", content: [], toolCalls: [] },
+    ],
+  });
+  assert.equal(view.turns[0]?.producedAt, "2024-05-01T12:34:56.789Z");
+  // UTC: the heading is locale-free, so the expected value is fixed regardless of the runner's timezone.
+  assert.equal(view.turns[0]?.time, "12:34:56");
+  assert.equal(view.turns[1]?.producedAt, undefined);
+  assert.equal(view.turns[1]?.time, undefined);
+});
+
 test("agentHistoryView read-as-absence: an empty history yields zero turns", () => {
   const view = agentHistoryView({ agentInstanceKey: "ai-9", count: 0, records: [] });
   assert.equal(view.count, 0);

package/app/agentic/cockpit/agent-history-view.ts

@@ -63,6 +63,10 @@ export interface AgentTurnView {
   readonly toolCalls: readonly AgentTurnToolCallView[];
   /** A compact per-turn token/duration rollup, when metrics exist. */
   readonly metrics?: string;
+  /** When the turn was produced (ISO-8601), when the engine reports it. */
+  readonly producedAt?: string;
+  /** The turn's compact heading timestamp (`HH:MM:SS`, UTC), when `producedAt` parses. */
+  readonly time?: string;
 }
 
 /** The full renderable history for one agent instance: its rolled-up header + ordered turns. */
@@ -113,6 +117,16 @@ function turnMetrics(r: AgentHistoryRecord): string | undefined {
   return dur !== undefined ? `${base} \u00b7 ${dur}` : base;
 }
 
+/** A compact `HH:MM:SS` heading timestamp in UTC for an ISO instant; undefined when unparseable. */
+export function turnTime(iso: string | undefined): string | undefined {
+  if (iso === undefined || iso === "") return undefined;
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return undefined;
+  const d = new Date(ms);
+  const pad = (n: number): string => String(n).padStart(2, "0");
+  return `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`;
+}
+
 /** The textual content of a turn: TEXT blocks joined in order (non-textual/empty blocks dropped). */
 function turnText(r: AgentHistoryRecord): string {
   const texts: string[] = [];
@@ -156,6 +170,7 @@ export function agentSessionsView(report: AgentInstanceListReport): AgentSession
 /** Project one engine {@link AgentHistoryRecord} onto a renderable {@link AgentTurnView}. */
 export function agentTurnView(r: AgentHistoryRecord): AgentTurnView {
   const metrics = turnMetrics(r);
+  const time = turnTime(r.producedAt);
   return {
     historyItemKey: r.historyItemKey,
     loopIteration: r.loopIteration,
@@ -167,6 +182,8 @@ export function agentTurnView(r: AgentHistoryRecord): AgentTurnView {
       ...(c.elementId !== undefined && c.elementId !== "" ? { elementId: c.elementId } : {}),
     })),
     ...(metrics !== undefined ? { metrics } : {}),
+    ...(r.producedAt !== undefined && r.producedAt !== "" ? { producedAt: r.producedAt } : {}),
+    ...(time !== undefined ? { time } : {}),
   };
 }
 

package/app/agentic/cockpit/mount.test.ts

@@ -303,6 +303,7 @@ test("agent-history panel renders the engine run list and a selected run's turns
         content: [{ contentType: "TEXT", text: "did the thing" }],
         toolCalls: [{ toolCallId: "t-1", toolName: "grep", elementId: "tool", arguments: {} }],
         metrics: { inputTokens: 12, outputTokens: 4, reasoningTokenCount: 0, cacheCreationTokenCount: 0, cacheReadTokenCount: 0, durationMs: 900 },
+        producedAt: "2024-05-01T12:34:56.789Z",
       },
     ],
   };
@@ -334,6 +335,17 @@ test("agent-history panel renders the engine run list and a selected run's turns
       assert(transcript != null, "the selected run's history rendered");
       assert((transcript?.textContent ?? "").includes("did the thing"), "the turn text rendered");
       assert((transcript?.textContent ?? "").includes("grep"), "the tool call rendered");
+      // #831 — each turn renders as a collapsed native <details> whose <summary> heading carries the
+      // UTC timestamp. Assert the browser twin mirrors the typed renderer so mount.js can't regress.
+      const turn = transcript?.querySelector(".cockpit-agent-turn");
+      assertEquals(turn?.tagName?.toLowerCase(), "details", "the turn is a <details>");
+      assertEquals(turn?.hasAttribute("open"), false, "collapsed by default: no open attribute");
+      const summary = turn?.querySelector(".cockpit-agent-turn-meta");
+      assertEquals(summary?.tagName?.toLowerCase(), "summary", "the heading is a <summary>");
+      const time = turn?.querySelector(".cockpit-agent-turn-time");
+      assertEquals(time?.tagName?.toLowerCase(), "time", "the timestamp is a <time>");
+      assertEquals(time?.textContent, "12:34:56", "the heading shows the UTC HH:MM:SS");
+      assertEquals(time?.getAttribute("datetime"), "2024-05-01T12:34:56.789Z", "the <time> carries the ISO instant");
     } finally {
       handle.dispose();
     }

package/app/persist-escalation.test.ts

@@ -8,29 +8,56 @@
 // guard moved downstream of progress classification) and likewise passes `recordRound=false`; an
 // agent-raised arm with no prior round row omits the flag and must still record the round.
 import { test } from "node:test";
-import { assertEquals } from "#test-assert";
+import { assertEquals, assertRejects } from "#test-assert";
 import handler from "../workers/persist-escalation/worker.ts";
 
-function fakeApp() {
+// `failOn` forces the named table's `update` to throw, so a test can assert the escalation-insert +
+// PR-stamp transaction rolls back as a unit (issue #829 — the insert-before-timestamp window).
+function fakeApp(opts: { failOn?: string } = {}) {
   const inserts: Record<string, unknown[]> = { rounds: [], escalations: [] };
   const updates: Record<string, unknown[]> = { pull_requests: [] };
   const rows: Record<string, Map<string, unknown>> = {};
+  // `apply` decides WHEN a staged write lands: outside a transaction it applies immediately; inside
+  // `open().tx()` it is buffered and flushed only on a clean return, so a throw discards it (rollback).
+  const makeTable = (name: string, apply: (fn: () => void) => void) => {
+    const store = (rows[name] ??= new Map());
+    return {
+      async get(key: string) {
+        return store.get(key);
+      },
+      async insert(row: unknown) {
+        const pk = name === "escalations" ? "id" : name === "rounds" ? "id" : "pr_key";
+        const id = name === "escalations" ? 42 : name === "rounds" ? 1 : (row as any).pr_key;
+        const stored = pk === "id" ? { id, ...(row as Record<string, unknown>) } : row;
+        apply(() => {
+          (inserts[name] ??= []).push(row);
+          store.set((stored as any)[pk], stored);
+        });
+        return id;
+      },
+      async update(key: string, patch: unknown) {
+        if (opts.failOn === name) throw new Error(`simulated ${name} update failure`);
+        apply(() => {
+          (updates[name] ??= []).push({ key, patch });
+        });
+      },
+    };
+  };
+  const applyNow = (fn: () => void) => fn();
   const app = {
     data: {
-      table(name: string, _key: string) {
-        const store = (rows[name] ??= new Map());
+      table(name: string, _key?: string) {
+        return makeTable(name, applyNow);
+      },
+      open() {
         return {
-          async get(key: string) {
-            return store.get(key);
-          },
-          async insert(row: unknown) {
-            (inserts[name] ??= []).push(row);
-            const pk = name === "escalations" ? "id" : name === "rounds" ? "id" : "pr_key";
-            store.set((row as any)[pk], row);
-            return name === "escalations" ? 42 : 1;
-          },
-          async update(key: string, patch: unknown) {
-            (updates[name] ??= []).push({ key, patch });
+          async tx<T>(fn: (t: unknown) => Promise<T>): Promise<T> {
+            const staged: Array<() => void> = [];
+            const stage = (fn2: () => void) => staged.push(fn2);
+            const handle = { table: (name: string, _key?: string) => makeTable(name, stage) };
+            const result = await fn(handle); // a throw here skips the flush below — the staged writes roll back
+            for (const s of staged) s();
+            return result;
           },
         };
       },
@@ -50,6 +77,20 @@ test("stalled arm (recordRound=false) does not insert a duplicate rounds row", a
   assertEquals((out as any).escalationId, 42);
 });
 
+// Red/green regression for the insert-before-timestamp race (issue #829, Copilot review). The
+// escalated-PR self-heal snapshots the PR generation + open-escalation ids and fences its repair on
+// them. If this worker inserted the fresh `open` escalation BEFORE stamping the PR's `updated_at`
+// (two separate writes), a heal snapshot landing between them would see the new escalation under the
+// OLD generation and could retire it, orphaning a live user task. The insert and the PR stamp are now
+// one transaction, so they are all-or-nothing: a failed PR stamp must roll the escalation insert back
+// — proving no `open` row is ever visible while the PR still carries the pre-escalation generation.
+test("persist-escalation opens the escalation and stamps the PR atomically — a failed PR stamp rolls back the escalation insert (issue #829)", async () => {
+  const { app, inserts } = fakeApp({ failOn: "pull_requests" });
+  const job = { variables: { prKey: "o/r#1", round: 3, status: "blocked", question: "needs input" } };
+  await assertRejects(() => handler(job as any, app as any));
+  assertEquals(inserts.escalations.length, 0, "the escalation insert rolls back with the failed PR stamp — no orphan open row under the old generation");
+});
+
 test("an agent-raised arm without the flag still records the round", async () => {
   const { app, inserts } = fakeApp();
   const job = { variables: { prKey: "o/r#1", round: 3, status: "blocked", question: "needs input" } };

package/app/persistEscalationElements.test.ts

@@ -0,0 +1,40 @@
+// Drift guard for `PR_ESCALATION_PRODUCER_ELEMENTS` (issue #829).
+//
+// The escalated-PR self-heal (`pollUserTasks` in app/service.ts) treats an ACTIVE `pr.persist-escalation`
+// PRODUCER element as positive evidence an escalation is being raised, so it must NOT retire the live
+// escalation. That guard is only as correct as the element-id set it checks against — a NEW escalation
+// arm added to either loop's BPMN, or a renamed one, would silently fall outside the set and re-open the
+// race the fix closes. This test derives the truth from the deployed BPMN: every service task whose
+// `zeebe:taskDefinition type="pr.persist-escalation"` in convergence-loop.bpmn / merge-loop.bpmn must be
+// listed in the constant, and the constant must list nothing that isn't such a task. It fails loudly on
+// either drift so the set stays the single source of truth.
+import { readFileSync } from "node:fs";
+import { test } from "node:test";
+import { assertEquals } from "#test-assert";
+import { PR_ESCALATION_PRODUCER_ELEMENTS } from "./userTasks.ts";
+
+/** Extract the `id`s of every `<bpmn:serviceTask>` whose `<zeebe:taskDefinition type="pr.persist-escalation"/>`
+ *  from one BPMN file. Matches each service task element and keeps the ones carrying the producer job type. */
+function persistEscalationTaskIds(bpmnPath: string): string[] {
+  const xml = readFileSync(bpmnPath, "utf8");
+  const ids: string[] = [];
+  const taskRe = /<bpmn:serviceTask\b[^>]*\bid="([^"]+)"[\s\S]*?<\/bpmn:serviceTask>/g;
+  for (let m = taskRe.exec(xml); m !== null; m = taskRe.exec(xml)) {
+    if (/<zeebe:taskDefinition\b[^>]*\btype="pr\.persist-escalation"/.test(m[0])) ids.push(m[1]);
+  }
+  return ids;
+}
+
+test("PR_ESCALATION_PRODUCER_ELEMENTS matches every pr.persist-escalation task in both PR loops (issue #829)", () => {
+  const modelled = [
+    ...persistEscalationTaskIds("resources/processes/convergence-loop.bpmn"),
+    ...persistEscalationTaskIds("resources/processes/merge-loop.bpmn"),
+  ].sort();
+  // Sanity: the BPMN really does carry producer tasks — a zero here would make the match vacuously pass.
+  assertEquals(modelled.length > 0, true, "expected at least one pr.persist-escalation task in the BPMN");
+  assertEquals(
+    [...PR_ESCALATION_PRODUCER_ELEMENTS].sort(),
+    modelled,
+    "PR_ESCALATION_PRODUCER_ELEMENTS drifted from the pr.persist-escalation tasks modelled in the BPMN — update the constant in app/userTasks.ts",
+  );
+});