@nanobpm/nano-workforce 0.188.1 → 0.189.1

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

@@ -111,6 +111,56 @@ test("the rendered transcript region sits directly beneath the Workers — suppl
   }
 });
 
+// #802 — the DEPLOYED browser twin (mount.js) must surface a STALE harness as a distinct badge, and
+// a healthy one with none. The typed renderer (`supply-render.ts`) has its own test, but the twin is
+// hand-maintained and previously had no non-empty supply-row coverage, so it could silently stop
+// surfacing stale harnesses while the typed test stayed green.
+test("#802: mount.js renders a stale-harness badge for a stale worker and none for a healthy one", async () => {
+  const worker = (instance: string, harnessStale: boolean, harnessProtocol?: number) => ({
+    instance,
+    identity: "senior",
+    stream: instance,
+    family: "senior",
+    host: "h1",
+    jobKeys: [],
+    live: true,
+    staleMs: 0,
+    harnessStale,
+    ...(harnessProtocol !== undefined ? { harnessProtocol } : {}),
+  });
+  const workers = [worker("wk-stale", true, 0), worker("wk-ok", false, 3)];
+  const report = { count: workers.length, workers, leaves: [{ token: "senior", workers }], correlations: [] };
+  const restore = installEnv((url) => {
+    const ok = (body: unknown) => Promise.resolve({ ok: true, status: 200, json: async () => body });
+    if (url.includes("/supply")) return ok(report);
+    if (url.includes("/agent-instances")) return ok({ count: 0, instances: [] });
+    if (url.includes("/transcripts")) return ok({ sessions: [] });
+    return Promise.resolve({ ok: false, status: 404, json: async () => ({}) });
+  });
+  try {
+    const { mountCockpit } = await import("../../../pages/cockpit/mount.js");
+    const handle = mountCockpit(document.getElementById("root"), OPTS);
+    try {
+      await handle.refresh();
+      const staleRow = document.querySelector('.cockpit-supply-worker[data-worker="wk-stale"]');
+      const okRow = document.querySelector('.cockpit-supply-worker[data-worker="wk-ok"]');
+      assert(staleRow != null && okRow != null, "both worker rows rendered");
+      const badge = staleRow?.querySelector('.cockpit-supply-harness-stale[data-harness-stale="true"]');
+      assert(badge != null, "the stale worker carries the harness-stale badge");
+      assertEquals(badge?.textContent, "stale harness (v0)", "the badge shows the advertised protocol");
+      assertEquals(
+        okRow?.querySelector(".cockpit-supply-harness-stale"),
+        null,
+        "the healthy worker carries no harness-stale badge",
+      );
+    } finally {
+      handle.dispose();
+    }
+  } finally {
+    restore();
+  }
+});
+
 test("live drill renders the transcript — a nwfTranscriptEvent chunk is never surfaced verbatim", async () => {
   const restore = installEnv(fetchStub());
   try {

package/app/agentic/cockpit/supply-render.test.ts

@@ -140,3 +140,23 @@ test("H6: a worker with no correlation renders an em-dash process cell", () => {
   assert.equal(cell?.text(), "—");
   assert.equal(cell?.getAttribute("data-correlations"), "0");
 });
+
+test("#802: renders a stale-harness badge for a worker below the minimum / with no advertised protocol", () => {
+  const host = new FakeElement("body");
+  const staleWorker = { instance: "wk-old", identity: "leaf-1", stream: "wk-old", family: "senior", host: "h1", jobKeys: [], live: true, staleMs: 0, harnessStale: true };
+  const okWorker = { instance: "wk-ok", identity: "leaf-1", stream: "wk-ok", family: "senior", host: "h2", jobKeys: [], live: true, staleMs: 0, harnessStale: false, harnessProtocol: 3 };
+  const report: SupplyReport = {
+    count: 2,
+    workers: [staleWorker, okWorker],
+    leaves: [{ token: "leaf-1", workers: [staleWorker, okWorker] }],
+  };
+  renderSupply(host, doc, supplyView(report));
+
+  const rowOld = host.byData("worker", "wk-old")[0];
+  assert.equal(rowOld?.getAttribute("data-harness-stale"), "true");
+  assert.equal(rowOld?.byClass("cockpit-supply-harness-stale").length, 1, "stale harness badge rendered");
+
+  const rowOk = host.byData("worker", "wk-ok")[0];
+  assert.equal(rowOk?.getAttribute("data-harness-stale"), "false");
+  assert.equal(rowOk?.byClass("cockpit-supply-harness-stale").length, 0, "no badge for a healthy harness");
+});

package/app/agentic/cockpit/supply-render.ts

@@ -51,6 +51,7 @@ function workerRow(doc: DocumentLike, worker: SupplyWorkerView, options: RenderS
   row.setAttribute("data-worker", worker.instance);
   row.setAttribute("data-liveness", worker.liveness);
   row.setAttribute("data-stream", worker.stream);
+  row.setAttribute("data-harness-stale", String(worker.harnessStale));
 
   const nameCell = el(doc, "td", "cockpit-td cockpit-supply-name");
   nameCell.appendChild(dot(doc, worker.liveness));
@@ -82,6 +83,20 @@ function workerRow(doc: DocumentLike, worker: SupplyWorkerView, options: RenderS
     }
     nameCell.appendChild(drill);
   }
+  // A stale harness silently swallows machine-readable artifacts (issue #802) — surface it as a
+  // distinct badge so the operator can drain/upgrade the worker. Separate from the liveness dot,
+  // which grades heartbeat recency, not harness capability.
+  if (worker.harnessStale) {
+    const badge = el(
+      doc,
+      "span",
+      "cockpit-supply-harness-stale",
+      worker.harnessProtocol === undefined ? "stale harness" : `stale harness (v${worker.harnessProtocol})`,
+    );
+    badge.setAttribute("data-harness-stale", "true");
+    badge.setAttribute("title", "Harness protocol below the configured minimum (or none advertised); jobs may dead-end.");
+    nameCell.appendChild(badge);
+  }
   row.appendChild(nameCell);
 
   row.appendChild(el(doc, "td", "cockpit-td cockpit-supply-family", worker.family));

package/app/agentic/cockpit/supply-view.ts

@@ -38,9 +38,16 @@ export interface SupplyWorkerReport {
   readonly live: boolean;
   /** How long since the worker's last liveness refresh, in ms. */
   readonly staleMs: number;
+  /**
+   * Whether the worker's HARNESS is stale — its advertised harness protocol is below the configured
+   * minimum, or it advertised none at all (issue #802). Distinct from {@link Liveness} `"stale"`,
+   * which grades heartbeat recency. A stale harness silently swallows machine-readable artifacts
+   * (AgentInstance / transcript / result envelope), so its jobs dead-end at human escalations.
+   */
+  readonly harnessStale?: boolean;
+  /** The harness protocol version the worker advertised at enrolment, if any (issue #802). */
+  readonly harnessProtocol?: number;
 }
-
-/** The supply registered under one leaf token. */
 export interface SupplyLeafReport {
   readonly token: string;
   readonly workers: readonly SupplyWorkerReport[];
@@ -128,6 +135,10 @@ export interface SupplyWorkerView {
   readonly liveness: Liveness;
   /** How long since the last liveness refresh, in ms. */
   readonly staleMs: number;
+  /** Whether the worker's harness protocol is stale (below minimum / absent) — issue #802. */
+  readonly harnessStale: boolean;
+  /** The advertised harness protocol version, if any (issue #802). */
+  readonly harnessProtocol?: number;
 }
 
 /** One leaf-token section in the renderable supply view. */
@@ -212,6 +223,12 @@ function workerView(
     correlations,
     liveness: liveness(worker, staleAfterMs),
     staleMs: worker.staleMs,
+    // Fail loud: a report without a harness verdict (an older/cached response) has no trustworthy
+    // protocol assessment, so keep the worker visible as STALE until the server supplies a healthy one
+    // — mirrors the server's `harness?.stale ?? true` (issue #802). Defaulting to `false` here would
+    // let a cached response hide exactly the workers this surface is meant to expose.
+    harnessStale: worker.harnessStale ?? true,
+    ...(worker.harnessProtocol !== undefined ? { harnessProtocol: worker.harnessProtocol } : {}),
   };
 }
 

package/app/agentic/permission-bridge.test.ts

@@ -141,7 +141,7 @@ test("escalate REQUEST → Tasks-inbox row → operator ALLOW via the completion
   assertEquals(result.completion.elementId, "acp-permission");
   assertEquals(completed.length, 1);
   assertEquals(completed[0].userTaskKey, "ut-perm-1");
-  assertEquals(completed[0].variables, { optionId: "allow", allowed: true });
+  assertEquals(completed[0].variables, { optionId: "allow", allowed: true, completedUserTaskKey: "ut-perm-1", completedCompletionId: 1 });
   assertEquals(stores.task_completions.rows.length, 1);
   assertEquals(stores.task_completions.rows[0].actor_kind, "human");
 
@@ -173,7 +173,7 @@ test("escalate REQUEST → operator DENY via the completion door → RESOLUTION
   });
 
   assertEquals(result.completion.ok, true);
-  assertEquals(completed[0].variables, { optionId: "deny", allowed: false });
+  assertEquals(completed[0].variables, { optionId: "deny", allowed: false, completedUserTaskKey: "ut-perm-2", completedCompletionId: 1 });
   assertEquals(frames.length, 1);
   const resolution = decodeResolution(frames[0]);
   assertEquals(resolution.callId, "job-deny");

package/app/agentic/vocab/demand-report.test.ts

@@ -5,8 +5,11 @@ import { test } from "node:test";
 import { assert, assertEquals } from "#test-assert";
 import type { TaskDefinitionLeaf } from "@nanobpm/agentic/demand";
 import type { RegisteredWorker } from "@nanobpm/agentic/vocab";
+import { HarnessProtocolRegistry } from "../../harnessProtocol.ts";
+import { noopLog } from "../../../test/log.ts";
+import { memDataFor } from "../../../test/worldDb.ts";
 import { CREW_VOCAB_VERSION } from "./crew-vocab.ts";
-import { buildRegistryReport, engineRestAddress, toWireReport } from "./demand-report.ts";
+import { buildRegistryReport, computeRegistryReport, engineRestAddress, toWireReport } from "./demand-report.ts";
 
 const NOW = new Date(0);
 // A demanded taskDefinition leaf. `agentic` is the structural signal the engine reads from a task's
@@ -142,3 +145,65 @@ test("engineRestAddress strips trailing slashes from the derived NANOBPMN_BASE_U
     else process.env.NANOBPMN_BASE_URL = prevBase;
   }
 });
+
+test("#802: toWireReport carries staleWorkers through, omitting harnessProtocol when absent", () => {
+  const base = buildRegistryReport({ taskDefinitions: [], workers: [seniorImpl] });
+  const report = {
+    ...base,
+    staleWorkers: [
+      { instance: "wk-old", stale: true },
+      { instance: "wk-low", stale: true, harnessProtocol: 0 },
+    ],
+  };
+  const wire = toWireReport(report);
+  assertEquals(wire.staleWorkers, [
+    { instance: "wk-old", stale: true },
+    { instance: "wk-low", stale: true, harnessProtocol: 0 },
+  ]);
+});
+
+test("#802: toWireReport omits staleWorkers entirely when the report has none (supply-only build)", () => {
+  const report = buildRegistryReport({ taskDefinitions: [], workers: [seniorImpl] });
+  assertEquals("staleWorkers" in toWireReport(report), false);
+});
+
+const HARNESS_MIGRATIONS = ["107_worker_harness_protocol.sql"];
+
+test("#802: computeRegistryReport threads live workers through the registry into staleWorkers", async () => {
+  // Exercises the real assessment→staleWorkers wiring end-to-end against a mounted registry (migration
+  // 107) rather than hand-building `staleWorkers` before `toWireReport`: a regression in passing the
+  // live workers through `assessWorkersWithAvailability` would otherwise stay green.
+  const { data } = memDataFor(HARNESS_MIGRATIONS);
+  const reg = new HarnessProtocolRegistry(data);
+  await reg.recordEnrolment("w-front", 5); // healthy (>= default min 1)
+  await reg.recordEnrolment("w-kimi", 0); // below minimum → stale
+  // seniorImpl ("w-senior") never enrolled a protocol → absent → stale.
+  const report = await computeRegistryReport(noopLog(), data, [plannerFrontier, plannerKimi, seniorImpl]);
+  assertEquals(report.staleWorkers, [
+    { instance: "w-kimi", stale: true, harnessProtocol: 0 },
+    { instance: "w-senior", stale: true },
+  ]);
+  // The stale-harness condition is folded into the OVERALL status so the board's status pill (which
+  // renders only `report.status`, not `staleWorkers`) turns RED rather than staying green (issue #802).
+  assertEquals(report.status, "red");
+});
+
+test("#802: computeRegistryReport keeps status green when every enrolled harness is healthy", async () => {
+  // Guards the fold's other edge: a mounted registry with NO stale workers must NOT force `red` — the
+  // overall status stays whatever demand×supply produced (here green, empty demand / no missing).
+  const { data } = memDataFor(HARNESS_MIGRATIONS);
+  const reg = new HarnessProtocolRegistry(data);
+  await reg.recordEnrolment("w-front", 5);
+  await reg.recordEnrolment("w-senior", 5);
+  const report = await computeRegistryReport(noopLog(), data, [plannerFrontier, seniorImpl]);
+  assertEquals(report.staleWorkers, []);
+  assertEquals(report.status, "green");
+});
+
+test("#802: computeRegistryReport OMITS staleWorkers when the registry cannot be consulted", async () => {
+  // A legacy DB predating migration 107: the bounded read throws → registryAvailable=false, so the
+  // report must omit staleWorkers rather than mislabel an outage as a fleet-wide drain signal.
+  const { data } = memDataFor([]);
+  const report = await computeRegistryReport(noopLog(), data, [plannerFrontier, seniorImpl]);
+  assertEquals("staleWorkers" in report, false, "an outage omits staleWorkers, not report every worker stale");
+});

package/app/agentic/vocab/demand-report.ts

@@ -18,9 +18,10 @@ import {
   type TaskDefinitionLeaf,
 } from "@nanobpm/agentic/demand";
 import type { RegisteredWorker } from "@nanobpm/agentic/vocab";
-import type { Logger } from "@nanobpm/urban";
-import type { RegistryReport as WireRegistryReport } from "../../../nano-generated/api-io.d.ts";
+import type { DataLayer, Logger } from "@nanobpm/urban";
+import type { StaleWorker, RegistryReport as WireRegistryReport } from "../../../nano-generated/api-io.d.ts";
 import { resolveEngineAddress } from "../../enginePreflight.ts";
+import { assessWorkersWithAvailability, type HarnessAssessment } from "../../harnessProtocol.ts";
 import { envVar } from "../../version.ts";
 import { currentPresenceRegistry } from "../families/presence.family.ts";
 import { CREW_VOCAB_VERSION, crewResolver } from "./crew-vocab.ts";
@@ -38,6 +39,15 @@ export interface RegistryReport extends DemandSupplyReport {
    * demand is unavailable rather than silently showing "no demand".
    */
   readonly demandUnavailable: boolean;
+  /**
+   * The enrolled workers whose harness is STALE (issue #802) — below the configured minimum protocol,
+   * or advertising no version at all — so they may silently swallow AgentInstance / transcript /
+   * result-envelope artifacts and should be drained. Empty when every supplied worker is healthy;
+   * omitted only when the harness-protocol registry could not be consulted. When non-empty, the
+   * overall {@link DemandSupplyReport.status} is folded to `red` (a drain signal), because the board
+   * renders only `status` and does not surface this list on its own.
+   */
+  readonly staleWorkers?: readonly HarnessAssessment[];
 }
 
 /**
@@ -159,15 +169,53 @@ export function toWireReport(report: RegistryReport): WireRegistryReport {
       })),
     },
     status: report.status,
+    ...(report.staleWorkers !== undefined
+      ? {
+          staleWorkers: report.staleWorkers.map((w): StaleWorker => {
+            const out: StaleWorker = { instance: w.instance, stale: w.stale };
+            if (w.harnessProtocol !== undefined) out.harnessProtocol = w.harnessProtocol;
+            return out;
+          }),
+        }
+      : {}),
   };
 }
 
 /**
  * The composition path the `getAgenticRegistry` operation calls: read demand from the engine, read
- * supply from the presence registry, and build the report. Never throws for an engine outage — it
- * degrades to a supply-only report.
+ * supply from the presence registry, assess harness staleness (issue #802), and build the report.
+ * Never throws for an engine outage — it degrades to a supply-only report; the staleness assessment
+ * is best-effort and omitted when no data layer is mounted.
+ *
+ * `workers` defaults to the live presence feed ({@link supplyWorkers}); it is injectable so a test can
+ * drive the full assessment→`staleWorkers` wiring against a real registry without mounting the global
+ * presence family.
  */
-export async function computeRegistryReport(log?: Logger): Promise<RegistryReport> {
+export async function computeRegistryReport(
+  log?: Logger,
+  data?: DataLayer,
+  workers: readonly RegisteredWorker[] = supplyWorkers(),
+): Promise<RegistryReport> {
   const taskDefinitions = await readDemand(log);
-  return buildRegistryReport({ taskDefinitions, workers: supplyWorkers() });
+  const report = buildRegistryReport({ taskDefinitions, workers });
+  if (!data) return report;
+  const { registryAvailable, assessments } = await assessWorkersWithAvailability(
+    data,
+    workers.map((w) => w.instance),
+  );
+  // The registry could not be consulted (read outage / legacy DB): OMIT `staleWorkers` per the report
+  // contract, so an operator cannot mistake "the registry is unavailable" for "every harness is stale"
+  // and treat an outage as a fleet-wide drain signal (issue #802).
+  if (!registryAvailable) return report;
+  const staleWorkers = [...assessments.values()]
+    .filter((a) => a.stale)
+    .sort((a, b) => a.instance.localeCompare(b.instance));
+  // Fold the stale-harness condition into the OVERALL status (issue #802). The board renders only
+  // `report.status` as its overall pill and does not surface `staleWorkers`, so without this a
+  // healthy-demand report (status `green`/`amber`) would still show green while enrolled harnesses are
+  // stale — silently swallowing AgentInstance / transcript / result-envelope artifacts. A stale
+  // harness is a drain signal, so any stale worker forces the overall status to `red` (`red` is
+  // already the worst grade, so this never downgrades an existing `red`).
+  const status = staleWorkers.length > 0 ? "red" : report.status;
+  return { ...report, status, staleWorkers };
 }