@saluzi/saluzi-edu 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saluzi/saluzi-edu",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "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__/routes.test.ts

@@ -399,6 +399,91 @@ describe('V1 Session Routes', () => {
       body: JSON.stringify({ events: [{ type: 'init', data: 'starting' }] }),
     })
     expect(sessRes.status).toBe(200)
+    const { id } = await sessRes.json()
+    // Legacy raw shape — published verbatim as before (type from the event,
+    // direction outbound).
+    const events = getEventBus(id).getEventsSince(0)
+    expect(events).toHaveLength(1)
+    expect(events[0]?.type).toBe('init')
+    expect(events[0]?.direction).toBe('outbound')
+  })
+
+  test('POST /v1/sessions with CCR-wrapped system/init seed — publishes a typed system event the Web UI scan can find', async () => {
+    // `slz rcs one`'s headless worker seeds its pre-created session with a
+    // system/init so the Web UI has the worker's command/skill tables and
+    // capabilities before the first message spawns a --print child. The
+    // create route must unwrap { type: 'event', data: SDKMessage } and run
+    // the inner message through the standard ingest normalization —
+    // publishing the raw wrapper would yield an opaque 'event'-typed entry
+    // no consumer (loadHistory worker-info scan, live SSE handler) matches.
+    const sessRes = await app.request('/v1/sessions', {
+      method: 'POST',
+      headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        events: [
+          {
+            type: 'event',
+            data: {
+              type: 'system',
+              subtype: 'init',
+              uuid: 'seed-init-uuid',
+              slash_commands: ['compact'],
+              slash_command_details: [
+                {
+                  name: 'compact',
+                  description: 'Shrink context',
+                  type: 'local',
+                },
+              ],
+              skills: ['code-review'],
+              skill_details: [
+                {
+                  name: 'code-review',
+                  description: 'Review code',
+                  type: 'prompt',
+                },
+              ],
+              remote_capabilities: {
+                file_search: true,
+                clear: true,
+                set_max_thinking_tokens: true,
+                get_context_usage: true,
+                stop_task: true,
+                set_model: true,
+                set_permission_mode: true,
+                interrupt: true,
+                end_session: true,
+                mcp_management: true,
+                remote_settings: true,
+                rewind: true,
+                set_effort: true,
+                side_question: true,
+              },
+            },
+          },
+        ],
+      }),
+    })
+    expect(sessRes.status).toBe(200)
+    const { id } = await sessRes.json()
+
+    const events = getEventBus(id).getEventsSince(0)
+    expect(events).toHaveLength(1)
+    expect(events[0]?.type).toBe('system')
+    expect(events[0]?.direction).toBe('inbound')
+    const payload = events[0]?.payload as Record<string, unknown>
+    expect(payload.subtype).toBe('init')
+    expect(payload.slash_command_details).toEqual([
+      { name: 'compact', description: 'Shrink context', type: 'local' },
+    ])
+    expect(payload.skill_details).toEqual([
+      { name: 'code-review', description: 'Review code', type: 'prompt' },
+    ])
+    expect(
+      (payload.remote_capabilities as Record<string, unknown>).set_model,
+    ).toBe(true)
+    // raw keeps the full SDK message for the adapter's payload.raw fallback.
+    expect((payload.raw as Record<string, unknown>).subtype).toBe('init')
   })
 })
 

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/v1/sessions.ts

@@ -11,6 +11,7 @@ import {
 } from '../../services/session'
 import { createWorkItem } from '../../services/work-dispatch'
 import { publishSessionEvent } from '../../services/transport'
+import { ingestBridgeMessage } from '../../transport/ws-handler'
 import { loadPersistedEvents } from '../../services/event-persistence'
 import { getEventBus } from '../../transport/event-bus'
 import { touchEnvironmentActivity } from '../../services/environment'
@@ -225,7 +226,26 @@ app.post('/', acceptCliHeaders, apiKeyAuth, async c => {
   // Publish initial events if provided
   if (body.events && Array.isArray(body.events)) {
     for (const evt of body.events) {
-      publishSessionEvent(session.id, evt.type || 'init', evt, 'outbound')
+      // CCR wire format { type: 'event', data: SDKMessage } — unwrap and run
+      // the inner SDK message through the standard ingest path (event-type
+      // derivation + payload normalization, e.g. system/init's
+      // slash_command_details / remote_capabilities preservation). Publishing
+      // the raw wrapper as-is yields an opaque 'event'-typed entry no
+      // consumer recognizes.
+      const data =
+        evt &&
+        typeof evt === 'object' &&
+        evt.type === 'event' &&
+        evt.data &&
+        typeof evt.data === 'object' &&
+        typeof evt.data.type === 'string'
+          ? evt.data
+          : null
+      if (data) {
+        ingestBridgeMessage(session.id, data)
+      } else {
+        publishSessionEvent(session.id, evt.type || 'init', evt, 'outbound')
+      }
     }
   }
 

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,