@nanobpm/nano-workforce 0.158.0 → 0.158.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.158.1](https://github.com/nanobpm/nano-workforce/compare/v0.158.0...v0.158.1) (2026-08-29)
+
+### Bug Fixes
+
+* **cockpit:** derive relay URL from import.meta.url, not location.host ([#600](https://github.com/nanobpm/nano-workforce/issues/600)) ([#612](https://github.com/nanobpm/nano-workforce/issues/612)) ([69923fa](https://github.com/nanobpm/nano-workforce/commit/69923fad688aaa849302be8a1906dd7c6f938c49))
+
 ## [0.158.0](https://github.com/nanobpm/nano-workforce/compare/v0.157.0...v0.158.0) (2026-08-29)
 
 ### Features

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

@@ -164,23 +164,47 @@ test("relay output is written to the drilled worker's terminal", async () => {
   assert.deepEqual(r.terminalWrites, ["boot\n"]);
 });
 
-test("a live drill shows a 'waiting for output' note until the first frame, then clears it", async () => {
+test("a live drill reads 'connecting', promotes to 'waiting' on the subscribe ack, then clears on the first frame", async () => {
   const r = rig();
   const cockpit = bootSupplyCockpit(r.env);
   await cockpit.refresh();
   const note = () => r.host.byClass("cockpit-terminal-note")[0];
 
   cockpit.drill("wk-a");
+  // Before the socket opens/subscribes the note honestly reads "connecting" — not a false "connected".
+  assert.equal(note()?.getAttribute("data-terminal-note"), "connecting", "note armed as connecting before the socket opens");
+  assert.match(note()?.textContent ?? "", /connecting/i);
+
   r.sockets[0]?.fireOpen();
-  assert.equal(note()?.getAttribute("data-terminal-note"), "waiting", "note armed on a connected-but-quiet stream");
+  // The hub ACKs the subscribe → the note promotes to "waiting for live output" on a connected-but-quiet stream.
+  r.sockets[0]?.deliver({ lane: "control", family: "relay", seq: 0, payload: { op: "subscribed", stream: "wk-a", gap: false, nextOffset: 0 } });
+  assert.equal(note()?.getAttribute("data-terminal-note"), "waiting", "note promoted to waiting once the subscribe is acked");
   assert.match(note()?.textContent ?? "", /waiting for live output/i);
 
-  r.sockets[0]?.deliver({ lane: "bulk", family: "relay", seq: 0, payload: { stream: "wk-a", offset: 0, chunk: "hi\n" } });
+  r.sockets[0]?.deliver({ lane: "bulk", family: "relay", seq: 1, payload: { stream: "wk-a", offset: 0, chunk: "hi\n" } });
   assert.equal(note()?.getAttribute("data-terminal-note"), "none", "note cleared the instant the first frame is written");
   assert.equal(note()?.textContent, "");
 });
 
-test("switching to a new stream re-arms the 'waiting' note (the prior stream's cleared note does not persist)", async () => {
+test("a drill whose socket never opens surfaces 'connecting', never a false 'connected'/'waiting' (#600)", async () => {
+  const r = rig();
+  const cockpit = bootSupplyCockpit(r.env);
+  await cockpit.refresh();
+  const note = () => r.host.byClass("cockpit-terminal-note")[0];
+
+  // A dead relay target (the #600 symptom: reconnect-looping, never subscribed) — the socket is created
+  // but never fires open, so the subscribe is never acked. The note must NOT claim the stream connected.
+  cockpit.drill("wk-a");
+  assert.equal(note()?.getAttribute("data-terminal-note"), "connecting", "a socket that never opens reads as connecting, not connected");
+  assert.match(note()?.textContent ?? "", /connecting/i);
+  assert.doesNotMatch(
+    note()?.textContent ?? "",
+    /connected|waiting for live output/i,
+    "a dead socket must not masquerade as a connected-but-quiet stream (#600)",
+  );
+});
+
+test("switching to a new stream re-arms the note (the prior stream's cleared note does not persist)", async () => {
   const r = rig();
   const cockpit = bootSupplyCockpit(r.env);
   await cockpit.refresh();
@@ -192,7 +216,7 @@ test("switching to a new stream re-arms the 'waiting' note (the prior stream's c
   assert.equal(note()?.getAttribute("data-terminal-note"), "none");
 
   cockpit.drill("wk-b");
-  assert.equal(note()?.getAttribute("data-terminal-note"), "waiting", "the new drill re-arms the waiting note");
+  assert.equal(note()?.getAttribute("data-terminal-note"), "connecting", "the new drill re-arms the note (connecting), not stuck on the prior stream's cleared none");
 });
 
 test("the terminal survives a list refresh — it is not re-mounted and keeps streaming", async () => {

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

@@ -314,15 +314,15 @@ class SupplyCockpit implements SupplyCockpitHandle {
     if (mode !== "replay") this.#structuredRegion?.replaceChildren();
   }
 
-  /** Show (or clear) the terminal status note — the "connected, waiting for output" affordance. */
-  #setNote(text: string | undefined): void {
+  /** Show (or clear) the terminal status note — the "connecting" / "waiting for output" affordance. */
+  #setNote(text: string | undefined, state: "connecting" | "waiting" = "waiting"): void {
     if (text === undefined) {
       this.#terminalNote.textContent = "";
       this.#terminalNote.setAttribute("data-terminal-note", "none");
       return;
     }
     this.#terminalNote.textContent = text;
-    this.#terminalNote.setAttribute("data-terminal-note", "waiting");
+    this.#terminalNote.setAttribute("data-terminal-note", state);
   }
 
   async refresh(): Promise<void> {
@@ -528,7 +528,16 @@ class SupplyCockpit implements SupplyCockpitHandle {
       let session: TerminalSession | undefined;
       const client = new RelayChannelClient({
         connect: this.#env.connectRelay,
-        onRelay: (message) => session?.handle(message),
+        onRelay: (message) => {
+          // Promote the note to "waiting for live output" only once the hub ACKs the subscribe. Until
+          // then it honestly reads "connecting", so a socket that never opens/subscribes stops
+          // masquerading as a connected-but-quiet stream (#600). Gate on `!cleared` so a reconnect's
+          // resubscribe ack does not re-arm the note after real output has already flowed.
+          if (!cleared && "op" in message && message.op === "subscribed") {
+            this.#setNote("Waiting for live output…", "waiting");
+          }
+          session?.handle(message);
+        },
         // Re-attach on EVERY (re)connect → resume-from-offset: the terminal survives a cockpit
         // reconnect without losing or double-writing output.
         onOpen: () => session?.attach(),
@@ -544,9 +553,10 @@ class SupplyCockpit implements SupplyCockpitHandle {
       client.open();
       this.#drill = { stream, client };
       this.#setMode("live", stream);
-      // Arm the "waiting for output" note (after #setMode, which clears it): shown until the first
-      // frame is written, so a connected-but-quiet stream reads as "waiting", not "broken".
-      this.#setNote("Connected — waiting for live output…");
+      // Arm the note as "connecting" (after #setMode, which clears it) BEFORE the socket opens. It only
+      // becomes "waiting for live output" when the subscribe is ACKed (onRelay above) and clears on the
+      // first byte, so a dead socket reads as "connecting", never a falsely-"connected" quiet stream (#600).
+      this.#setNote("Connecting…", "connecting");
     } catch (err) {
       // Building the new terminal failed AFTER the prior drill + terminal were already torn down
       // above. Leaving #mode/#shownStream at their prior value would keep the panel showing a stale

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.158.0",
+  "version": "0.158.1",
   "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/cockpit/mount.js

@@ -542,14 +542,14 @@ export function mountCockpit(host, opts = {}) {
     setNote(undefined);
   }
 
-  function setNote(text) {
+  function setNote(text, state = "waiting") {
     if (text == null) {
       terminalNote.textContent = "";
       terminalNote.setAttribute("data-terminal-note", "none");
       return;
     }
     terminalNote.textContent = text;
-    terminalNote.setAttribute("data-terminal-note", "waiting");
+    terminalNote.setAttribute("data-terminal-note", state);
   }
 
   function teardownTerminal() {
@@ -628,7 +628,14 @@ export function mountCockpit(host, opts = {}) {
       let session;
       const client = new RelayChannelClient({
         connect: connectRelay,
-        onRelay: (message) => session?.handle(message),
+        onRelay: (message) => {
+          // Promote the note to "waiting for live output" only once the hub ACKs the subscribe. Until
+          // then it honestly reads "connecting", so a socket that never opens/subscribes stops
+          // masquerading as a connected-but-quiet stream (#600). Gate on `!cleared` so a reconnect's
+          // resubscribe ack does not re-arm the note after real output has already flowed.
+          if (!cleared && message?.op === "subscribed") setNote("Waiting for live output…", "waiting");
+          session?.handle(message);
+        },
         onOpen: () => session?.attach(),
         onError,
       });
@@ -636,8 +643,10 @@ export function mountCockpit(host, opts = {}) {
       client.open();
       drill = { stream, client };
       setMode("live", stream);
-      // Arm the "waiting for output" note (after setMode, which clears it) until the first frame.
-      setNote("Connected — waiting for live output…");
+      // Arm the note as "connecting" (after setMode, which clears it) BEFORE the socket opens. It only
+      // becomes "waiting for live output" when the subscribe is ACKed (onRelay above) and clears on the
+      // first byte, so a dead socket reads as "connecting", never a falsely-"connected" quiet stream (#600).
+      setNote("Connecting…", "connecting");
     } catch (err) {
       // The new terminal failed to build after the prior one was torn down: reset the region to idle
       // (and drop any partially-built terminal) so the UI never shows a stale "live"/"replay"
@@ -811,7 +820,7 @@ export function mountCockpit(host, opts = {}) {
 }
 
 /**
- * Derive the channel WebSocket URL from the current origin (path `/agentic`).
+ * Derive the channel WebSocket URL module-relatively (path `/agentic`, anchored to import.meta.url).
  *
  * The agentic hub authenticates upgrades with an identity token only
  * (`sharedSecretAuthenticator({ requireCredential: false })`) — no capability credential is required.
@@ -824,10 +833,21 @@ export function mountCockpit(host, opts = {}) {
  * token (or an explicit `relayUrl`) for secured deployments.
  */
 function defaultRelayUrl(token, capability) {
-  const proto = location.protocol === "https:" ? "wss:" : "ws:";
-  const base = `${proto}//${location.host}/agentic`;
-  if (!token) return base;
-  const query = new URLSearchParams({ token });
-  if (capability) query.set("capability", capability);
-  return `${base}?${query}`;
+  // Anchor the relay endpoint to THIS MODULE's url (import.meta.url), NOT location.host — exactly as
+  // the HTTP endpoints (reportUrl/transcriptsUrl) are (#279/#467). mount.js is ALWAYS served at
+  // `<appMount>/cockpit/mount.js`, so `../agentic` resolves to `<appMount>/agentic` on every surface,
+  // then swap the scheme http→ws / https→wss:
+  //   • standalone / local App-View: `ws://<app-origin>/agentic` — byte-identical to the old behaviour.
+  //   • Studio console App-View:      `ws://<console>/console/app-view/<app>/agentic` — the app-view
+  //     -prefixed path the console proxies, NOT the console origin root.
+  // Deriving from `location.host` instead dialed the CONSOLE origin behind the App-View — which has no
+  // `/agentic` route (404) and whose app-view proxy refuses WS upgrades (501, ADR 0057 §3) — leaving
+  // the live terminal permanently dead behind the console (#600). This is the WS hop of the same
+  // failure class the HTTP endpoints already fixed by anchoring to import.meta.url.
+  const url = new URL("../agentic", import.meta.url);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (!token) return url.href;
+  url.searchParams.set("token", token);
+  if (capability) url.searchParams.set("capability", capability);
+  return url.href;
 }

package/test/cockpit-embed-endpoints.test.ts

@@ -94,3 +94,87 @@ test("#279: embed.html forwards BOTH reportUrl and transcriptsUrl from the injec
     "embed.html must forward reportUrl: cfg.reportUrl",
   );
 });
+
+// #600: the relay WebSocket default is the WS hop of the SAME #279/#467 failure class. It used to be
+// derived from `location.host` — behind the Studio console that is the console origin (:8080), which
+// has no `/agentic` route (404) and whose app-view proxy refuses WS upgrades (501, ADR 0057 §3), so
+// the live terminal was permanently dead behind the console. The fix anchors it to import.meta.url
+// exactly like the HTTP endpoints, `../agentic` off `<appMount>/cockpit/mount.js`, then swaps the
+// scheme http→ws / https→wss. Unlike reportUrl/transcriptsUrl (inlined `.href`) it is BUILT from
+// `new URL("<spec>", import.meta.url)` so the scheme can be swapped, so it is matched separately.
+
+// Pull the module-relative relay spec out of `new URL("<spec>", import.meta.url);` in defaultRelayUrl()
+// (the HTTP defaults are `new URL(..., import.meta.url).href`, so `)\s*;` matches only the relay one).
+function relaySpec(): string {
+  const m = MOUNT_JS.match(/new URL\(\s*"([^"]*)"\s*,\s*import\.meta\.url\s*\)\s*;/);
+  assert(
+    m,
+    "mount.js defaultRelayUrl() must derive the relay default from new URL(\"<spec>\", import.meta.url), " +
+      "anchored to the module's own served location, not location.host (#600)",
+  );
+  return m![1];
+}
+
+// Resolve the relay spec against a REAL served mount url and swap the scheme, mirroring defaultRelayUrl().
+function resolveRelay(mount: string): string {
+  const url = new URL(relaySpec(), mount);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.href;
+}
+
+test("#600: defaultRelayUrl derives the relay target from import.meta.url, not location.host", () => {
+  assert(
+    !/\$\{location\.host\}/.test(MOUNT_JS),
+    "the relay default must not be interpolated from location.host: behind the console that is the " +
+      "console origin (:8080), which has no /agentic route (404) and refuses WS upgrades (501) (#600)",
+  );
+  const spec = relaySpec();
+  assert(
+    !spec.startsWith("/"),
+    `relay spec "${spec}" must not be absolute: a leading-slash path resolves against the iframe ORIGIN ` +
+      `(console :8080), not the app-view base the console proxies (#279 class)`,
+  );
+  assert(
+    spec.startsWith("../"),
+    `relay spec "${spec}" must step up out of /cockpit/ (mount.js is at <appMount>/cockpit/mount.js; the ` +
+      `hub is a sibling at <appMount>/agentic) (#467 class)`,
+  );
+});
+
+test("#600: relay default resolves to ws://<app-origin>/agentic standalone (behaviour unchanged)", () => {
+  assertEquals(
+    resolveRelay(STANDALONE_MOUNT),
+    "ws://127.0.0.1:3000/agentic",
+    "standalone the relay default must dial the app origin's /agentic exactly as it does today",
+  );
+});
+
+test("#600: relay default resolves onto the app-view base inside the Studio console iframe", () => {
+  assertEquals(
+    resolveRelay(STUDIO_MOUNT),
+    "ws://studio-host:8080/console/app-view/Workforce/agentic",
+    "behind the console the relay must dial the app-view-prefixed /agentic the console proxies, not the " +
+      "console origin root (#279 class) nor the /cockpit/ shell base (#467 class)",
+  );
+});
+
+test("#600: relay default swaps https→wss on a secure surface", () => {
+  assertEquals(
+    resolveRelay("https://studio-host:8443/console/app-view/Workforce/cockpit/mount.js"),
+    "wss://studio-host:8443/console/app-view/Workforce/agentic",
+    "an https surface must yield a wss relay url",
+  );
+});
+
+test("#600: an explicit relayUrl opt and injected __NANO_APP_VIEW__.relayUrl outrank the derived default", () => {
+  // Precedence is pinned in source: opts.relayUrl wins over the module-relative default, and embed.html
+  // forwards the console-injected cfg.relayUrl into that opt so it outranks the default behind the console.
+  assert(
+    /opts\.relayUrl\s*\?\?\s*defaultRelayUrl\(/.test(MOUNT_JS),
+    "mount.js must honour an explicit opts.relayUrl over the derived default (opts.relayUrl ?? defaultRelayUrl(...)) (#600)",
+  );
+  assert(
+    /relayUrl:\s*cfg\.relayUrl/.test(EMBED_HTML),
+    "embed.html must forward relayUrl: cfg.relayUrl so a console-injected __NANO_APP_VIEW__.relayUrl reaches the relay (#600)",
+  );
+});