@nanobpm/nano-workforce 0.171.8 → 0.171.9

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [0.171.9](https://github.com/nanobpm/nano-workforce/compare/v0.171.8...v0.171.9) (2026-09-01)
+
+### Bug Fixes
+
+* **agentic:** spare a still-active job's relay stream on a mid-job reconnect ([#690](https://github.com/nanobpm/nano-workforce/issues/690)) ([e0bb51e](https://github.com/nanobpm/nano-workforce/commit/e0bb51e5cb4a2e1c92f3760a3a4e9c70b8ef3803)), closes [661/#688](https://github.com/661/nano-workforce/issues/688) [#reconcile](https://github.com/nanobpm/nano-workforce/issues/reconcile) [#689](https://github.com/nanobpm/nano-workforce/issues/689) [#689](https://github.com/nanobpm/nano-workforce/issues/689) [#689](https://github.com/nanobpm/nano-workforce/issues/689)
+
 ## [0.171.8](https://github.com/nanobpm/nano-workforce/compare/v0.171.7...v0.171.8) (2026-09-01)
 
 ### Bug Fixes

package/app/agentic/families/presence.family.test.ts

@@ -138,6 +138,22 @@ test("instanceForConnection: resolves the worker instance owning a connection (H
   assertEquals(registry.instanceForConnection(""), undefined, "empty connection → undefined");
 });
 
+test("isInstanceLive: an instance is live while ANY of its connections is open — survives a reconnect (#689)", () => {
+  const store = createPresenceStore(memSqlite());
+  store.ensureSchema();
+  // worker-L reconnected: its OLD connection (cOld) is closed, a NEW one (cNew) is open. Presence is
+  // keyed by instance, so both rows exist; only cNew is live.
+  store.register({ instance: "worker-L", connectionId: "cOld", identity: "leaf", capability: {} });
+  store.register({ instance: "worker-L", connectionId: "cNew", identity: "leaf", capability: {} });
+  store.register({ instance: "worker-Gone", connectionId: "cGone", identity: "leaf", capability: {} });
+  const registry = new PresenceRegistry(store, () => new Set(["cNew"]));
+
+  assertEquals(registry.isInstanceLive("worker-L"), true, "live via its new connection despite the old one dropping");
+  assertEquals(registry.isInstanceLive("worker-Gone"), false, "no live connection → not live");
+  assertEquals(registry.isInstanceLive("unknown"), false, "unknown instance → not live");
+  assertEquals(registry.isInstanceLive(""), false, "empty instance → not live");
+});
+
 test("attributionOf: resolves a worker instance's durable identity + host for job attribution (#485)", () => {
   const store = createPresenceStore(memSqlite());
   store.ensureSchema();

package/app/agentic/families/presence.family.ts

@@ -148,6 +148,25 @@ export class PresenceRegistry {
     return undefined;
   }
 
+  /**
+   * Whether a worker instance currently has a LIVE hub connection — i.e. the worker is present now,
+   * on any connection. Used by the relay slice to distinguish a worker that merely RECONNECTED
+   * mid-job (its old producer connection dropped, a new one re-registered under the SAME instance,
+   * so the instance is still live) from a worker that truly EXITED (all its connections gone, so the
+   * instance is no longer live). The former must NOT complete/archive its still-active job stream on
+   * the stale-producer reconcile; the latter must. Presence is keyed by instance across reconnects,
+   * so this survives the connection churn that a single-connection liveness check cannot. An empty or
+   * unknown instance is not live.
+   */
+  isInstanceLive(instance: string): boolean {
+    if (instance === "") return false;
+    const live = this.#liveConnectionIds();
+    for (const row of this.#store.list()) {
+      if (row.instance === instance && live.has(row.connectionId)) return true;
+    }
+    return false;
+  }
+
   /**
    * Resolve a worker instance's durable identity attributes (presence identity + host) for job
    * attribution (#485). Returns the most recently registered matching row's attributes, or undefined

package/app/agentic/families/relay.family.test.ts

@@ -153,6 +153,7 @@ function mkCorrelatedService(
     attributionForInstance?: (instance: string) => { identity?: string; host?: string } | undefined;
     correlationStore?: AgenticCorrelationStore;
     resolveElementInstance?: (jobKey: string, processInstanceKey?: string) => Promise<string | undefined>;
+    isInstanceLive?: (instance: string) => boolean;
     now?: () => string;
   } = {},
 ): { service: RelayTranscriptService; hub: CapturingHub } {
@@ -167,6 +168,7 @@ function mkCorrelatedService(
     attributionForInstance: extra.attributionForInstance,
     correlationStore: extra.correlationStore,
     resolveElementInstance: extra.resolveElementInstance,
+    isInstanceLive: extra.isInstanceLive,
     now: extra.now,
   });
   return { service, hub };
@@ -885,6 +887,75 @@ test("H6 correlation write-side: a producer disconnect releases its job correlat
   service.teardown();
 });
 
+test("#689 mid-job reconnect: a stale producer whose instance is still live keeps its job correlation", () => {
+  const registry = new ConnectionRegistry();
+  const correlation = new CorrelationRegistry();
+  const byConnection = new Map([["conn-old", "worker-L"]]);
+  // Derive liveness from REAL connections exactly as production's PresenceRegistry.isInstanceLive
+  // does — an instance is live iff some connection attributed to it is still open in the registry —
+  // rather than a static stub decoupled from the connection churn. This makes the test exercise the
+  // very reconnect race the seam guards: the instance is live only while a real live connection
+  // (conn-old, then conn-new) backs it.
+  const isInstanceLive = (instance: string): boolean => {
+    for (const [connId, inst] of byConnection) {
+      if (inst === instance && registry.has(connId)) return true;
+    }
+    return false;
+  };
+  const { service, hub } = mkCorrelatedService(registry, memoryDb(), correlation, byConnection, {
+    isInstanceLive,
+  });
+  const p = connect("conn-old", registry);
+  hub.handler?.(produce(jobStream("5749"), 1, "booting agent"), p.conn);
+  assertEquals(correlation.jobKeysFor("worker-L"), ["5749"], "the job is linked on first produce");
+
+  // The producer's WS connection blips (client reconnects). Model the reconnect faithfully: the new
+  // connection re-registers under the SAME instance BEFORE the reconcile frame, so there is never a
+  // gap where the instance is not live — presence keeps worker-L live across the churn. The old
+  // producer connection then drops. A subsequent frame drives #reconcile — which, seeing the instance
+  // still live via conn-new, must NOT archive the still-active job.
+  byConnection.set("conn-new", "worker-L");
+  const p2 = connect("conn-new", registry);
+  registry.remove("conn-old");
+  const other = connect("cons", registry);
+  hub.handler?.(grant(0), other.conn);
+  assertEquals(correlation.jobKeysFor("worker-L"), ["5749"], "a mid-job reconnect keeps the correlation");
+  assertEquals(service.transcriptOf(jobStream("5749")), undefined, "the still-active stream is NOT archived");
+
+  // The worker resumes producing on the SAME job over its already-open NEW connection → re-attributed,
+  // still one job, transcript still live (not terminal).
+  hub.handler?.(produce(jobStream("5749"), 1, "resumed output"), p2.conn);
+  assertEquals(correlation.jobKeysFor("worker-L"), ["5749"], "the resumed producer stays linked to the same job");
+  assertEquals(service.liveFallback(jobStream("5749"))?.ring !== undefined, true, "the transcript is still live, not completed");
+
+  // Only once the worker truly EXITS (all its connections gone → isInstanceLive false) does a later
+  // reconcile complete the stream and release the correlation.
+  registry.remove("conn-new");
+  hub.handler?.(grant(0), other.conn);
+  assertEquals(correlation.jobKeysFor("worker-L"), [], "a true worker-exit completes + releases the job");
+  assertEquals(service.transcriptOf(jobStream("5749"))?.status, "completed", "the exited worker's stream is archived");
+  service.teardown();
+});
+
+test("#689 mid-job reconnect: with no isInstanceLive wired, a producer disconnect completes as before", () => {
+  const registry = new ConnectionRegistry();
+  const correlation = new CorrelationRegistry();
+  const byConnection = new Map([["prod", "worker-N"]]);
+  // Default seam (isInstanceLive omitted → () => false): a producer disconnect completes the stream,
+  // preserving the prior always-complete-on-disconnect behaviour for callers that don't wire presence.
+  const { service, hub } = mkCorrelatedService(registry, memoryDb(), correlation, byConnection);
+  const p = connect("prod", registry);
+  hub.handler?.(produce(jobStream("kN"), 1, "x"), p.conn);
+  assertEquals(correlation.jobKeysFor("worker-N"), ["kN"]);
+
+  registry.remove("prod");
+  const other = connect("cons", registry);
+  hub.handler?.(grant(0), other.conn);
+  assertEquals(correlation.jobKeysFor("worker-N"), [], "disconnect completes + releases when liveness is unknown");
+  assertEquals(service.transcriptOf(jobStream("kN"))?.status, "completed");
+  service.teardown();
+});
+
 test("H6 correlation write-side: non-job streams are never linked; a link retries until the instance resolves", () => {
   const registry = new ConnectionRegistry();
   const correlation = new CorrelationRegistry();

package/app/agentic/families/relay.family.ts

@@ -252,6 +252,19 @@ export interface RelayTranscriptServiceOptions {
    * ({@link currentPresenceRegistry}). A resolver returning undefined → no linking (advisory).
    */
   readonly instanceForConnection?: (connectionId: string) => string | undefined;
+  /**
+   * Whether a worker instance is still live on any hub connection (#689). Wired to the presence
+   * registry's {@link PresenceRegistry.isInstanceLive}. The disconnect-driven reconcile uses it to
+   * spare a still-active job's stream when its worker merely RECONNECTED mid-job (old producer
+   * connection dropped, a new one re-registered under the same instance): completing then would
+   * archive a live job's transcript and release its correlation, wedging the cockpit (the reconnected
+   * worker's produce frames hit a terminal `completed` stream and are ignored) while the harness
+   * keeps the engine lease. When wired to presence, a true worker-exit still completes: presence
+   * has dropped the instance, so this returns false. Omitted (`() => false`, the static default) →
+   * the prior always-complete-on-disconnect behaviour — every disconnect completes, reconnect
+   * included (the seam never consults presence, so its value does not vary).
+   */
+  readonly isInstanceLive?: (instance: string) => boolean;
   /**
    * Resolve a producing worker instance's durable identity attributes (identity / host) — read at
    * job-completion time and persisted with the attribution so a PAST session stays attributable to a
@@ -317,6 +330,8 @@ export class RelayTranscriptService {
   readonly #correlation: () => CorrelationLink | undefined;
   /** The connection → producing-instance resolver (H6, #149). */
   readonly #instanceForConnection: (connectionId: string) => string | undefined;
+  /** Whether a worker instance is still live on any connection (#689) — gates disconnect completion. */
+  readonly #isInstanceLive: (instance: string) => boolean;
   /** Resolve a worker instance's durable identity attributes for attribution (#485). */
   readonly #attributionForInstance: (instance: string) => WorkerAttribution | undefined;
   /** The durable worker-attribution store, or undefined when unpersisted (#485). */
@@ -331,6 +346,7 @@ export class RelayTranscriptService {
     this.#log = options.log;
     this.#correlation = options.correlation ?? currentCorrelation;
     this.#instanceForConnection = options.instanceForConnection ?? (() => undefined);
+    this.#isInstanceLive = options.isInstanceLive ?? (() => false);
     this.#attributionForInstance = options.attributionForInstance ?? (() => undefined);
     this.#resolveElementInstance = options.resolveElementInstance;
     this.#now = options.now ?? (() => new Date().toISOString());
@@ -718,6 +734,19 @@ export class RelayTranscriptService {
   #reconcile(): void {
     for (const [stream, state] of this.#streams) {
       if (state.producer !== undefined && !this.#registry.has(state.producer)) {
+        // Producer connection gone. Normally that means the job it was relaying ended — release the
+        // correlation and flush+complete its ephemeral transcript. BUT a worker that merely
+        // RECONNECTED mid-job (#689) also loses its old producer connection while its job keeps
+        // running (the harness holds the engine lease and extends it). Presence re-registers the SAME
+        // instance under the new connection, so the instance stays live even though this specific
+        // producer connection is gone. Completing then would archive a still-active job's transcript
+        // to `historical` and drop its correlation — and because a completed stream is terminal
+        // (`#observe` ignores later frames), the reconnected worker could NEVER re-correlate: the
+        // cockpit shows the worker idle with a frozen transcript while the job is genuinely running.
+        // So spare the stream while its instance is still live; the next `produce` re-attributes the
+        // live connection (via `#observe`), a NEW job supersedes it (via `#link`), or — once the
+        // worker truly exits — presence drops the instance and a later reconcile completes it.
+        if (state.instance !== undefined && this.#isInstanceLive(state.instance)) continue;
         // Producer connection gone → the job it was relaying ended: release its correlation.
         this.#unlink(stream, state);
         // ...and flush+complete an ephemeral, not-yet-completed transcript exactly as before.
@@ -857,6 +886,11 @@ export function createRelayFamily(options: {
         // are read per call, so this works regardless of family mount order (relay may mount before
         // presence/correlation). Absent registries → no linking, still advisory-correct.
         instanceForConnection: (connectionId) => currentPresenceRegistry()?.instanceForConnection(connectionId),
+        // #689: is the producing worker instance still live on ANY connection? Gates the
+        // disconnect-driven reconcile so a mid-job RECONNECT (old producer connection dropped, the
+        // same instance re-registered) does not archive a still-active job's stream and wedge its
+        // correlation. Read per call for the same mount-order independence as the resolvers above.
+        isInstanceLive: (instance) => currentPresenceRegistry()?.isInstanceLive(instance) ?? false,
         // #485: resolve a completed job's worker attribution (presence identity/host) from the live
         // presence registry, read per call for the same mount-order independence. Absent → attribution
         // records instance only.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanobpm/nano-workforce",
-  "version": "0.171.8",
+  "version": "0.171.9",
   "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",