@saluzi/saluzi-edu 0.4.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saluzi/saluzi-edu",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Saluzi CLI - interactive AI coding assistant in the terminal",
   "license": "MIT",
   "type": "module",

package/packages/remote-control-server/src/__tests__/attach-wait.test.ts

@@ -158,7 +158,7 @@ describe('Session Attach wait mode', () => {
     expect(res.status).toBe(403)
     const body = (await res.json()) as { error: { type: string } }
     expect(body.error.type).toBe('forbidden')
-    // updatePollTime runs only AFTER the gate — a 403 must not keep a dead
+    // touchEnvironmentActivity runs only AFTER the gate — a 403 must not keep a dead
     // env looking alive.
     expect(storeGetEnvironment(env.id)?.lastPollAt?.getTime()).toBe(
       stale.getTime(),

package/packages/remote-control-server/src/__tests__/services.test.ts

@@ -4,7 +4,11 @@ import { mockConfigModule } from './helpers/mock-config'
 // Mock config before importing modules
 mock.module('../config', () => mockConfigModule())
 
-import { storeReset, storeCreateEnvironment } from '../store'
+import {
+  storeReset,
+  storeCreateEnvironment,
+  storeUpdateEnvironment,
+} from '../store'
 import {
   createSession,
   createCodeSession,
@@ -22,7 +26,7 @@ import {
   registerEnvironment,
   deregisterEnvironment,
   getEnvironment,
-  updatePollTime,
+  touchEnvironmentActivity,
   listActiveEnvironments,
   listActiveEnvironmentsResponse,
   listActiveEnvironmentsByUsername,
@@ -230,14 +234,38 @@ describe('Environment Service', () => {
     })
   })
 
-  describe('updatePollTime', () => {
-    test('updates lastPollAt', () => {
+  describe('touchEnvironmentActivity', () => {
+    test('updates lastPollAt for an active env', () => {
       const result = registerEnvironment({})
-      const before = getEnvironment(result.environment_id)?.lastPollAt
-      // Small delay to ensure time difference
-      updatePollTime(result.environment_id)
+      const stale = new Date(Date.now() - 60_000)
+      storeUpdateEnvironment(result.environment_id, { lastPollAt: stale })
+      touchEnvironmentActivity(result.environment_id)
       const after = getEnvironment(result.environment_id)?.lastPollAt
-      expect(after!.getTime()).toBeGreaterThanOrEqual(before!.getTime())
+      expect(after!.getTime()).toBeGreaterThan(stale.getTime())
+    })
+
+    test('reactivates a disconnected env', () => {
+      const result = registerEnvironment({})
+      storeUpdateEnvironment(result.environment_id, { status: 'disconnected' })
+      touchEnvironmentActivity(result.environment_id)
+      const env = getEnvironment(result.environment_id)
+      expect(env?.status).toBe('active')
+      expect(env?.lastPollAt).toBeTruthy()
+    })
+
+    test('leaves a deregistered env untouched (terminal state)', () => {
+      const result = registerEnvironment({})
+      const stale = new Date(Date.now() - 60_000)
+      storeUpdateEnvironment(result.environment_id, { lastPollAt: stale })
+      deregisterEnvironment(result.environment_id)
+      touchEnvironmentActivity(result.environment_id)
+      const env = getEnvironment(result.environment_id)
+      expect(env?.status).toBe('deregistered')
+      expect(env?.lastPollAt?.getTime()).toBe(stale.getTime())
+    })
+
+    test('no-ops for a non-existent env', () => {
+      expect(() => touchEnvironmentActivity('env_no')).not.toThrow()
     })
   })
 

package/packages/remote-control-server/src/__tests__/work-dispatch.test.ts

@@ -10,6 +10,8 @@ import {
   storeCreateSession,
   storeGetWorkItem,
   storeGetPendingWorkItem,
+  storeGetEnvironment,
+  storeUpdateEnvironment,
 } from '../store'
 import {
   createWorkItem,
@@ -129,6 +131,42 @@ describe('Work Dispatch', () => {
       const result = heartbeatWork('work_no')
       expect(result.state).toBe('acked')
     })
+
+    test('refreshes env liveness — at-capacity workers poll for work only every 10 min', async () => {
+      const workId = await createWorkItem(envId, sessionId)
+      ackWork(workId)
+      const stale = new Date(Date.now() - 10 * 60 * 1000)
+      storeUpdateEnvironment(envId, { lastPollAt: stale })
+      heartbeatWork(workId)
+      const lastPollAt = storeGetEnvironment(envId)?.lastPollAt
+      expect(lastPollAt!.getTime()).toBeGreaterThan(stale.getTime())
+    })
+
+    test('reactivates a monitor-flipped (disconnected) env', async () => {
+      const workId = await createWorkItem(envId, sessionId)
+      ackWork(workId)
+      storeUpdateEnvironment(envId, { status: 'disconnected' })
+      heartbeatWork(workId)
+      const env = storeGetEnvironment(envId)
+      expect(env?.status).toBe('active')
+      expect(env?.lastPollAt).toBeTruthy()
+    })
+
+    test('does not refresh env liveness for a stopped (completed) work item', async () => {
+      // 410 path: a zombie heartbeat after a Web-UI session deletion must
+      // not resurrect the env or refresh its liveness.
+      const workId = await createWorkItem(envId, sessionId)
+      stopWork(workId)
+      const stale = new Date(Date.now() - 10 * 60 * 1000)
+      storeUpdateEnvironment(envId, {
+        status: 'disconnected',
+        lastPollAt: stale,
+      })
+      heartbeatWork(workId)
+      const env = storeGetEnvironment(envId)
+      expect(env?.status).toBe('disconnected')
+      expect(env?.lastPollAt?.getTime()).toBe(stale.getTime())
+    })
   })
 
   describe('reconnectWorkForEnvironment', () => {

package/packages/remote-control-server/src/routes/v2/worker.ts

@@ -17,7 +17,7 @@ import {
 } from '../../auth/middleware'
 import { getEventBus } from '../../transport/event-bus'
 import { storeGetSessionWorker, storeUpsertSessionWorker } from '../../store'
-import { updatePollTime } from '../../services/environment'
+import { touchEnvironmentActivity } from '../../services/environment'
 
 const app = new Hono()
 
@@ -120,11 +120,12 @@ app.post(
     touchSession(sessionId)
     // V2 path doesn't go through /v1/environments/:id/work/poll, so
     // disconnect-monitor never sees lastPollAt updates. Refresh the parent
-    // environment's poll time here — otherwise the env gets marked
+    // environment's liveness here — otherwise the env gets marked
     // disconnected and disappears from /web/environments even though the
-    // worker is actively heartbeating.
+    // worker is actively heartbeating. touchEnvironmentActivity (not a raw
+    // lastPollAt write) so a monitor-flipped env is also reactivated.
     if (session.environment_id) {
-      updatePollTime(session.environment_id)
+      touchEnvironmentActivity(session.environment_id)
     }
     return c.json({ status: 'ok', last_heartbeat_at: now.toISOString() }, 200)
   },
@@ -142,9 +143,9 @@ app.post('/:id/worker/register', acceptCliHeaders, apiKeyAuth, async c => {
   }
 
   const epoch = incrementEpoch(sessionId)
-  // Same lastPollAt rationale as heartbeat — V2 path skips v1 poll.
+  // Same liveness rationale as heartbeat — V2 path skips v1 poll.
   if (session.environment_id) {
-    updatePollTime(session.environment_id)
+    touchEnvironmentActivity(session.environment_id)
   }
   return c.json({ worker_epoch: epoch }, 200)
 })

package/packages/remote-control-server/src/services/disconnect-monitor.ts

@@ -28,8 +28,11 @@ export function runDisconnectMonitorSweep(now = Date.now()) {
       continue
     }
     if (env.lastPollAt && now - env.lastPollAt.getTime() > timeoutMs) {
+      // lastPollAt is written by touchEnvironmentActivity — any worker
+      // traffic counts (poll, assignment, session-create, work heartbeat),
+      // not just literal polls.
       log(
-        `[RCS] Environment ${env.id} timed out (no poll for ${Math.round((now - env.lastPollAt.getTime()) / 1000)}s)`,
+        `[RCS] Environment ${env.id} timed out (no activity for ${Math.round((now - env.lastPollAt.getTime()) / 1000)}s)`,
       )
       storeUpdateEnvironment(env.id, { status: 'disconnected' })
       // 会话不自动归档：perpetual worker 重启时复用 envId 重新激活 env，

package/packages/remote-control-server/src/services/environment.ts

@@ -273,16 +273,13 @@ export function getEnvironment(envId: string) {
   return storeGetEnvironment(envId)
 }
 
-export function updatePollTime(envId: string) {
-  storeUpdateEnvironment(envId, { lastPollAt: new Date() })
-}
-
 /**
  * Worker-traffic liveness signal: refresh lastPollAt and, when the disconnect
  * monitor had flipped the env to 'disconnected', reactivate it.
  *
  * The flip is based on a stale heartbeat — a worker actively hitting the env
- * (work poll, assignment poll, session-creation retry during claim wait)
+ * (work poll, assignment poll, session-creation retry during claim wait,
+ * work-item heartbeat while at capacity, v2 worker register/heartbeat)
  * proves it is alive. Without reactivation the CLI polls a zombie env
  * forever: the work-poll route never 404s, so the client's env-lost recovery
  * never fires, and any session created on the flipped env gets no work item

package/packages/remote-control-server/src/services/work-dispatch.ts

@@ -11,6 +11,7 @@ import {
 import { config } from '../config'
 import { getBaseUrl } from '../config'
 import { touchSession } from './session'
+import { touchEnvironmentActivity } from './environment'
 import type { WorkResponse } from '../types/api'
 
 /** Encode work secret as base64 JSON (no JWT — just API key as token) */
@@ -140,6 +141,19 @@ export function heartbeatWork(workId: string): {
   if (item?.sessionId) {
     touchSession(item.sessionId)
   }
+  // Worker liveness for the parent env: an at-capacity worker (e.g. the
+  // `slz rcs one` repl worker, capacity=1) stops polling for work for the
+  // whole duration of a session (at-capacity poll interval is 10 min) and
+  // sends only this heartbeat (~60s). Without counting it as env activity,
+  // the disconnect monitor flips every busy env to 'disconnected' once
+  // RCS_DISCONNECT_TIMEOUT (default 300s) passes since the dispatch poll.
+  // Use the item's own environmentId — the route's :id param is not
+  // validated against it. Completed (stopped → 410) items must NOT refresh
+  // liveness: a zombie heartbeat after a Web-UI session deletion must not
+  // resurrect the env.
+  if (item && item.state !== 'completed') {
+    touchEnvironmentActivity(item.environmentId)
+  }
   const now = new Date()
   return {
     lease_extended: true,