@nanobpm/nano-workforce 0.94.0 → 0.95.0

package/e2e/plan-fanout-preflight.e2e.ts

@@ -0,0 +1,170 @@
+// End-to-end proof for the inter-epic capability PREFLIGHT seeded into plan-fanout (issue #292, slice
+// S3). Boots the whole app against the WASM engine + virtual clock and drives the REAL
+// `plan-fanout.bpmn` with `readinessProbes` seeded — the exact shape slice S3's lowering seeds for a
+// DEPENDENT epic — proving the leading readiness-gate executes on the engine BEFORE wave 0:
+//   • GREEN — a dependent seeded with a probe that is ready reruns the reused `pr.readiness-probe`
+//     worker inside the multi-instance preflight, releases through `pf_gw → pf_end`, binds the
+//     resolved artifact into `resolvedArtifacts`, and only THEN reaches `ensure-base-branch` (the
+//     head of the fan-out) — it never fans a wave before the gate is green, and never escalates.
+//   • ROOT — an epic seeded with `readinessProbes = null` skips the gate entirely
+//     (`gw-readiness → ensure-base-branch`), fanning out immediately as a single epic does today.
+//
+// The probe is a deterministic shell builtin (`true`) with a bound artifact, so the gate itself is
+// hermetic (no network, no GitHub). The fan-out head (`pr.ensure-base-branch`) that follows a green
+// gate is handled by the shared hermetic admit-github stub (installAdmitGithub) like the sibling
+// plan-fanout e2es, so the whole flow runs offline.
+// We assert on the cumulative taken sequence flows (the WASM engine folds completed variables away).
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { after, before, describe, test } from "node:test";
+import { fileURLToPath } from "node:url";
+import { bootTestApp, type TestApp } from "@nanobpm/urban-testkit";
+import { admitGithubState, installAdmitGithub } from "./support/github-admit.ts";
+
+const APP_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+const GITHUB_ENV_OVERRIDES: Record<string, string> = {
+  NANO_PR_GITHUB_TRANSPORT: "token",
+  GITHUB_TOKEN: "",
+};
+const savedEnv = new Map<string, string | undefined>();
+
+interface TakenFlow {
+  from: string;
+  to: string;
+}
+
+function takenFlows(app: TestApp): string[] {
+  const snapshot = app.snapshot();
+  const flows = Array.isArray(snapshot.takenSequenceFlows) ? snapshot.takenSequenceFlows : [];
+  return flows
+    .filter((f): f is TakenFlow => typeof f === "object" && f !== null && "from" in f && "to" in f)
+    .map((f) => `${f.from}->${f.to}`);
+}
+
+// The full variable set `startPlan` seeds onto a plan-fanout instance (app/plan.ts). We seed it
+// directly so we can inject `readinessProbes` (which the `startPlanFanout` op never sets — only S3's
+// set lowering does) without standing up a whole two-epic set + release provenance.
+function planVars(overrides: Record<string, unknown>): Record<string, unknown> {
+  return {
+    planKey: "owner/repo#2",
+    repo: "owner/repo",
+    issue: "owner/repo#2",
+    issueNumber: 2,
+    issueUrl: "https://github.com/owner/repo/issues/2",
+    planFindings: null,
+    planReviewEpoch: 0,
+    escalationSlaTimeout: "PT24H",
+    escalationAssignee: null,
+    blackboardUrl: "http://blackboard.local/x",
+    blackboardBrief: "",
+    baseBranch: "epic/e2e",
+    baseBranchBrief: "",
+    waveCount: 1,
+    readinessProbes: null,
+    probeTimeout: null,
+    gateKey: null,
+    resolvedArtifacts: null,
+    ...overrides,
+  };
+}
+
+async function boot(): Promise<{ app: TestApp; dbDir: string }> {
+  const dbDir = mkdtempSync(join(tmpdir(), "nwf-preflight-"));
+  const app = await bootTestApp(APP_ROOT, { env: { NANO_APP_DB_URL: `file:${join(dbDir, "app.db")}` } });
+  return { app, dbDir };
+}
+
+describe("plan-fanout inter-epic capability preflight (plan-fanout.bpmn, issue #292 S3)", () => {
+  let restoreGithub: (() => void) | undefined;
+
+  before(() => {
+    for (const [k, v] of Object.entries(GITHUB_ENV_OVERRIDES)) {
+      savedEnv.set(k, process.env[k]);
+      process.env[k] = v;
+    }
+    // The fan-out head (`pr.ensure-base-branch`, ADR 0003) reads/creates the base ref via the token
+    // transport, which would throw `no GitHub transport available` under an empty token. Pin the
+    // shared hermetic admit-github stub (dummy token + fetch intercept) like the sibling plan-fanout
+    // e2es so base-branch admission is deterministic and offline.
+    restoreGithub = installAdmitGithub(admitGithubState("owner/repo", "main"));
+  });
+  after(() => {
+    restoreGithub?.();
+    for (const [k, v] of savedEnv) {
+      if (v === undefined) delete process.env[k];
+      else process.env[k] = v;
+    }
+  });
+
+  test("GREEN: a dependent waits on the preflight, releases green, and only THEN reaches the fan-out head", async () => {
+    const { app, dbDir } = await boot();
+    try {
+      const { processInstanceKey } = await app.engine.createInstance({
+        processDefinitionId: "plan-fanout",
+        variables: planVars({
+          // The shape S3 lowering seeds — here a hermetic green probe that binds a version, standing
+          // in for the `capability` probe (whose green/bind path is unit-tested in planLowering.test).
+          readinessProbes: [
+            {
+              kind: "command",
+              target: "true",
+              resolvedArtifact: "@scope/pkg@1.4.0",
+              poll: { everyMs: 5, timeoutMs: 5000, backoff: "fixed" },
+            },
+          ],
+          probeTimeout: "PT30M",
+          gateKey: "preflight:owner/repo#2",
+        }),
+      });
+      await app.settle();
+
+      const flows = takenFlows(app);
+      // The DEPENDENT was gated: it entered the preflight (not the root skip) and released green.
+      assert.ok(
+        flows.includes("gw-readiness->readiness-preflight"),
+        `a dependent enters the preflight (flows: ${flows.join(", ")})`,
+      );
+      assert.ok(flows.includes("pf_gw->pf_end"), "the probe went green and settled the gate");
+      // Only AFTER the gate does it reach ensure-base-branch — the head of the fan-out (wave 0 is
+      // downstream of it). The gate is a true PREFLIGHT, not a parallel afterthought.
+      assert.ok(
+        flows.includes("readiness-preflight->ensure-base-branch"),
+        "the green gate leads into the fan-out head",
+      );
+      // A green probe never escalates.
+      const tasks = await app.engine.searchUserTasks({ processInstanceKey });
+      assert.equal(
+        tasks.filter((t) => t.elementId === "readiness-escalation-pf").length,
+        0,
+        "a green preflight never opens an escalation task",
+      );
+    } finally {
+      await app.stop();
+      rmSync(dbDir, { recursive: true, force: true });
+    }
+  });
+
+  test("ROOT: readinessProbes = null skips the gate and fans out immediately", async () => {
+    const { app, dbDir } = await boot();
+    try {
+      await app.engine.createInstance({
+        processDefinitionId: "plan-fanout",
+        variables: planVars({ planKey: "owner/repo#1", issue: "owner/repo#1", readinessProbes: null }),
+      });
+      await app.settle();
+
+      const flows = takenFlows(app);
+      assert.ok(
+        flows.includes("gw-readiness->ensure-base-branch"),
+        `a root skips straight to the fan-out head (flows: ${flows.join(", ")})`,
+      );
+      assert.ok(!flows.includes("gw-readiness->readiness-preflight"), "a root never enters the preflight");
+    } finally {
+      await app.stop();
+      rmSync(dbDir, { recursive: true, force: true });
+    }
+  });
+});

package/openapi.yaml

@@ -954,11 +954,12 @@ components:
           minLength: 1
           description: The producer epic's issue handle, used to resolve which published pkg@version first carries the capability (S3).
     StartEpicSetResult:
-      description: The result of a successful set admission — the epics admitted and the edges staged (FK-free in `admitted_plan_deps`) for S3 to materialize.
+      description: The result of a successful set admission + lowering (issue #292, slice S3) — the epics admitted, the roots started immediately, the dependents started behind their leading capability readiness-gate, and the inter-epic edges materialized into `plan_deps`.
       type: object
       required:
         - epics
         - roots
+        - dependents
         - edges
       properties:
         epics:
@@ -976,12 +977,28 @@ components:
                 type: string
         roots:
           type: array
-          description: The plan keys of epics with NO inbound edge — the roots S3 starts immediately.
+          description: The plan keys of epics with NO inbound edge — the roots started immediately (fan out right away).
           items:
             type: string
+        dependents:
+          type: array
+          description: The epics with ≥1 inbound edge — started behind a leading capability readiness-gate that holds wave 0 until every listed producer publishes its capability.
+          items:
+            type: object
+            required:
+              - planKey
+              - producers
+            properties:
+              planKey:
+                type: string
+              producers:
+                type: array
+                description: The producer plan keys whose capabilities this dependent waits for (ALL must be green before it fans out).
+                items:
+                  type: string
         edges:
           type: array
-          description: The inter-epic edges staged FK-free into `admitted_plan_deps` for S3 to materialize into `plan_deps` (endpoints resolved to plan keys).
+          description: The inter-epic edges materialized into the durable `plan_deps` graph (endpoints resolved to plan keys).
           items:
             type: object
             required:

package/operations/startEpicSet.admission.integration.test.ts

@@ -168,18 +168,27 @@ test("valid DAG: admits all epics and persists all edges", async () => {
     assertEquals(res.body.edges, [
       { consumer: `${REPO}#2`, producer: `${REPO}#1`, package: "@scope/pkg", capabilityRef: `${REPO}#1` },
     ]);
-    // S2 admits + STAGES (epics and edges) but NEVER starts an epic and NEVER writes the durable
-    // `plans` / `plan_deps` graph (that is S3).
-    assertEquals(started.length, 0);
-    assertEquals(planDepsRows(tables).length, 0); // durable plan_deps untouched by S2
+    // S2 admits + STAGES (epics and edges); S3 (this slice) then reads that staging and LOWERS the
+    // set — starting every epic (roots immediately, dependents behind a seeded capability preflight)
+    // and materializing the durable `plan_deps` graph after the `plans` rows exist.
+    assertEquals(started.length, 2); // both epics started by the S3 lowering
+    assertEquals(planDepsRows(tables).length, 1); // durable edge materialized by S3
     const epicRows = admittedEpicRows(tables);
-    assertEquals(epicRows.length, 2); // both epics staged (roots included) for S3 to materialize
+    assertEquals(epicRows.length, 2); // both epics staged (roots included) then materialized
     const rows = admittedDepRows(tables);
     assertEquals(rows.length, 1);
     assertEquals(rows[0].plan_key, `${REPO}#2`);
     assertEquals(rows[0].depends_on_plan_key, `${REPO}#1`);
     assertEquals(rows[0].package, "@scope/pkg");
     assertEquals(rows[0].capability_ref, `${REPO}#1`);
+    // The dependent (#2) is seeded with a capability probe + bounded timeout; the root (#1) starts
+    // with none so it fans out immediately.
+    const startedByKey = new Map(started.map((s) => [s.variables?.["planKey"], s.variables ?? {}]));
+    const rootVars = startedByKey.get(`${REPO}#1`);
+    const depVars = startedByKey.get(`${REPO}#2`);
+    assertEquals(rootVars?.["readinessProbes"], null);
+    assertEquals(Array.isArray(depVars?.["readinessProbes"]), true);
+    assertEquals((depVars?.["readinessProbes"] as unknown[]).length, 1);
   });
 });
 
@@ -485,7 +494,11 @@ function makeSqliteApp(
 ) {
   const db = new DatabaseSync(":memory:");
   db.exec("PRAGMA foreign_keys = ON;");
-  db.exec("CREATE TABLE plans (plan_key TEXT PRIMARY KEY, repo TEXT, base_branch TEXT, status TEXT);");
+  db.exec(
+    "CREATE TABLE plans (plan_key TEXT PRIMARY KEY, repo TEXT, issue_number INTEGER, issue_url TEXT, " +
+      "title TEXT, base_branch TEXT, status TEXT, task_count INTEGER, epic_phase TEXT, " +
+      "blackboard_token TEXT, list_bucket TEXT, ack_open INTEGER, created_at TEXT, updated_at TEXT);",
+  );
   for (const p of seedPlans) {
     db.prepare("INSERT INTO plans (plan_key, repo, base_branch, status) VALUES (?, ?, ?, ?)")
       .run(p.plan_key, p.repo, p.base_branch, p.status);
@@ -520,7 +533,7 @@ function makeSqliteApp(
   return { app, db };
 }
 
-test("SQLite (FK ON): admits a set with NO plans row, stages FK-free, never writes plan_deps", async () => {
+test("SQLite (FK ON): admits a set with NO plans row, then S3 lowering starts plans FK-first and materializes plan_deps", async () => {
   const gh = freshGithub(REPO);
   await withGithub(gh, async () => {
     const { app, db } = makeSqliteApp(); // no plans rows — the first-submission FK-failure condition
@@ -532,10 +545,13 @@ test("SQLite (FK ON): admits a set with NO plans row, stages FK-free, never writ
         ],
         deps: [{ consumer: `${REPO}#2`, producer: `${REPO}#1`, package: "@scope/pkg", capabilityRef: `${REPO}#1` }],
       });
-      // Under the old code this was a 500 FK violation on `plan_deps.plan_key`.
+      // Under the old code this was a 500 FK violation on `plan_deps.plan_key`. S3 lowering inserts
+      // BOTH `plans` rows before recording the edge, so the durable `plan_deps` FK is satisfied.
       assertEquals(res.status, 202);
+      const planN = db.prepare("SELECT COUNT(*) AS n FROM plans").get() as { n: number };
+      assertEquals(planN.n, 2); // both epics materialized a plans row
       const planDepN = db.prepare("SELECT COUNT(*) AS n FROM plan_deps").get() as { n: number };
-      assertEquals(planDepN.n, 0); // durable plan_deps untouched by S2
+      assertEquals(planDepN.n, 1); // durable edge materialized FK-clean by S3
       const staged = db
         .prepare("SELECT plan_key, depends_on_plan_key, package FROM admitted_plan_deps")
         .all() as { plan_key: string; depends_on_plan_key: string; package: string }[];

package/operations/startEpicSet.ts

@@ -15,18 +15,19 @@
 //      in-request intra-set shared-base guard (two members of the same set cannot silently grab the
 //      same custom base, which admitPlan's durable-only rule 4 would miss). The first failure maps to
 //      its 4xx (400/409) via the shared `admitPlanErrorResponse`, before anything is persisted.
-//   4. Only once every epic admits: STAGE the admitted set — each epic into `admitted_epics` and each
-//      validated edge into `admitted_plan_deps` — then return the admitted epics, the roots, and the
-//      staged edges.
+//   4. Once every epic admits: STAGE the admitted set — each epic into `admitted_epics` and each
+//      validated edge into `admitted_plan_deps` — then LOWER it (issue #292 slice S3): start every
+//      ROOT immediately, start every DEPENDENT behind its leading capability readiness-gate, and
+//      materialize the durable `plan_deps` edges. Returns the admitted epics, the roots, the gated
+//      dependents, and the materialized edges.
 //
-// This slice deliberately does NOT start any epic or seed any readiness gate, and — per the #292
-// design decision — it MATERIALIZES neither a `plans` row nor a `plan_deps` edge. Both are owned by
-// slice S3 (planner lowering: schedule roots, seed the capability gate, bind the resolved version),
-// which reads this staging and creates `plans` + `plan_deps` when it schedules roots — where the
-// `plan_deps.plan_key REFERENCES plans(plan_key)` FK is satisfied by construction. S2 persists into
-// its OWN FK-FREE staging tables instead, so a first-time set submission can never FK-fail here.
-// Re-submitting the identical set is a no-op (admitPlan is idempotent on an already-created base + an
-// inactive plan; the staging records collapse a duplicate epic/edge).
+// The FK-free staging (step 4a) survives a crash between admission and lowering: `lowerAdmittedSet`
+// reads `admitted_epics` / `admitted_plan_deps` and creates the durable `plans` row (via `startPlan`)
+// before recording each `plan_deps` edge, so the `plan_deps.plan_key REFERENCES plans(plan_key)` FK
+// is satisfied by construction. Re-submitting the identical set is a no-op: `admitPlan` is idempotent
+// on an already-created base + inactive plan, the staging records collapse a duplicate epic/edge, and
+// lowering neither double-starts an epic nor re-seeds a gate (`startPlan` short-circuits a running
+// plan) nor duplicates a durable edge.
 
 import { fetchDefaultBranch } from "../app/github.ts";
 import {
@@ -40,6 +41,7 @@ import {
   SharedBaseError,
   validateEpicSet,
 } from "../app/plan.ts";
+import { lowerAdmittedSet } from "../app/planLowering.ts";
 import { defineOperation } from "../nano-generated/operations.ts";
 
 /** One parsed, admission-ready epic member: its parsed issue reference plus the per-epic admission
@@ -167,13 +169,13 @@ export default defineOperation("startEpicSet", async ({ body }, app) => {
     }
   }
 
-  // ── Step 4: STAGE the admitted set + validated edges (idempotent). S2 is the admission DOOR only:
-  // per the #292 design decision it persists into ITS OWN FK-FREE staging tables and MATERIALIZES
-  // neither a `plans` row nor a `plan_deps` edge. Slice S3 (planner lowering) reads this staging and
-  // creates `plans` + `plan_deps` when it schedules roots — where the `plan_deps.plan_key REFERENCES
-  // plans(plan_key)` FK is satisfied by construction. Each admitted epic (INCLUDING roots) is staged
-  // so S3 can materialize its `plans` row; each validated edge is staged FK-free. Only reached once
-  // the WHOLE set admitted.
+  // ── Step 4: STAGE the admitted set + validated edges FK-free (idempotent), THEN lower it (step 5).
+  // Staging first keeps the door crash-safe: `admitted_epics` / `admitted_plan_deps` carry exactly
+  // what `lowerAdmittedSet` needs to materialize the durable `plans` + `plan_deps` graph, so a crash
+  // between staging and lowering loses nothing (a re-dispatch re-reads the staging). The staging
+  // tables are FK-free (no `plans` row need exist yet); lowering creates the `plans` row before
+  // recording each `plan_deps` edge, so the FK holds by construction. Each admitted epic (INCLUDING
+  // roots) is staged; each validated edge is staged. Only reached once the WHOLE set admitted.
   for (const a of admitted) {
     await recordAdmittedEpic(app.data, {
       plan_key: a.parsed.planKey,
@@ -192,20 +194,25 @@ export default defineOperation("startEpicSet", async ({ body }, app) => {
     });
   }
 
-  // Roots = admitted epics with no inbound edge — the ones S3 will start immediately.
-  const dependents = new Set(edges.map((e) => e.consumer));
-  const roots = admitted.map((a) => a.parsed.planKey).filter((k) => !dependents.has(k));
+  // ── Step 5: LOWER the admitted set into a running schedule (issue #292, slice S3). Now that the
+  // whole set has admitted and staged, materialize it: start every ROOT immediately, start every
+  // DEPENDENT behind its leading capability readiness-gate (seeded from its inbound edges), and
+  // materialize the durable `plan_deps` edges. Idempotent — a re-submitted set neither double-starts
+  // an epic nor re-seeds a gate nor duplicates an edge (see lowerAdmittedSet).
+  const lowered = await lowerAdmittedSet(app.data, app.engine, planKeys);
 
-  app.log.info("epic set admitted", {
+  app.log.info("epic set admitted + lowered", {
     epics: admitted.length,
     edges: edges.length,
-    roots: roots.length,
+    roots: lowered.roots.length,
+    dependents: lowered.dependents.length,
   });
   return {
     status: 202,
     body: {
       epics: admitted.map((a) => ({ planKey: a.parsed.planKey, baseBranch: a.baseBranch })),
-      roots,
+      roots: lowered.roots,
+      dependents: lowered.dependents,
       edges: edges.map((e) => ({
         consumer: e.consumer,
         producer: e.producer,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.94.0",
+  "version": "0.95.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",
@@ -53,7 +53,7 @@
   },
   "dependencies": {
     "@nanobpm/agentic": "^0.1.0",
-    "@nanobpm/urban": "^0.55.0"
+    "@nanobpm/urban": "^0.59.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.11",

package/pages/epic-detail.page.json

@@ -64,7 +64,7 @@
           { "field": "promotion_state", "header": "Promotion" },
           { "field": "wave_label", "header": "Wave" },
           { "field": "task_count", "header": "Tasks" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "detail": {
           "linkField": "issue_url",
@@ -127,7 +127,7 @@
           { "field": "status", "header": "Status" },
           { "field": "pr_key", "header": "PR" },
           { "field": "summary", "header": "Summary" },
-          { "field": "updated_at", "header": "Updated" }
+          { "field": "updated_at", "header": "Updated", "format": "datetime" }
         ],
         "detail": {
           "fields": [
@@ -202,7 +202,7 @@
           { "field": "task_b", "header": "Task B" },
           { "field": "files", "header": "Shared files" },
           { "field": "source", "header": "Source" },
-          { "field": "updated_at", "header": "Updated" }
+          { "field": "updated_at", "header": "Updated", "format": "datetime" }
         ]
       }
     },

package/pages/epic.page.json

@@ -85,7 +85,7 @@
           { "field": "wave_label", "header": "Wave" },
           { "field": "task_count", "header": "Tasks" },
           { "field": "issue_number", "header": "Issue", "linkField": "issue_url" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
           {

package/pages/feature.page.json

@@ -91,7 +91,7 @@
             "notInPathField": "stage_skipped",
             "locus": { "field": "process_key", "link": { "kind": "processExplorer", "keyField": "process_key" } }
           },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
           {

package/pages/home.page.json

@@ -207,6 +207,7 @@
           {
             "field": "updated_at",
             "header": "Updated",
+            "format": "datetime",
             "width": "9rem"
           }
         ],

package/pages/lineage.page.json

@@ -79,7 +79,7 @@
             "link": { "kind": "processExplorer", "keyField": "process_key" }
           },
           { "field": "pr_count", "header": "PRs", "width": "5rem" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "detail": {
           "linkField": "issue_url",
@@ -103,7 +103,7 @@
                 { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
                 { "field": "current_round", "header": "Round" },
                 { "field": "outcome", "header": "Outcome", "truncate": true },
-                { "field": "updated_at", "header": "Updated", "width": "9rem" }
+                { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
               ],
               "detail": {
                 "linkField": "url",

package/pages/overview.page.json

@@ -69,7 +69,7 @@
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
           { "field": "incident_message", "header": "Incident", "truncate": true, "badge": { "tone": "danger", "label": "1" } },
           { "field": "current_round", "template": "{{current_round}} · {{active_worker}}", "header": "Round · Agent" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ]
       }
     },
@@ -95,7 +95,7 @@
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
           { "field": "delivery_label", "header": "Landing" },
           { "field": "wave_label", "header": "Wave" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
           {
@@ -131,7 +131,7 @@
           { "field": "title", "template": "{{title}}", "header": "Item", "subtitleField": "feature_key", "truncate": true, "width": "36%", "link": { "kind": "page", "page": "feature", "keyField": "feature_key" } },
           { "field": "status", "header": "Status", "link": { "kind": "processExplorer", "keyField": "process_key" } },
           { "field": "delivery_label", "header": "Delivery" },
-          { "field": "updated_at", "header": "Updated", "width": "9rem" }
+          { "field": "updated_at", "header": "Updated", "width": "9rem", "format": "datetime" }
         ],
         "rowActions": [
           {

package/pages/tasks.page.json

@@ -105,7 +105,8 @@
           },
           {
             "field": "updated_at",
-            "header": "Updated"
+            "header": "Updated",
+            "format": "datetime"
           }
         ],
         "rowKey": "user_task_key",
@@ -170,7 +171,8 @@
           },
           {
             "field": "updated_at",
-            "header": "Updated"
+            "header": "Updated",
+            "format": "datetime"
           }
         ],
         "rowKey": "user_task_key",
@@ -235,7 +237,8 @@
           },
           {
             "field": "updated_at",
-            "header": "Updated"
+            "header": "Updated",
+            "format": "datetime"
           }
         ],
         "rowKey": "user_task_key",
@@ -301,7 +304,8 @@
           },
           {
             "field": "updated_at",
-            "header": "Updated"
+            "header": "Updated",
+            "format": "datetime"
           }
         ],
         "rowKey": "user_task_key",
@@ -384,7 +388,8 @@
           },
           {
             "field": "updated_at",
-            "header": "Updated"
+            "header": "Updated",
+            "format": "datetime"
           }
         ],
         "rowKey": "user_task_key",