@lensmcp/cluster 1.18.0 → 1.18.1

package/executors/gateway/runtime/lens-children.d.ts

@@ -44,6 +44,12 @@ export interface LensChildren {
      *  everything"): spawn each app's vite (+ capture) in the workspace's OWN root + event bus, on a
      *  collision-safe port, and point its route target at that port. Returns a reaper for unregister. */
     hostWorkspaceApps(fragment: WorkspaceFragment): Promise<() => void>;
+    /** ONE liveness round over every tracked lens-frontend vite: TCP-probe its pinned port, emit the
+     *  RECOVERY edge (`service-up`) the first time it accepts, and — past the spawn grace and with the
+     *  probe enabled — the wedge verdict + SIGKILL. The sweeper calls this on a timer; it is exposed
+     *  (like `ServiceLayer.scanNow`) so the transitions are testable without a 15-second interval.
+     *  Concurrency-guarded: a call while a round is in flight returns immediately. */
+    probeLensFrontends(): Promise<void>;
     /** Reap all managed children (called from `stop()`): SIGTERM, a grace window, then SIGKILL any survivor
      *  (vite ignores SIGTERM → would orphan when the daemon exits). Async so `stop()` awaits the escalation. */
     reapAll(): Promise<void>;

package/executors/gateway/runtime/lens-children.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lens-children.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/lens-children.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,kCAAkC,CAAC;AAI1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAuB,MAAM,SAAS,CAAC;AAiB1F,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA0B7E,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAalE;AAyBD;;;;;;mDAMmD;AACnD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAG1F;AAMD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAClF,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;iFAGiF;AACjF,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAQvE;AAED,MAAM,WAAW,YAAY;IAC3B,iBAAiB,EAAE,UAAU,CAAC;IAC9B;;gFAE4E;IAC5E,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC;;6GAEyG;IACzG,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC;IACvF;;yGAEqG;IACrG,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;IACpE;gHAC4G;IAC5G,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,cAAc,EAClB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,qBAAqB,EAE9B,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,GACzD,YAAY,CAmcd"}
+{"version":3,"file":"lens-children.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/lens-children.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,UAAU,EAChB,MAAM,kCAAkC,CAAC;AAI1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE1D,OAAO,KAAK,EAAE,cAAc,EAAE,qBAAqB,EAAuB,MAAM,SAAS,CAAC;AAiB1F,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AA0B7E,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAalE;AAyBD;;;;;;mDAMmD;AACnD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,SAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAG1F;AAMD;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GAClF,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED;;;iFAGiF;AACjF,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,CAQvE;AAED,MAAM,WAAW,YAAY;IAC3B,iBAAiB,EAAE,UAAU,CAAC;IAC9B;;gFAE4E;IAC5E,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC;;6GAEyG;IACzG,sBAAsB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC,CAAC;IACvF;;yGAEqG;IACrG,iBAAiB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;IACpE;;;;sFAIkF;IAClF,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC;gHAC4G;IAC5G,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,cAAc,EAClB,GAAG,EAAE,aAAa,EAClB,OAAO,EAAE,qBAAqB,EAE9B,IAAI,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,GACzD,YAAY,CAwfd"}

package/executors/gateway/runtime/lens-children.js

@@ -145,11 +145,6 @@ deps) {
     // `portConflicts` counts CONSECUTIVE lost bind races (EADDRINUSE) — forgiven rather than charged to
     // `attempts`, but capped so a permanently-squatted port still falls back to backoff.
     const lensHeal = new Map();
-    // Zombie recycle + LIVENESS probe: the live `lens:true` app VITE children (label 'vite') + when each
-    // spawned, its pinned `port`, and its run of consecutive probe failures. `port`/`probeFails` drive the
-    // wedge probe (alive but NOT listening); `spawnedAt` also drives the stale-source-set recycle. Both reset
-    // naturally on a respawn, which registers a FRESH handle. The capture sidecar + the dashboard/MCP
-    // singletons are NOT tracked (they don't serve app source).
     const viteChildren = new Map();
     // Per-project last-recycle time — the cooldown survives the kill→auto-heal→respawn (a new child handle).
     const viteRecycleAt = new Map();
@@ -210,8 +205,20 @@ deps) {
         // The port THIS child owns (pinned `--port <n> --strictPort`): what the liveness probe checks and what
         // the respawn must wait to be free. `undefined` for the dashboard/MCP singletons + an unpinned vite.
         const ownPort = isVite ? viteArgPort(args) : undefined;
-        if (isVite)
-            viteChildren.set(child, { project: env?.['LENSMCP_PROJECT'] ?? 'app', spawnedAt, port: ownPort, probeFails: 0 });
+        if (isVite) {
+            // `spawnLensFrontend` always stamps the OWNING workspace's bus into the child env, so this is
+            // the authoritative "whose app is this" — a registered workspace's lifecycle events go to its
+            // own `.lensmcp/events.jsonl`, exactly as the service layer's `emitSvc` routes pod events.
+            const childBus = typeof env?.['LENSMCP_EVENT_FILE'] === 'string' ? env['LENSMCP_EVENT_FILE'] : undefined;
+            viteChildren.set(child, {
+                project: env?.['LENSMCP_PROJECT'] ?? 'app',
+                spawnedAt,
+                port: ownPort,
+                probeFails: 0,
+                listening: false,
+                ...(childBus && childBus !== rt.eventFile ? { bus: childBus } : {}),
+            });
+        }
         child.on('exit', (code, sig) => {
             const idx = lensChildren.indexOf(child);
             if (idx >= 0)
@@ -269,7 +276,7 @@ deps) {
     // 502ing forever. The kill lands on the proven exit→auto-heal path, which respawns after waiting the port
     // out. `probeInFlight` keeps a slow round from overlapping the next tick.
     let probeInFlight = false;
-    const probeLensChildren = async (cfg) => {
+    const probeLensChildren = async (cfg, killWedged) => {
         if (probeInFlight)
             return;
         probeInFlight = true;
@@ -281,22 +288,39 @@ deps) {
                     continue; // unpinned port ⇒ nothing to probe
                 if (child.exitCode !== null || child.signalCode !== null)
                     continue; // already dying — the exit heal owns it
-                if (Date.now() - meta.spawnedAt < cfg.graceMs) {
-                    meta.probeFails = 0;
-                    continue;
-                } // still booting
+                // The probe now runs DURING the spawn grace too. It costs one extra TCP connect per child
+                // for the first `graceMs`, and it buys the RECOVERY edge below at first-listen instead of
+                // 45s later — the grace exists to withhold the KILL verdict from a booting vite, not to
+                // withhold the observation that it came up.
                 if (await probePortListening(meta.port, types_1.LENS_PROBE_TIMEOUT_MS)) {
                     meta.probeFails = 0;
+                    // RECOVERY EDGE. A wedged/zombie-recycled vite is SIGKILLed and auto-healed by the exit
+                    // handler, which announces nothing — so `pod-recycle` (→ `wedged` in the lens fold) had no
+                    // counterpart and a lens app stayed "wedged" for the rest of the session while serving
+                    // every request (foodguard 2026-07-31: `wedged: ["authentication","dashboard"]`, `up: []`,
+                    // zero 502s). An accepting listener is the same evidence the wedge verdict is the absence
+                    // of, so it is what clears it. Once per generation: a fresh child starts `listening: false`.
+                    if (!meta.listening) {
+                        meta.listening = true;
+                        emit('info', `lens app up: ${meta.project} (vite :${meta.port} listening)`, `cluster-lens-app:${meta.project}`, { kind: 'service-up', project: meta.project, port: meta.port }, undefined, meta.bus);
+                    }
                     continue;
                 }
+                if (Date.now() - meta.spawnedAt < cfg.graceMs) {
+                    meta.probeFails = 0;
+                    continue;
+                } // still booting
+                if (!killWedged)
+                    continue; // liveness still OBSERVED above; only the kill verdict is switched off
                 meta.probeFails += 1;
                 const reason = (0, lifecycle_1.lensChildWedged)(meta, viteRecycleAt.get(meta.project) ?? 0, Date.now(), cfg);
                 if (!reason)
                     continue; // failing, but not yet N-in-a-row / still in cooldown
                 viteRecycleAt.set(meta.project, Date.now());
                 meta.probeFails = 0;
+                meta.listening = false; // re-arm the recovery edge, in case the SIGKILL below doesn't take
                 console.error(`[gateway] wedge recycle: lens app ${meta.project} is ALIVE but NOT LISTENING on :${meta.port} after ${Math.max(2, cfg.failureThreshold)} probes — SIGKILL; a fresh vite is coming.`);
-                emit('warning', `wedge recycle: ${meta.project} (${reason})`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason, port: meta.port });
+                emit('warning', `wedge recycle: ${meta.project} (${reason})`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason, port: meta.port }, undefined, meta.bus);
                 try {
                     child.kill('SIGKILL');
                 }
@@ -321,14 +345,15 @@ deps) {
         if (lensSweeper || (!types_1.POD_RECYCLE_ENABLED && !types_1.LENS_PROBE_ENABLED))
             return;
         const cfg = { graceMs: types_1.POD_STALE_GRACE_MS, settleMs: types_1.POD_RECYCLE_SETTLE_MS, cooldownMs: types_1.POD_STALE_RECYCLE_COOLDOWN_MS };
-        const probeCfg = { graceMs: types_1.LENS_PROBE_GRACE_MS, failureThreshold: types_1.LENS_PROBE_FAILS, cooldownMs: types_1.LENS_PROBE_COOLDOWN_MS };
         lensSweeper = setInterval(() => {
             if (rt.stopped() || viteChildren.size === 0)
                 return;
             // The liveness probe is INDEPENDENT of the source-set clock — a wedge has nothing to do with the file
-            // set, so it must run before (and regardless of) the staleness early-return below.
-            if (types_1.LENS_PROBE_ENABLED)
-                void probeLensChildren(probeCfg);
+            // set, so it must run before (and regardless of) the staleness early-return below. It runs whenever
+            // the sweeper does: `LENS_PROBE_ENABLED` gates the KILL verdict, NOT the observation, because the
+            // probe is also the only RECOVERY signal a lens frontend has — with the staleness recycle on and the
+            // probe off, a zombie-recycled app would otherwise stay `wedged` in the fold forever.
+            void probeLensFrontends();
             if (!types_1.POD_RECYCLE_ENABLED)
                 return;
             const wideChangedAt = rt.sourceSetChangedAt ?? 0;
@@ -343,8 +368,9 @@ deps) {
                 if (!(0, lifecycle_1.lensFrontendStale)(meta.spawnedAt, last, changedAt, now, cfg))
                     continue;
                 viteRecycleAt.set(meta.project, now);
+                meta.listening = false; // re-arm the recovery edge — the respawned vite must announce itself
                 console.log(`[gateway] zombie recycle: lens app ${meta.project} (stale-source-set) — vite missed a file add; restarting it`);
-                emit('warning', `zombie recycle: ${meta.project} (stale-source-set)`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason: 'stale-source-set' });
+                emit('warning', `zombie recycle: ${meta.project} (stale-source-set)`, `cluster-lens-app:${meta.project}`, { kind: 'pod-recycle', project: meta.project, reason: 'stale-source-set' }, undefined, meta.bus);
                 try {
                     child.kill('SIGTERM');
                 }
@@ -569,7 +595,10 @@ deps) {
                     labelPrefix,
                     log: (l) => console.log(l),
                 }, spawnInRoot);
-                emit('info', `lens app started: ${fragment.wsKey}/${project} (vite :${port})`, `cluster-lens-app:${fragment.wsKey}:${project}`, { kind: 'lens-app-up', project, port });
+                // Onto the REGISTERED workspace's OWN bus (like the service layer's `emitSvc`): its cluster
+                // view must show its apps, and the daemon's must not — two workspaces can both own a
+                // project called `dashboard`, so a shared bus makes the fold ambiguous as well as wrong.
+                emit('info', `lens app started: ${fragment.wsKey}/${project} (vite :${port})`, `cluster-lens-app:${fragment.wsKey}:${project}`, { kind: 'lens-app-up', project, port }, undefined, eventFile);
             }
             catch (e) {
                 console.error(`[gateway] lens app ${fragment.wsKey}/${project}: ${e.message}`);
@@ -617,5 +646,6 @@ deps) {
             }
         }
     };
-    return { spawnManagedChild, bootSingletonsAndApps, hostWorkspaceDashboard, hostWorkspaceApps, reapAll };
+    const probeLensFrontends = () => probeLensChildren({ graceMs: types_1.LENS_PROBE_GRACE_MS, failureThreshold: types_1.LENS_PROBE_FAILS, cooldownMs: types_1.LENS_PROBE_COOLDOWN_MS }, types_1.LENS_PROBE_ENABLED);
+    return { spawnManagedChild, bootSingletonsAndApps, hostWorkspaceDashboard, hostWorkspaceApps, probeLensFrontends, reapAll };
 }

package/executors/gateway/runtime/lifecycle.d.ts

@@ -116,7 +116,13 @@ export interface ServiceLayer {
     spawnService(svc: ServiceCtl): void;
     ensureUp(svc: ServiceCtl): Promise<boolean>;
     scaleUp(svc: ServiceCtl): void;
-    killSpawned(svc: ServiceCtl, why: string): void;
+    killSpawned(svc: ServiceCtl, why: string, opts?: {
+        announce?: boolean;
+    }): void;
+    /** The RECOVERY edge: record + announce that this service is serving again.
+     *  Idempotent (a no-op once `state === 'up'`), so the hot path can call it per
+     *  request. Returns true only on the transition. See the implementation. */
+    markUp(svc: ServiceCtl, how: 'adopted' | 'observed'): boolean;
     /** Start the idle sweeper; returns the interval (already `.unref()`'d). */
     startSweeper(): NodeJS.Timeout;
 }

package/executors/gateway/runtime/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/lifecycle.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/lifecycle.ts"],"names":[],"mappings":"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"}

package/executors/gateway/runtime/lifecycle.js

@@ -452,7 +452,7 @@ function createServiceLayer(rt, obs) {
                     setTimeout(() => {
                         if (rt.stopped() || !svc.lockBlockedAt)
                             return;
-                        killSpawned(svc, 'parked on a foreign nx task lock — recycling');
+                        killSpawned(svc, 'parked on a foreign nx task lock — recycling', { announce: false }); // a recycle: `nx-lock-break` above is the report
                         reapForeignRunners(svc, target);
                         setTimeout(() => {
                             if (!rt.stopped() && !svc.proc && svc.state === 'down')
@@ -498,12 +498,34 @@ function createServiceLayer(rt, obs) {
         });
         svc.proc = proc;
     };
+    /**
+     * The RECOVERY edge — the counterpart to `service-down`/`service-recycle`/`pod-recycle`.
+     *
+     * The gateway used to announce a service going UP from exactly two places, both inside
+     * `ensureUp`: the adopt fast-path and the cold-start wait loop. But the proxy only calls
+     * `ensureUp` when `pickSock` came back EMPTY — so a service that self-healed on its own (the
+     * exit auto-heal respawn, a recycled pod re-binding, an externally-started devserver) was never
+     * announced. Its `svc.state` stayed `'starting'` and the lens fold behind `process://cluster`
+     * latched on the last DEGRADATION forever: `agent://current-status` reported `failing` while the
+     * app served every request (foodguard 2026-07-31 — four services `starting`, `up: []`, 20×200,
+     * 0×502).
+     *
+     * So the transition lives here, callable from every place that observes a live pod, and the
+     * evidence is the SAME socket scan the wedge detector uses (`live = scanNow(pool) > 0`) — the
+     * detector that clears `wedgedSince` must also be the one that records `up`, or the two disagree.
+     * Idempotent, so the per-request call costs one property compare.
+     */
+    const markUp = (svc, how) => {
+        if (svc.state === 'up')
+            return false;
+        svc.state = 'up';
+        const pods = svc.pool.socks.length;
+        emitSvc(svc, 'info', `service up: ${svc.project} (${pods} pods, ${how})`, `cluster-service:${svc.project}`, { kind: 'service-up', project: svc.project, pods, adopted: how === 'adopted' });
+        return true;
+    };
     const ensureUp = async (svc) => {
         if (scanNow(svc.pool) > 0) {
-            if (svc.state !== 'up') {
-                emitSvc(svc, 'info', `service up: ${svc.project} (${svc.pool.socks.length} pods, adopted)`, `cluster-service:${svc.project}`, { kind: 'service-up', project: svc.project, pods: svc.pool.socks.length, adopted: true });
-            }
-            svc.state = 'up';
+            markUp(svc, 'adopted');
             return true;
         }
         if (rt.stopped())
@@ -549,11 +571,21 @@ function createServiceLayer(rt, obs) {
         emitSvc(svc, 'info', `autoscale: ${svc.project} ${cur} → ${cur + 1} pods`, `cluster-service:${svc.project}`, { kind: 'autoscale', project: svc.project, from: cur, to: cur + 1, inflight: svc.inflight });
     };
     // Idle sweeper: kill gateway-spawned lazy services after idleKillSec.
-    const killSpawned = (svc, why) => {
+    //
+    // `announce: false` for a caller that is TEARING THE TREE DOWN AS PART OF A RECYCLE. This function
+    // is the shared teardown for two different intents — "park this service, it's idle" and "kill this
+    // service, it's broken" — and the `idle-kill` event only describes the first. A recycle caller has
+    // ALREADY announced the real reason (`service-recycle` / `pod-recycle` / `service-crash-loop`), and
+    // an `idle-kill` on top would OVERWRITE that fault in the lens fold with a benign `idle` — the
+    // crash-loop and wedge reports would vanish milliseconds after they were raised. It also read wrong
+    // in the log ("idle kill: auth (wedged: 0 live pods — recycling)").
+    const killSpawned = (svc, why, opts) => {
         if (!svc.proc)
             return;
         console.log(`[gateway] ${svc.project} ${why} — scaling to zero.`);
-        emitSvc(svc, 'info', `idle kill: ${svc.project} (${why})`, `cluster-service:${svc.project}`, { kind: 'idle-kill', project: svc.project, why });
+        if (opts?.announce !== false) {
+            emitSvc(svc, 'info', `idle kill: ${svc.project} (${why})`, `cluster-service:${svc.project}`, { kind: 'idle-kill', project: svc.project, why });
+        }
         const dying = svc.proc;
         // Detach the corpse's handlers BEFORE killing: a dying webpack/nx flushes
         // buffered stdout/stderr as it exits, and those `sniff` callbacks would
@@ -623,13 +655,13 @@ function createServiceLayer(rt, obs) {
         svc.restarts = (svc.restarts ?? []).filter((t) => now - t < types_1.SERVICE_RESTART_WINDOW_MS);
         if (svc.restarts.length >= types_1.SERVICE_MAX_RESTARTS) {
             emitSvc(svc, 'error', `service crash-looping: ${svc.project} — wedged ${types_1.SERVICE_MAX_RESTARTS}+×/min, not auto-recycling (the next request retries)`, `cluster-service:${svc.project}`, { kind: 'service-crash-loop', project: svc.project });
-            killSpawned(svc, 'wedged (crash-loop cap) — leaving down for the next request'); // svc.proc cleared → scale-from-zero can retry
+            killSpawned(svc, 'wedged (crash-loop cap) — leaving down for the next request', { announce: false }); // svc.proc cleared → scale-from-zero can retry
             return;
         }
         svc.restarts.push(now);
         console.log(`[gateway] self-heal: recycling WEDGED ${svc.project} (live parent, 0 live pods; ${svc.restarts.length}/${types_1.SERVICE_MAX_RESTARTS})`);
         emitSvc(svc, 'warning', `self-heal: recycling wedged ${svc.project} (0 live pods)`, `cluster-service:${svc.project}`, { kind: 'service-recycle', project: svc.project, attempt: svc.restarts.length });
-        killSpawned(svc, 'wedged: 0 live pods — recycling'); // kills the tree + unlinks stale socks (+1200ms) + svc.proc=undefined + state='down'
+        killSpawned(svc, 'wedged: 0 live pods — recycling', { announce: false }); // kills the tree + unlinks stale socks (+1200ms) + svc.proc=undefined + state='down'
         // A wedge is unexpected — bring it straight back (don't wait for a request). Respawn AFTER killSpawned's
         // deferred sock cleanup (1200ms) so the fresh child binds a clean socket path.
         setTimeout(() => {
@@ -748,7 +780,7 @@ function createServiceLayer(rt, obs) {
         console.log(`[gateway] zombie recycle: ${svc.project} (${reason}) — stale fs view; fresh pod incoming`);
         emitSvc(svc, 'warning', `zombie recycle: ${svc.project} (${reason})`, `cluster-service:${svc.project}`, { kind: 'pod-recycle', project: svc.project, reason });
         const eager = !!svc.decl.eager;
-        killSpawned(svc, `${reason} — recycling stale pod`); // clears proc, state='down', unlinks socks (+1200ms)
+        killSpawned(svc, `${reason} — recycling stale pod`, { announce: false }); // clears proc, state='down', unlinks socks (+1200ms)
         if (eager)
             setTimeout(() => { if (!rt.stopped() && !svc.proc && svc.state === 'down')
                 spawnService(svc); }, 1500).unref?.();
@@ -776,6 +808,13 @@ function createServiceLayer(rt, obs) {
                 const live = scanNow(svc.pool) > 0;
                 if (live || coldStarting) {
                     svc.wedgedSince = undefined;
+                    // RECOVERY EDGE. `live` is the exact evidence that just cleared `wedgedSince`, so it must
+                    // also record the service as UP — otherwise the gateway silently forgives a wedge while
+                    // the lens fold stays latched on it. This is the path that heals a service which came
+                    // back WITHOUT a request (the exit auto-heal respawn), since nothing else calls `ensureUp`
+                    // once a pod socket exists. Idempotent: after the first tick it is a property compare.
+                    if (live)
+                        markUp(svc, 'observed');
                     // ZOMBIE recycle: a live pod (live parent + live socket, answers requests) whose fs view went
                     // stale — neither exit-respawn nor wedge-recycle sees it. Idle-gated in podRecycleReason so a busy
                     // pod is never interrupted.
@@ -799,5 +838,5 @@ function createServiceLayer(rt, obs) {
         sweeper.unref();
         return sweeper;
     };
-    return { scanNow, spawnService, ensureUp, scaleUp, killSpawned, startSweeper };
+    return { scanNow, spawnService, ensureUp, scaleUp, killSpawned, markUp, startSweeper };
 }

package/executors/gateway/runtime/proxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/proxy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,cAAc,EAAW,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA8BhD,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IACxH,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IACnI,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAC/H;kGAC8F;IAC9F,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAC7H,KAAK,CAAC,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,OAAO,YAAY,EAAE,KAAK,CAAC;IACzE,aAAa,IAAI,IAAI,CAAC;IACtB,UAAU,IAAI,IAAI,CAAC;CACpB;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,GAAG,UAAU,CAuYtG"}
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../../../../libs/cluster/src/executors/gateway/runtime/proxy.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAC;AAG3C,OAAO,KAAK,EAAE,cAAc,EAAW,KAAK,EAAE,MAAM,SAAS,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA8BhD,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IACxH,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,GAAG,IAAI,CAAC;IACnI,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAC/H;kGAC8F;IAC9F,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,aAAa,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAC7H,KAAK,CAAC,IAAI,IAAI,CAAC;CAChB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,eAAe,EAAE,GAAG,EAAE,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAAC,KAAK,GAAG,OAAO,YAAY,EAAE,KAAK,CAAC;IACzE,aAAa,IAAI,IAAI,CAAC;IACtB,UAAU,IAAI,IAAI,CAAC;CACpB;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,GAAG,UAAU,CA8YtG"}

package/executors/gateway/runtime/proxy.js

@@ -256,6 +256,12 @@ function createProxy(rt, obs, svcLayer) {
                 if (await svcLayer.ensureUp(ctl))
                     sock = (0, discovery_1.pickSock)(route.pool, rt.scanTtlMs);
             }
+            // A ROUTABLE pod is the recovery edge (see `markUp` in lifecycle.ts): `ensureUp` — which used
+            // to be the only announcer of a service going up — is SKIPPED whenever `pickSock` already
+            // found a socket, so a service that self-healed between requests was never announced and the
+            // lens fold latched on its last degradation. Idempotent ⇒ a property compare per request.
+            if (ctl && sock)
+                svcLayer.markUp(ctl, 'observed');
             if (ctl)
                 svcLayer.scaleUp(ctl);
             if (!sock) {
@@ -358,6 +364,9 @@ function createProxy(rt, obs, svcLayer) {
                 if (await svcLayer.ensureUp(ctl))
                     sock = (0, discovery_1.pickSock)(route.pool, rt.scanTtlMs);
             }
+            // The recovery edge — see the twin comment in `forwardNative` above.
+            if (ctl && sock)
+                svcLayer.markUp(ctl, 'observed');
             if (ctl)
                 svcLayer.scaleUp(ctl);
             if (!sock) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lensmcp/cluster",
-  "version": "1.18.0",
+  "version": "1.18.1",
   "description": "Run your Nx workspace as a local production cluster: pods on unix sockets with true HMR, one https gateway with per-project domains, scale-from-zero, autoscale, idle-kill, local-CA TLS — observed by the LensMCP lens.",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -65,8 +65,8 @@
     }
   },
   "dependencies": {
-    "@lensmcp/node-instrumentation": "1.18.0",
-    "@lensmcp/nx-plugin": "1.18.0",
+    "@lensmcp/node-instrumentation": "1.18.1",
+    "@lensmcp/nx-plugin": "1.18.1",
     "@typescript/native-preview": "^7.0.0-dev.20260707.2",
     "fork-ts-checker-webpack-plugin": "^9.0.0",
     "glob": "^11.0.0",