@saluzi/saluzi-edu 0.2.65 → 0.2.67

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

@@ -181,6 +181,60 @@ describe('Session Attach wait mode', () => {
     expect(await res.json()).toEqual({ assigned: false })
   })
 
+  test('assignment: disconnected env + authorized caller → reactivated, not 404', async () => {
+    // A wait-mode worker whose env the disconnect monitor flipped (laptop
+    // sleep during the 24h wait, pre-fix claim-wait, etc.) must recover on
+    // its next poll instead of dead-waiting on swallowed 404s — the CLI
+    // ignores assignment errors until its deadline.
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    storeUpdateEnvironment(env.id, { status: 'disconnected' })
+
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ assigned: false })
+    expect(storeGetEnvironment(env.id)?.status).toBe('active')
+  })
+
+  test('assignment: disconnected env + stranger → 403, env NOT reactivated', async () => {
+    // Same invariant as the heartbeat test above: a 403 must not resurrect
+    // or keep alive an env the caller has no business touching.
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    storeUpdateEnvironment(env.id, { status: 'disconnected' })
+    const stranger = createUser(db)
+
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { Authorization: rctAuth(stranger.id) },
+    })
+    expect(res.status).toBe(403)
+    expect(storeGetEnvironment(env.id)?.status).toBe('disconnected')
+  })
+
+  test('assignment: deregistered env → 404 (terminal)', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    storeUpdateEnvironment(env.id, { status: 'deregistered' })
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(404)
+  })
+
   test('assignment: session bound to the env (web attach) → assigned with session id', async () => {
     const env = storeCreateEnvironment({
       secret: 'test-api-key',

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

@@ -313,6 +313,43 @@ describe('POST /v1/sessions/:id/attach', () => {
     expect(body.error.type).toBe('environment_unowned')
   })
 
+  test('bare admin API key attaches to an unowned env (documented worker setup)', async () => {
+    // Self-hosted workers connect with SALUZI_BRIDGE_OAUTH_TOKEN=<RCS_API_KEYS>
+    // and no SALUZI_BRIDGE_USERNAME — the env they register is unowned until
+    // claimed, and the direct-attach path never prints a claim URL. A hard
+    // 409 here made `/rc --attach <id>` fail out of the box. Bare admin keys
+    // are trusted credentials (ensureAttachAccess already audited their
+    // session-manage bypass) — the bind is allowed.
+    const owner = createUser(db)
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'cli-worker',
+    })
+    const session = createSession({
+      environment_id: null,
+      title: 'Web session',
+      source: 'web',
+    })
+    storeBindSession(session.id, owner.id, 'user')
+
+    const res = await app.request(`/v1/sessions/${session.id}/attach`, {
+      method: 'POST',
+      headers: { ...JSON_HDRS, ...ADMIN_KEY },
+      body: JSON.stringify({ environment_id: env.id }),
+    })
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as {
+      status: string
+      session_id: string
+      work_item_id: string
+      rebind: boolean
+    }
+    expect(body.status).toBe('attached')
+    expect(body.session_id).toBe(session.id)
+    expect(body.work_item_id).toMatch(/^work_/)
+    expect(body.rebind).toBe(true)
+  })
+
   test('archived session → 409 session_closed', async () => {
     const world = seedWorld(db)
     const { archiveSession } = await import('../services/session')

package/packages/remote-control-server/src/__tests__/helpers/mock-config.ts

@@ -15,6 +15,7 @@ export function createMockConfig(overrides?: Partial<Record<string, unknown>>) {
     webCorsOrigins: [],
     wsIdleTimeout: 30,
     wsKeepaliveInterval: 20,
+    artifactsPublicAccess: true,
     ...overrides,
   }
 }

package/packages/remote-control-server/src/__tests__/low-priority-fixes.test.ts

@@ -10,8 +10,11 @@ import { Hono } from 'hono'
 import {
   storeReset,
   storeCreateSession,
+  storeCreateEnvironment,
   storeBindSession,
   storeListSessionsByOwnerUuid,
+  storeListSessionsByEnvironment,
+  storeGetActiveWorkItemBySession,
 } from '../store'
 import { initDatabase, resetDbSingleton } from '../db/sqlite'
 import { issueToken } from '../auth/token'
@@ -176,3 +179,95 @@ describe('M2: resolveOwnedWebSessionId removes redundant fallback', () => {
     expect(source).not.toMatch(/import\s*\{[^}]*storeIsSessionOwner[^}]*\}/)
   })
 })
+
+// =============================================================================
+// worker_at_capacity pre-validation: the repl-worker capacity check must run
+// BEFORE createSession. It used to run after, where the just-created session
+// (already bound to body.environment_id) always tripped it — every web session
+// creation on a repl worker env 409'd AND left a stray bound-but-never-
+// dispatched session behind on each retry.
+// =============================================================================
+describe('worker_at_capacity pre-validation (repl workers)', () => {
+  let app: Hono
+
+  beforeEach(() => {
+    freshDb()
+    storeReset()
+    app = createApp()
+  })
+
+  test('idle repl worker env → 200, session created AND work item dispatched', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'cli-worker',
+      workerType: 'repl',
+    })
+    const res = await app.request('/web/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: userAuth('webuser'),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ title: 'On Worker', environment_id: env.id }),
+    })
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as { id: string; environment_id: string }
+    expect(body.environment_id).toBe(env.id)
+    // Pre-fix the 409 returned before createWorkItem — the CLI would poll a
+    // session that never received work.
+    const work = storeGetActiveWorkItemBySession(body.id)
+    expect(work).not.toBeNull()
+    expect(work?.environmentId).toBe(env.id)
+  })
+
+  test('repl env with an open session → 409 and NO stray session left behind', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'cli-worker',
+      workerType: 'repl',
+    })
+    storeCreateSession({
+      environmentId: env.id,
+      title: 'Existing',
+      source: 'web',
+    })
+    const before = storeListSessionsByEnvironment(env.id).length
+
+    const res = await app.request('/web/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: userAuth('webuser'),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ title: 'Overflow', environment_id: env.id }),
+    })
+    expect(res.status).toBe(409)
+    const body = (await res.json()) as { error: { type: string } }
+    expect(body.error.type).toBe('worker_at_capacity')
+    // Pre-fix the session record was created (and bound) before the 409.
+    expect(storeListSessionsByEnvironment(env.id).length).toBe(before)
+  })
+
+  test('non-repl (spawn) env skips the capacity check', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'spawn-worker',
+      workerType: 'claude_code',
+      maxSessions: 4,
+    })
+    storeCreateSession({
+      environmentId: env.id,
+      title: 'Existing',
+      source: 'web',
+    })
+    const res = await app.request('/web/sessions', {
+      method: 'POST',
+      headers: {
+        Authorization: userAuth('webuser'),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ title: 'Second', environment_id: env.id }),
+    })
+    expect(res.status).toBe(200)
+  })
+})

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

@@ -10,6 +10,9 @@ import {
   storeCreateSession,
   storeCreateEnvironment,
   storeBindSession,
+  storeUpdateEnvironment,
+  storeGetEnvironment,
+  storeGetActiveWorkItemBySession,
 } from '../store'
 import {
   removeEventBus,
@@ -323,6 +326,72 @@ describe('V1 Session Routes', () => {
     expect(body.id).toMatch(/^session_/)
   })
 
+  test('POST /v1/sessions with environment_id refreshes env liveness (claim-wait retry loop)', async () => {
+    // An unowned env's claim-wait loop retries POST /v1/sessions every 5s
+    // (409 environment_unowned) for up to 24h — that retry IS the worker's
+    // only traffic. Without touching lastPollAt here the disconnect monitor
+    // flips the env after RCS_DISCONNECT_TIMEOUT, and when the claim finally
+    // lands the work item dispatch rejects the non-active env: a session
+    // that exists yet never receives work (the CLI polls 204s forever).
+    ensureUser('testuser')
+    const envRes = await app.request('/v1/environments/bridge', {
+      method: 'POST',
+      headers: {
+        ...AUTH_HEADERS,
+        'Content-Type': 'application/json',
+        'X-User-Id': 'testuser',
+      },
+      body: JSON.stringify({ machine_name: 'test' }),
+    })
+    const { environment_id } = await envRes.json()
+    // Age the heartbeat past the disconnect timeout, then simulate one
+    // claim-wait retry.
+    const stale = new Date(Date.now() - 10 * 60 * 1000)
+    storeUpdateEnvironment(environment_id, { lastPollAt: stale })
+    const before = storeGetEnvironment(environment_id)?.lastPollAt?.getTime()
+
+    const sessRes = await app.request('/v1/sessions', {
+      method: 'POST',
+      headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ environment_id }),
+    })
+    expect(sessRes.status).toBe(200)
+    const after = storeGetEnvironment(environment_id)?.lastPollAt?.getTime()
+    expect(after).not.toBe(before)
+    expect(after ?? 0).toBeGreaterThan(stale.getTime())
+  })
+
+  test('POST /v1/sessions reactivates a monitor-flipped env so the work item is created', async () => {
+    // Recovery path for envs already flipped to 'disconnected' (CLI waited
+    // out the timeout before these fixes, laptop sleep, etc.): the retry
+    // reactivates the env, so the session gets its work item instead of
+    // becoming a zombie the CLI polls forever.
+    ensureUser('testuser')
+    const envRes = await app.request('/v1/environments/bridge', {
+      method: 'POST',
+      headers: {
+        ...AUTH_HEADERS,
+        'Content-Type': 'application/json',
+        'X-User-Id': 'testuser',
+      },
+      body: JSON.stringify({ machine_name: 'test' }),
+    })
+    const { environment_id } = await envRes.json()
+    storeUpdateEnvironment(environment_id, { status: 'disconnected' })
+
+    const sessRes = await app.request('/v1/sessions', {
+      method: 'POST',
+      headers: { ...AUTH_HEADERS, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ environment_id }),
+    })
+    expect(sessRes.status).toBe(200)
+    const body = await sessRes.json()
+    expect(storeGetEnvironment(environment_id)?.status).toBe('active')
+    const work = storeGetActiveWorkItemBySession(body.id)
+    expect(work).not.toBeNull()
+    expect(work?.environmentId).toBe(environment_id)
+  })
+
   test('POST /v1/sessions with events — publishes initial events', async () => {
     const sessRes = await app.request('/v1/sessions', {
       method: 'POST',

package/packages/remote-control-server/src/config.ts

@@ -34,6 +34,12 @@ export const config = {
     process.env.RCS_WS_CLIENT_INACTIVITY_TIMEOUT || '300',
     10,
   ),
+  /** Whether artifact content (GET /v1/artifacts/:id/content) is served
+   *  without authentication. Default true — the unguessable artifact id is
+   *  the secret, same trust model as the upstream cloud-artifacts service.
+   *  Set RCS_ARTIFACTS_PUBLIC_ACCESS=false to gate reads behind web session
+   *  or worker credentials. */
+  artifactsPublicAccess: process.env.RCS_ARTIFACTS_PUBLIC_ACCESS !== 'false',
 } as const
 
 export function getBaseUrl(): string {

package/packages/remote-control-server/src/db/rcs-schema.sql

@@ -119,6 +119,26 @@ CREATE TABLE IF NOT EXISTS session_events (
   created_at INTEGER NOT NULL
 );
 
+-- Artifacts — self-hosted HTML pages uploaded by the CLI `artifact` tool or
+-- created from the web UI gallery. `id` doubles as the unguessable share
+-- slug (URL-is-the-secret model, same as the upstream cloud-artifacts
+-- service). `team_id` is denormalized from session ownership at upload time
+-- so the team gallery can filter without joining session_owners.
+CREATE TABLE IF NOT EXISTS artifacts (
+  id TEXT PRIMARY KEY,
+  session_id TEXT,
+  team_id TEXT,
+  title TEXT,
+  content_type TEXT NOT NULL DEFAULT 'text/html',
+  content TEXT NOT NULL,
+  size INTEGER NOT NULL,
+  version INTEGER NOT NULL DEFAULT 1,
+  created_by TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  expires_at TEXT
+);
+
 -- Performance indexes
 CREATE INDEX IF NOT EXISTS idx_session_owners_owner ON session_owners(owner_type, owner_id);
 CREATE INDEX IF NOT EXISTS idx_session_owners_session ON session_owners(session_id);
@@ -134,3 +154,6 @@ CREATE INDEX IF NOT EXISTS idx_environments_team ON environments(team_id);
 CREATE INDEX IF NOT EXISTS idx_environments_owner_user ON environments(owner_user_id);
 CREATE INDEX IF NOT EXISTS idx_environments_claim_token ON environments(claim_token);
 CREATE INDEX IF NOT EXISTS idx_session_events_session ON session_events(session_id);
+CREATE INDEX IF NOT EXISTS idx_artifacts_session ON artifacts(session_id);
+CREATE INDEX IF NOT EXISTS idx_artifacts_team ON artifacts(team_id);
+CREATE INDEX IF NOT EXISTS idx_artifacts_expires ON artifacts(expires_at);

package/packages/remote-control-server/src/index.ts

@@ -12,6 +12,7 @@ import { webCorsOptions } from './auth/cors'
 import { websocket } from './transport/ws-shared'
 import { getDb } from './db/sqlite'
 import { reapExpiredSessions } from './auth/session'
+import { cleanupExpiredArtifacts } from './services/artifacts'
 
 console.log('[RCS] In-memory store ready (no SQLite)')
 
@@ -66,11 +67,19 @@ try {
   console.warn('[RCS] Failed to reap expired sessions:', err)
 }
 
+// Clean up expired artifacts (7/30-day TTLs) on the same hourly cadence
+try {
+  cleanupExpiredArtifacts()
+} catch (err) {
+  console.warn('[RCS] Failed to clean up expired artifacts:', err)
+}
+
 const reapInterval = setInterval(
   () => {
     try {
       const db = getDb()
       reapExpiredSessions(db)
+      cleanupExpiredArtifacts()
     } catch {
       // ignore — DB may not be available
     }

package/packages/remote-control-server/src/registerRoutes.ts

@@ -9,6 +9,7 @@ import { createSessionIngressApp } from './routes/v1/session-ingress'
 import { csrfCheck } from './auth/csrf'
 
 // Routes
+import v1Artifacts from './routes/v1/artifacts'
 import v1Environments from './routes/v1/environments'
 import v1EnvironmentsWork from './routes/v1/environments.work'
 import v1Sessions from './routes/v1/sessions'
@@ -16,6 +17,7 @@ import v2CodeSessions from './routes/v2/code-sessions'
 import v2Worker from './routes/v2/worker'
 import v2WorkerEventsStream from './routes/v2/worker-events-stream'
 import v2WorkerEvents from './routes/v2/worker-events'
+import webArtifacts from './routes/web/artifacts'
 import webAuth from './routes/web/auth'
 import webAuthRoutes from './routes/web/auth-routes'
 import webSessions from './routes/web/sessions'
@@ -58,6 +60,8 @@ export function registerRoutes(
   app.get('/code/:sessionId', ss({ root: webDir, path: 'index.html' }))
   // /code/s/:shareToken — share landing page (two-segment path, not matched by /code/:sessionId)
   app.get('/code/s/:shareToken', ss({ root: webDir, path: 'index.html' }))
+  // /code/a/:artifactId — artifact viewer page (two-segment path)
+  app.get('/code/a/:artifactId', ss({ root: webDir, path: 'index.html' }))
   // /code/claim/:claimToken — environment claim landing page
   app.get('/code/claim/:claimToken', ss({ root: webDir, path: 'index.html' }))
 
@@ -65,6 +69,9 @@ export function registerRoutes(
   app.route('/v1/environments', v1Environments)
   app.route('/v1/environments', v1EnvironmentsWork)
 
+  // v1 Artifacts — CLI worker upload + public content read
+  app.route('/v1', v1Artifacts)
+
   // v1 Session routes
   app.route('/v1/sessions', v1Sessions)
 
@@ -84,6 +91,7 @@ export function registerRoutes(
   app.use('/web/*', csrfCheck)
   app.route('/web', webAuth)
   app.route('/web/auth', webAuthRoutes)
+  app.route('/web', webArtifacts)
   app.route('/web', webShares)
   app.route('/web', webTeams)
   app.route('/web', webSessions)

package/packages/remote-control-server/src/routes/v1/artifacts.ts

@@ -0,0 +1,179 @@
+import { Hono } from 'hono'
+import type { Context, Next } from 'hono'
+import { log } from '../../logger'
+import { config, getBaseUrl } from '../../config'
+import { validateApiKey } from '../../auth/api-key'
+import { verifyWorkerJwt } from '../../auth/jwt'
+import { extractBearerToken, sessionAuth } from '../../auth/middleware'
+import { resolveExistingSessionId } from '../../services/session'
+import {
+  ArtifactError,
+  ARTIFACT_ALLOWED_TTLS,
+  ARTIFACT_MAX_BYTES,
+  createArtifact,
+  getArtifactContent,
+  type ArtifactTtl,
+} from '../../services/artifacts'
+
+const app = new Hono()
+
+/**
+ * CLI/worker artifact upload + public content read.
+ *
+ * Mirrors the upstream cloud-artifacts worker contract:
+ * - POST /v1/artifacts (API key or worker JWT auth) — body {html, hash?, ttl?,
+ *   session_id?, title?} → {id, url, expiresAt}. Passing `hash` overwrites
+ *   the artifact in place (URL stays stable).
+ * - GET /v1/artifacts/:id/content — serves the stored HTML document. Access
+ *   is URL-is-the-secret (the id is an unguessable nanoid), same trust model
+ *   as the upstream service. Set RCS_ARTIFACTS_PUBLIC_ACCESS=false to require
+ *   auth on content reads as well.
+ */
+
+function artifactUrl(id: string): string {
+  return `${getBaseUrl()}/v1/artifacts/${id}/content`
+}
+
+/** API key or worker JWT — same credential surface as session ingress. */
+function authenticateWorker(c: Context): boolean {
+  const token = extractBearerToken(c)
+  if (!token) return false
+  if (validateApiKey(token)) return true
+  return verifyWorkerJwt(token) !== null
+}
+
+/**
+ * Content-read auth. Default (artifactsPublicAccess=true): open — the
+ * unguessable id IS the secret, matching the upstream cloud-artifacts trust
+ * model. Operators can set RCS_ARTIFACTS_PUBLIC_ACCESS=false to require a
+ * web session (cookie/bearer) or worker credential instead.
+ */
+async function contentAuth(c: Context, next: Next) {
+  if (config.artifactsPublicAccess === false) {
+    if (authenticateWorker(c)) {
+      await next()
+      return
+    }
+    return sessionAuth(c, next)
+  }
+  await next()
+}
+
+app.post('/artifacts', async c => {
+  if (!authenticateWorker(c)) {
+    return c.json(
+      { error: { type: 'unauthorized', message: 'Invalid auth token' } },
+      401,
+    )
+  }
+
+  let body: Record<string, unknown>
+  try {
+    body = await c.req.json()
+  } catch {
+    return c.json(
+      { error: { type: 'bad_request', message: 'Invalid JSON body' } },
+      400,
+    )
+  }
+
+  const html = typeof body.html === 'string' ? body.html : undefined
+  if (!html || html.length === 0) {
+    return c.json(
+      { error: { type: 'bad_request', message: 'html is required' } },
+      400,
+    )
+  }
+
+  const hash = typeof body.hash === 'string' ? body.hash : undefined
+  const ttlRaw = body.ttl
+  let ttl: ArtifactTtl | undefined
+  if (ttlRaw !== undefined) {
+    const n =
+      typeof ttlRaw === 'number' ? ttlRaw : Number.parseInt(String(ttlRaw), 10)
+    if (!ARTIFACT_ALLOWED_TTLS.includes(n as ArtifactTtl)) {
+      return c.json(
+        { error: { type: 'bad_request', message: 'ttl must be 7 or 30' } },
+        400,
+      )
+    }
+    ttl = n as ArtifactTtl
+  }
+
+  const title = typeof body.title === 'string' ? body.title : undefined
+
+  // Session association is best-effort: unknown session ids (local REPL runs,
+  // SDK mode) simply leave the artifact session-less.
+  let sessionId: string | undefined
+  const requestedSessionId =
+    typeof body.session_id === 'string' ? body.session_id : undefined
+  if (requestedSessionId) {
+    sessionId = resolveExistingSessionId(requestedSessionId) ?? undefined
+    if (!sessionId) {
+      log(
+        `[artifacts] upload referenced unknown session ${requestedSessionId} — storing session-less`,
+      )
+    }
+  }
+
+  try {
+    const result = createArtifact({
+      html,
+      hash,
+      ttl,
+      sessionId,
+      title,
+    })
+    return c.json(
+      {
+        id: result.id,
+        url: artifactUrl(result.id),
+        expiresAt: result.expiresAt,
+      },
+      201,
+    )
+  } catch (err) {
+    if (err instanceof ArtifactError) {
+      const status =
+        err.code === 'payload_too_large'
+          ? 413
+          : err.code === 'invalid_ttl' || err.code === 'invalid_hash'
+            ? 400
+            : 500
+      return c.json({ error: { type: err.code, message: err.message } }, status)
+    }
+    throw err
+  }
+})
+
+/** Content read — URL-is-the-secret by default; session-auth-gated when public access is disabled. */
+app.get('/artifacts/:id/content', contentAuth, async c => {
+  const id = c.req.param('id')!
+  const artifact = getArtifactContent(id)
+  if (!artifact) {
+    return c.notFound()
+  }
+
+  return c.body(artifact.content, 200, {
+    'content-type': artifact.contentType,
+    'cache-control': 'public, max-age=60',
+    'x-content-type-options': 'nosniff',
+  })
+})
+
+/** Head variant so embedders can probe existence cheaply. */
+app.on('HEAD', '/artifacts/:id/content', contentAuth, async c => {
+  const id = c.req.param('id')!
+  const artifact = getArtifactContent(id)
+  if (!artifact) return c.notFound()
+  return c.body(null, 200, {
+    'content-type': artifact.contentType,
+    'cache-control': 'public, max-age=60',
+  })
+})
+
+// Cap documented alongside the service — kept here so route-level callers
+// (tests) can assert against the same constant.
+export { ARTIFACT_MAX_BYTES }
+
+export default app

package/packages/remote-control-server/src/routes/v1/environments.ts

@@ -4,7 +4,7 @@ import {
   registerEnvironment,
   deregisterEnvironment,
   reconnectEnvironment,
-  updatePollTime,
+  touchEnvironmentActivity,
 } from '../../services/environment'
 import { acceptCliHeaders, apiKeyAuth } from '../../auth/middleware'
 import {
@@ -291,7 +291,12 @@ app.post('/bridge', acceptCliHeaders, bridgeAuth, async c => {
 app.get('/:id/assignment', acceptCliHeaders, bridgeAuth, async c => {
   const envId = c.req.param('id')!
   const env = storeGetEnvironment(envId)
-  if (!env || env.status !== 'active') {
+  // 'disconnected' is NOT a 404 here: the ownership gate below authorizes the
+  // caller first, then touchEnvironmentActivity reactivates the env — a live
+  // wait-mode worker polling a monitor-flipped env recovers instead of
+  // dead-waiting on swallowed 404s for its 24h deadline. Deregistered is
+  // terminal.
+  if (!env || env.status === 'deregistered') {
     return c.json(
       { error: { type: 'not_found', message: 'Environment not found' } },
       404,
@@ -299,10 +304,11 @@ app.get('/:id/assignment', acceptCliHeaders, bridgeAuth, async c => {
   }
 
   // Ownership gate: assignment discloses the env's bound session AND doubles
-  // as its liveness signal (updatePollTime below) — both are restricted to
-  // the env owner (the wait-mode worker polls under the same identity it
-  // registered with) and admins. Unowned envs (claim pending) stay open:
-  // nothing is bound yet, so there is nothing to disclose or keep alive.
+  // as its liveness signal (touchEnvironmentActivity below) — both are
+  // restricted to the env owner (the wait-mode worker polls under the same
+  // identity it registered with) and admins. Unowned envs (claim pending)
+  // stay open: nothing is bound yet, so there is nothing to disclose or keep
+  // alive.
   const caller = resolveAttachCaller(c)
   if (caller.dbUnavailable) {
     return c.json(
@@ -345,9 +351,11 @@ app.get('/:id/assignment', acceptCliHeaders, bridgeAuth, async c => {
   // The attach-wait worker has no work item in flight, so the work-poll
   // route never refreshes its heartbeat. This poll IS its liveness signal:
   // without touching lastPollAt the disconnect monitor flips the env to
-  // disconnected after the idle timeout, assignment starts 404ing, and the
-  // CLI silently spins until its 24h deadline (P0-2).
-  updatePollTime(envId)
+  // disconnected after the idle timeout and the CLI silently spins until its
+  // 24h deadline (P0-2). touchEnvironmentActivity also reactivates an env the
+  // monitor already flipped (runs only after the gate — a 403 must not keep
+  // a dead env looking alive).
+  touchEnvironmentActivity(envId)
   const assigned = storeListSessionsByEnvironment(envId)
     .filter(s => !isSessionClosedStatus(s.status))
     .filter(s => s.source !== 'acp')

package/packages/remote-control-server/src/routes/v1/environments.work.ts

@@ -6,14 +6,14 @@ import {
   heartbeatWork,
 } from '../../services/work-dispatch'
 import { apiKeyAuth, acceptCliHeaders } from '../../auth/middleware'
-import { updatePollTime } from '../../services/environment'
+import { touchEnvironmentActivity } from '../../services/environment'
 
 const app = new Hono()
 
 /** GET /v1/environments/:id/work/poll — Long-poll for work */
 app.get('/:id/work/poll', acceptCliHeaders, apiKeyAuth, async c => {
   const envId = c.req.param('id')!
-  updatePollTime(envId)
+  touchEnvironmentActivity(envId)
   const result = await pollWork(envId)
   if (!result) {
     // Return 204 No Content so the client's axios parses it as null