@logicseek/hello-cc 1.0.0 → 1.0.2-dsh.3

package/lib/web/native-sessions.mjs

@@ -0,0 +1,286 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { CliError } from '../shared/errors.mjs';
+import { redactSecrets } from '../shared/redact.mjs';
+import { tx } from '../db/schema.mjs';
+import { createEventHelpers } from '../db/events.mjs';
+import { nativeRequest } from '../runtime/native/client.mjs';
+
+const PROVIDERS = new Set(['codex', 'claude', 'dsh']);
+const CLOSED = new Set(['closed', 'exited', 'stopped']);
+const HISTORY_LIMIT = 200;
+
+// A Web view of a worker already owned by the independent native service.
+// This module never starts a service, provider process, or foreign TUI session.
+export function createNativeSessions({ sessions, sessionKey, connectWebProject,
+  broadcast = () => {}, closeSessionClients = () => {},
+  now = () => Math.floor(Date.now() / 1000), nativeApi = nativeRequest,
+  addEvent = createEventHelpers({ now }).addEvent } = {}) {
+  const projects = new Map();
+  const scans = new Map();
+  let stopped = false;
+
+  function projectKey(ctx) { return `${ctx.root}\0${path.resolve(ctx.dbPath)}`; }
+  function projectSessions(ctx) {
+    return [...sessions.values()].filter((session) => session.type === 'native' &&
+      projectKey(session.ctx) === projectKey(ctx) && !session.nativeRetired);
+  }
+  function errorInfo(error) {
+    return redactSecrets({ code: error.code || 'NATIVE_RUNTIME_OFFLINE',
+      message: error.message || 'Native runtime is disconnected' });
+  }
+  function disconnect(session, error, retire = false) {
+    session.status = 'disconnected';
+    session.nativeState = { ...session.nativeState, connected: false, status: 'disconnected', error: errorInfo(error) };
+    broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+    if (retire && !session.nativeRetired) {
+      session.nativeRetired = true;
+      closeSessionClients(session);
+      session.actionTokens.clear();
+      session.actionTokenSockets?.clear();
+    }
+  }
+  function assertProject(ctx, value) {
+    if (!value || value.root !== fs.realpathSync(ctx.root) || value.meshDb !== path.resolve(ctx.dbPath) ||
+        typeof value.generation !== 'string' || !value.generation || value.generation.length > 128) {
+      throw new CliError('NATIVE_SCOPE_CHANGED', 'Native runtime does not match this project');
+    }
+  }
+  function validateState(ctx, peer, value) {
+    assertProject(ctx, value);
+    if (value.peer !== peer || !PROVIDERS.has(value.provider) ||
+        typeof value.owner !== 'string' || !value.owner || value.owner.length > 512 ||
+        !value.snapshot || value.snapshot.provider !== value.provider ||
+        typeof value.snapshot.status !== 'string' ||
+        (value.snapshot.sessionId != null && typeof value.snapshot.sessionId !== 'string') ||
+        !Array.isArray(value.events) || !Array.isArray(value.deliveries) ||
+        value.events.some((event) => event.peer !== peer || !Number.isSafeInteger(event.id) || event.id < 1) ||
+        value.deliveries.some((delivery) => delivery.peer !== peer)) {
+      throw new CliError('NATIVE_RESPONSE_INVALID', 'Native state is not scoped to the requested worker');
+    }
+    const db = connectWebProject(ctx);
+    try {
+      const binding = db.prepare('SELECT * FROM peer_bindings WHERE peer=?').get(peer);
+      // A resumed Claude SDK query initializes lazily on its first input. The
+      // service retains its saved binding while the owned adapter is ready
+      // with no confirmed session ID; its init event must confirm that ID.
+      const lazyClaudeResume = value.provider === 'claude' && value.snapshot.status === 'ready' &&
+        value.snapshot.sessionId == null;
+      if (!binding || binding.transport !== 'native' || binding.provider !== value.provider ||
+          binding.runtime_target !== value.owner ||
+          ((binding.provider_session_id || null) !== (value.snapshot.sessionId || null) && !lazyClaudeResume)) {
+        throw new CliError('NATIVE_OWNER_CHANGED', 'Native worker binding changed; refresh the current worker');
+      }
+      return { value, binding: { ...binding } };
+    } finally { db.close(); }
+  }
+  function sameIdentity(session, value) {
+    const identity = session.nativeIdentity;
+    return identity.generation === value.generation && identity.owner === value.owner &&
+      identity.provider === value.provider &&
+      (!identity.sessionId || identity.sessionId === (value.snapshot.sessionId || null));
+  }
+  function current(session) {
+    if (stopped || session.nativeRetired || sessions.get(sessionKey(session.ctx, session.id)) !== session) {
+      throw new CliError('NATIVE_OWNER_CHANGED', 'This Web view no longer owns the current native worker');
+    }
+  }
+  function applyState(session, { value, binding }) {
+    current(session);
+    if (!sameIdentity(session, value)) {
+      const error = new CliError('NATIVE_OWNER_CHANGED', 'Native worker ownership changed');
+      disconnect(session, error, true);
+      throw error;
+    }
+    if (value.snapshot.sessionId) session.nativeIdentity.sessionId = value.snapshot.sessionId;
+    const events = new Map((session.nativeState?.events || []).map((event) => [event.id, event]));
+    for (const event of value.events) events.set(event.id, event);
+    const history = [...events.values()].sort((a, b) => a.id - b.id);
+    const cursor = Math.max(session.nativeState?.eventCursor || 0, ...value.events.map((event) => event.id));
+    const turnId = value.snapshot.turnId || value.snapshot.activeTurnId || value.active_delivery?.turn_id || null;
+    session.binding = binding;
+    session.cwd = value.cwd;
+    session.nativeState = redactSecrets({ backend: 'native', connected: true, root: value.root,
+      peer: value.peer, provider: value.provider, generation: value.generation, owner: value.owner,
+      executorId: value.owner, sessionId: value.snapshot.sessionId || null, turnId,
+      status: value.snapshot.status, cwd: value.cwd, capabilities: value.snapshot.capabilities || {}, pendingApprovals: value.snapshot.pendingApprovals || [],
+      quarantined: Boolean(value.quarantined), closing: Boolean(value.closing),
+      activeDelivery: value.active_delivery || null, events: history.slice(-HISTORY_LIMIT),
+      deliveries: value.deliveries.slice(0, 100), eventCursor: cursor,
+      truncated: Boolean(session.nativeState?.truncated || history.length > HISTORY_LIMIT) });
+    session.status = CLOSED.has(value.snapshot.status) ? 'exited'
+      : value.snapshot.status === 'disconnected' ? 'disconnected' : 'running';
+    if (session.status === 'exited') session.exitedAt = now();
+    broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+    return session.nativeSnapshot();
+  }
+  function makeSession(ctx, checked) {
+    const { value, binding } = checked;
+    const session = { id: value.peer, peerId: value.peer, root: ctx.root, ctx,
+      kind: value.provider, role: 'native-worker', type: 'native', command: null,
+      cwd: value.cwd, pid: null, status: 'running', createdAt: now(),
+      clients: new Set(), actionTokens: new Set(), buffer: '', binding,
+      nativeIdentity: { generation: value.generation, owner: value.owner,
+        provider: value.provider, sessionId: value.snapshot.sessionId || null }, nativeState: null };
+    session.nativeSnapshot = () => structuredClone(session.nativeState);
+    sessions.set(sessionKey(ctx, session.id), session);
+    applyState(session, checked);
+    return session;
+  }
+  async function readState(session) {
+    current(session);
+    const params = new URLSearchParams({ after: String(session.nativeState?.eventCursor || 0),
+      generation: session.nativeIdentity.generation, owner: session.nativeIdentity.owner });
+    const value = await nativeApi(session.ctx, 'GET', `/workers/${encodeURIComponent(session.peerId)}/state?${params}`);
+    current(session);
+    return applyState(session, validateState(session.ctx, session.peerId, value));
+  }
+  async function scan(ctx) {
+    let status;
+    try {
+      status = await nativeApi(ctx, 'GET', '/status', null, { timeoutMs: 2000 });
+      assertProject(ctx, status);
+      if (!Array.isArray(status.workers)) throw new CliError('NATIVE_RESPONSE_INVALID', 'Native worker list is invalid');
+    } catch (error) {
+      if (!stopped) for (const session of projectSessions(ctx)) disconnect(session, error,
+        ['NATIVE_SCOPE_CHANGED', 'NATIVE_OWNER_CHANGED'].includes(error.code));
+      return projectSessions(ctx);
+    }
+    if (stopped) return [];
+    const owned = status.workers.filter((worker) => worker.owned === true && PROVIDERS.has(worker.provider) &&
+      typeof worker.peer === 'string' && /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/.test(worker.peer));
+    const present = new Set(owned.map((worker) => worker.peer));
+    for (const session of projectSessions(ctx)) {
+      if (session.nativeIdentity.generation !== status.generation || !present.has(session.peerId)) {
+        disconnect(session, new CliError('NATIVE_OWNER_CHANGED', 'Native worker is no longer owned by this service'), true);
+      }
+    }
+    await Promise.allSettled(owned.map(async (worker) => {
+      const key = sessionKey(ctx, worker.peer);
+      const existing = sessions.get(key);
+      if (existing && existing.type !== 'native') return;
+      try {
+        const sameOwner = existing && !existing.nativeRetired && existing.nativeIdentity.owner === worker.owner &&
+          existing.nativeIdentity.generation === status.generation;
+        const after = sameOwner ? existing.nativeState?.eventCursor || 0 : 0;
+        const params = new URLSearchParams({ after: String(after), generation: status.generation, owner: worker.owner });
+        const value = await nativeApi(ctx, 'GET', `/workers/${encodeURIComponent(worker.peer)}/state?${params}`, null, { timeoutMs: 2000 });
+        if (stopped) return;
+        const checked = validateState(ctx, worker.peer, value);
+        if (existing && !existing.nativeRetired && sameIdentity(existing, value)) applyState(existing, checked);
+        else {
+          if (existing && !existing.nativeRetired) disconnect(existing,
+            new CliError('NATIVE_OWNER_CHANGED', 'Native worker ownership changed'), true);
+          makeSession(ctx, checked);
+        }
+      } catch (error) {
+        if (!stopped && existing && !existing.nativeRetired) disconnect(existing, error,
+          ['NATIVE_SCOPE_CHANGED', 'NATIVE_OWNER_CHANGED', 'NATIVE_WORKER_NOT_FOUND'].includes(error.code));
+      }
+    }));
+    return projectSessions(ctx);
+  }
+  function discoverNativeSessions(ctx) {
+    if (stopped) return Promise.resolve([]);
+    const key = projectKey(ctx);
+    projects.set(key, ctx);
+    if (scans.has(key)) return scans.get(key);
+    const operation = scan(ctx).finally(() => { if (scans.get(key) === operation) scans.delete(key); });
+    scans.set(key, operation);
+    return operation;
+  }
+  async function pollNativeSessions(ctx) {
+    if (ctx) return discoverNativeSessions(ctx);
+    const results = await Promise.allSettled([...projects.values()].map(discoverNativeSessions));
+    return results.flatMap((result) => result.status === 'fulfilled' ? result.value : []);
+  }
+  function receiptEvent(session, type, payload) {
+    const db = connectWebProject(session.ctx);
+    try { addEvent(db, type, session.peerId, null, payload); } finally { db.close(); }
+  }
+  async function nativeAction(session, action, input = {}) {
+    if (session?.type !== 'native') throw new CliError('BAD_REQUEST', 'A native worker view is required');
+    current(session);
+    if (action === 'state') return session.nativeSnapshot();
+    if (!['read', 'send', 'interrupt', 'close', 'respond'].includes(action)) throw new CliError('BAD_REQUEST', 'Unsupported native worker action');
+    let text, submissionId;
+    if (action === 'send') {
+      text = typeof input.text === 'string' ? input.text.trim() : typeof input.body === 'string' ? input.body.trim() : '';
+      submissionId = input.submissionId;
+      if (!text || text.length > 100000 || typeof submissionId !== 'string' || !/^[A-Za-z0-9_-]{8,100}$/.test(submissionId)) {
+        throw new CliError('BAD_REQUEST', 'A message and a unique submissionId are required');
+      }
+    }
+    try { await readState(session); }
+    catch (error) {
+      if (!session.nativeRetired) disconnect(session, error,
+        ['NATIVE_OWNER_CHANGED', 'NATIVE_SCOPE_CHANGED', 'NATIVE_WORKER_NOT_FOUND'].includes(error.code));
+      throw error;
+    }
+    if (action === 'read') return session.nativeSnapshot();
+    if (session.status !== 'running') throw new CliError('NATIVE_WORKER_NOT_FOUND', 'Native worker is not open');
+    if (typeof input.authorizeMutation === 'function') input.authorizeMutation();
+    const identity = { peer: session.peerId, generation: session.nativeIdentity.generation,
+      owner: session.nativeIdentity.owner, provider: session.kind, sessionId: session.nativeIdentity.sessionId };
+    if (action === 'respond' && (input.executorId !== session.nativeState.executorId || input.sessionId !== session.nativeState.sessionId)) {
+      throw new CliError('NATIVE_APPROVAL_MISMATCH', 'Interaction belongs to another executor or provider session');
+    }
+    if (action === 'interrupt' && !session.nativeState.capabilities.interrupt) {
+      throw new CliError('NATIVE_CAPABILITY_UNSUPPORTED', 'Provider does not support interrupt');
+    }
+    const pending = { submission_id: submissionId, owner: identity.owner, generation: identity.generation,
+      provider: identity.provider, provider_session_id: identity.sessionId };
+    if (action === 'send') {
+      const db = connectWebProject(session.ctx);
+      try {
+        tx(db, () => {
+          if (db.prepare(`SELECT id FROM events WHERE type='native.web.submission.pending'
+            AND json_extract(payload, '$.submission_id')=? LIMIT 1`).get(submissionId)) {
+            throw new CliError('SUBMISSION_EXISTS', 'This submission was already attempted; inspect native deliveries before sending again');
+          }
+          addEvent(db, 'native.web.submission.pending', session.peerId, null, pending);
+        });
+      } finally { db.close(); }
+    }
+    current(session);
+    if (typeof input.authorizeMutation === 'function') input.authorizeMutation();
+    try {
+      const result = await nativeApi(session.ctx, 'POST', `/${action === 'send' ? 'send' : action}`, {
+        ...identity, ...(action === 'send' ? { from: 'web', body: text, submissionId }
+          : action === 'interrupt' ? { turnId: input.turnId || session.nativeState.turnId || undefined }
+          : action === 'respond' ? { executorId: input.executorId, requestId: input.requestId, turnId: input.turnId,
+            decision: input.decision, permissions: input.permissions, scope: input.scope, answers: input.answers } : {})
+      });
+      if (action === 'send') {
+        if (!Number.isSafeInteger(result?.message_id) || result.submission_id !== submissionId || typeof result.state !== 'string') {
+          throw new CliError('NATIVE_RESPONSE_INVALID', 'Native queue receipt is invalid', { uncertain: true });
+        }
+        receiptEvent(session, 'native.web.submission.queued', { ...pending, message_id: result.message_id, state: result.state });
+      }
+      current(session);
+      if (action === 'respond') { await readState(session); current(session); }
+      if (action === 'close') {
+        session.status = 'exited'; session.exitedAt = now();
+        session.nativeState = { ...session.nativeState, connected: false, status: 'closed', closing: false };
+        broadcast(session, { type: 'native_state', state: session.nativeSnapshot() });
+        closeSessionClients(session);
+        session.actionTokens.clear();
+      }
+      return result;
+    } catch (error) {
+      if (action === 'send') receiptEvent(session, 'native.web.submission.unconfirmed', { ...pending, code: error.code || 'UNKNOWN' });
+      if (['NATIVE_OWNER_CHANGED', 'NATIVE_SCOPE_CHANGED'].includes(error.code) && !session.nativeRetired) disconnect(session, error, true);
+      throw error;
+    }
+  }
+  function closeNativeBridge() {
+    stopped = true;
+    for (const session of sessions.values()) {
+      if (session.type === 'native' && !session.nativeRetired) disconnect(session,
+        new CliError('NATIVE_WEB_DISCONNECTED', 'Web disconnected; the independent native worker keeps running'));
+      if (session.type === 'native') closeSessionClients(session);
+    }
+    projects.clear();
+  }
+  return { discoverNativeSessions, pollNativeSessions, nativeAction, closeNativeBridge };
+}

package/lib/web/project-contexts.mjs

@@ -5,6 +5,7 @@
 
 import path from 'node:path';
 import { randomBytes } from 'node:crypto';
+import WebSocket from 'ws';
 import { CliError } from '../shared/errors.mjs';
 import { contextForProject } from '../runtime/paths.mjs';
 import { resolveProjectDatabase } from '../runtime/project-path.mjs';
@@ -27,7 +28,7 @@ export function createProjectContexts(deps) {
     observePeerEvidence, peerEvidenceFromDb,
     observeClockSafetyInTransaction,
     assertTaskOwnerForMutation, claimNextTasksForPeer, takeOverTaskForPeer,
-    positiveIntOpt, sameResolvedPath
+    positiveIntOpt, sameResolvedPath, assertSessionControl
   } = deps;
 
   const projectContexts = new Map();
@@ -145,10 +146,15 @@ export function createProjectContexts(deps) {
     }
     const provided = readActionToken(input, req);
     const authorized = Boolean(provided) && [...(session.actionTokens || [])]
-      .some((candidate) => tokenMatches(provided, candidate));
+      .some((candidate) => {
+        if (!tokenMatches(provided, candidate)) return false;
+        const socket = session.actionTokenSockets?.get(candidate);
+        return socket?.readyState === WebSocket.OPEN;
+      });
     if (!authorized) {
       throw new CliError("PEER_IDENTITY_REQUIRED", "Web peer action for " + peer + " requires the managed session action token", { peer });
     }
+    assertSessionControl?.(session, provided, input.epoch);
     return actorPeer;
   }
 

package/lib/web/pty-sessions.mjs

@@ -14,6 +14,7 @@ import {
 import { providerSessionPeerId } from '../core/peers/session.mjs';
 import { childSessionEnv } from '../core/sessions/launch.mjs';
 import { detectBranch } from '../project-context.mjs';
+import { tx } from '../db/schema.mjs';
 
 export function createPtySessions(deps) {
   const {
@@ -26,6 +27,18 @@ export function createPtySessions(deps) {
     requestActorPeer, requestSource
   } = deps;
 
+  function assertPtyOwnerAllowed(db, id, binding = {}) {
+    const owner = db.prepare('SELECT transport FROM peer_bindings WHERE peer = ?').get(id);
+    const providerOwner = binding && (binding.provider_session_id || binding.provider_session_name)
+      ? db.prepare(`SELECT transport FROM peer_bindings WHERE provider = ? AND
+          ((? IS NOT NULL AND provider_session_id = ?) OR (? IS NOT NULL AND provider_session_name = ?)) LIMIT 1`)
+        .get(binding.provider, binding.provider_session_id || null, binding.provider_session_id || null,
+          binding.provider_session_name || null, binding.provider_session_name || null) : null;
+    if ([owner, providerOwner].some(row => ['native', 'app-server'].includes(row?.transport))) {
+      throw new CliError('STRUCTURED_SESSION_NO_TERMINAL', 'Open the structured worker instead of replacing its binding with a PTY');
+    }
+  }
+
   function startPtySession(input) {
     const pctx = input.projectCtx || ctx;
     const kind = input.kind || 'shell';
@@ -33,6 +46,8 @@ export function createPtySessions(deps) {
     const actorPeer = requestActorPeer(input, id);
     const auditSource = requestSource(input, 'web');
     const key = sessionKey(pctx, id);
+    const preflightDb = connectWebProject(pctx);
+    try { assertPtyOwnerAllowed(preflightDb, id, input.binding); } finally { preflightDb.close(); }
     if (sessions.has(key) && sessions.get(key).status === 'running') {
       return sessions.get(key);
     }
@@ -48,6 +63,7 @@ export function createPtySessions(deps) {
       TERM: 'xterm-256color'
     }, callerEnv);
     const size = input.size || { cols: 100, rows: 30 };
+    const previousSession = sessions.get(key);
     const child = pty.spawn(shell, ['-c', command], {
       name: 'xterm-256color',
       cols: size.cols,
@@ -76,42 +92,53 @@ export function createPtySessions(deps) {
       clients: new Set()
     };
     sessions.set(key, session);
-    const db = connectWebProject(pctx);
+    let db;
     try {
-      upsertPeer(db, {
-        id,
-        kind,
-        role,
-        worktree: cwd,
-        branch: detectBranch(cwd),
-        pid: child.pid,
-        status: 'running',
-        capabilities: 'web-pty'
+      db = connectWebProject(pctx);
+      tx(db, () => {
+        assertPtyOwnerAllowed(db, id, input.binding);
+        upsertPeer(db, {
+          id,
+          kind,
+          role,
+          worktree: cwd,
+          branch: detectBranch(cwd),
+          pid: child.pid,
+          status: 'running',
+          capabilities: 'web-pty'
+        });
+        const canonical = upsertCanonicalPeerBinding(db, {
+          peer: id,
+          provider: input.binding?.provider || kind,
+          provider_session_id: input.binding?.provider_session_id || null,
+          provider_session_name: input.binding?.provider_session_name || null,
+          resume_mode: input.binding?.resume_mode || 'new',
+          resume_arg: input.binding?.resume_arg || null,
+          command,
+          transport: 'web-pty',
+          runtime_session_id: id
+        }, Boolean(input.force));
+        session.peerId = canonical.peer;
+        session.binding = { ...canonical.binding };
+        addEvent(db, 'web.session.started', actorPeer, null, auditPayload({
+          actor: actorPeer,
+          target: session.peerId || id,
+          source: auditSource,
+          admin: actorPeer !== (session.peerId || id),
+          command,
+          cwd,
+          pid: child.pid
+        }));
       });
-      const canonical = upsertCanonicalPeerBinding(db, {
-        peer: id,
-        provider: input.binding?.provider || kind,
-        provider_session_id: input.binding?.provider_session_id || null,
-        provider_session_name: input.binding?.provider_session_name || null,
-        resume_mode: input.binding?.resume_mode || 'new',
-        resume_arg: input.binding?.resume_arg || null,
-        command,
-        transport: 'web-pty',
-        runtime_session_id: id
-      }, Boolean(input.force));
-      session.peerId = canonical.peer;
-      session.binding = { ...canonical.binding };
-      addEvent(db, 'web.session.started', actorPeer, null, auditPayload({
-        actor: actorPeer,
-        target: session.peerId || id,
-        source: auditSource,
-        admin: actorPeer !== (session.peerId || id),
-        command,
-        cwd,
-        pid: child.pid
-      }));
+    } catch (error) {
+      try { child.kill(); } catch {}
+      if (sessions.get(key) === session) {
+        if (previousSession) sessions.set(key, previousSession);
+        else sessions.delete(key);
+      }
+      throw error;
     } finally {
-      db.close();
+      db?.close();
     }
     child.onData((data) => {
       session.buffer += data;

package/lib/web/runtime-main.mjs

@@ -109,6 +109,10 @@ import { ensureSelfSignedCert } from '../web/tls.mjs';
 import * as webUiTemplate from '../web/ui-template.mjs';
 import { createWebPeerActions } from '../web/peer-actions.mjs';
 import { createCookieAuth } from '../web/cookie-auth.mjs';
+import { createControlLease } from './control-lease.mjs';
+import { createCodexSessions } from './codex-sessions.mjs';
+import { createTaskResults } from './task-results.mjs';
+import { createNativeSessions } from './native-sessions.mjs';
 import { createProjectContexts } from '../web/project-contexts.mjs';
 import { createExternalSessions } from '../web/external-sessions.mjs';
 import { createLivenessReaper } from '../web/liveness-reaper.mjs';
@@ -231,8 +235,36 @@ async function cmdWeb(ctx, args, startMeta = {}) {
     sessionKey, sessionsForProject,
     resolveSessionPeerId, sessionBindingForSerialize,
     serializeBindingSummary, serializeSession,
-    broadcast, hasOpenClients, closeSessionClients
-  } = createSessionSerialize({ sessions, cookieSocketValid, ctx, sameResolvedPath });
+    broadcast, hasOpenClients, closeSessionClients: closeSerializedSessionClients
+  } = createSessionSerialize({ sessions, cookieSocketValid, ctx, sameResolvedPath,
+    localClientObservation: (session) => {
+      try { return tmuxClientObservation(tmuxSessionNameForPane(session.pane)); }
+      catch { return { state: 'unknown', count: null }; }
+    }
+  });
+  const controlLease = createControlLease({ broadcast: (session) => {
+    for (const [actionToken, socket] of session.actionTokenSockets || []) {
+      if (cookieSocketValid(socket) && socket.readyState === 1) {
+        socket.send(JSON.stringify({ type: 'control', control: controlLease.status(session, actionToken) }));
+      }
+    }
+  } });
+  function closeSessionClients(session) {
+    controlLease.forget(session);
+    closeSerializedSessionClients(session);
+  }
+  function assertSessionControl(session, actionToken, epoch) {
+    try { return controlLease.assertControl(session, actionToken, epoch); }
+    catch (error) { throw new CliError(error.code || 'CONTROL_REQUIRED', error.message); }
+  }
+  function assertWebWrite(session, input, authMode, req) {
+    // Token CLI callers keep their admin path when no browser owns control.
+    // A browser lease also fences admin injection while it is held.
+    if (authMode !== 'cookie' && !controlLease.status(session).has_controller) return;
+    if (!input || typeof input !== 'object' || Array.isArray(input)) throw new CliError('BAD_REQUEST', 'A request object is required');
+    const actionToken = String(input.action_token || input.actionToken || req?.headers['x-hcc-session-token'] || '');
+    assertSessionControl(session, actionToken, input.epoch);
+  }
   // refreshPeerIoHeartbeat comes from createTmuxSessions below; wrap it so the
   // reference resolves at call time instead of at this forward-passing site.
   const lazyRefreshPeerIoHeartbeat = (session) => refreshPeerIoHeartbeat(session);
@@ -254,7 +286,7 @@ const {
     observePeerEvidence, peerEvidenceFromDb,
     observeClockSafetyInTransaction,
     assertTaskOwnerForMutation, claimNextTasksForPeer, takeOverTaskForPeer,
-    positiveIntOpt, sameResolvedPath
+    positiveIntOpt, sameResolvedPath, assertSessionControl
   });
 
   const {
@@ -394,8 +426,36 @@ const {
     upsertPeer, upsertCanonicalPeerBinding,
     requestActorPeer, requestSource
   });
+  const { readSessionResults, writeSessionResult, observeCodexResults } = createTaskResults({
+    connectWebProject, resolveSessionPeerId, now, addEvent
+  });
+  const { startCodexSession, codexAction, stopCodexSession,
+    listCodexThreads, readCodexThread, forkCodexThread } = createCodexSessions({
+    sessions, sessionKey, nextProjectSessionId, connectWebProject, upsertPeer,
+    upsertCanonicalPeerBinding, observePeerEvidence,
+    broadcast: (session, payload) => {
+      if (payload.type === 'codex_state') {
+        try { observeCodexResults(session, payload.state); }
+        catch (error) { console.error(redactedLogText(`Result evidence could not be saved: ${error.code || 'UNKNOWN'}`)); }
+      }
+      broadcast(session, payload);
+    }, closeSessionClients, now, addEvent
+  });
 
   const restoredTmuxDbs = new Set();
+  const { discoverNativeSessions, nativeAction, closeNativeBridge } = createNativeSessions({
+    sessions, sessionKey, connectWebProject, broadcast, closeSessionClients, now, addEvent
+  });
+  let nativeScanRunning = false;
+  async function scanNativeProjects() {
+    if (nativeScanRunning) return;
+    nativeScanRunning = true;
+    try { await Promise.allSettled(runtimeProjectContexts().map(discoverNativeSessions)); }
+    finally { nativeScanRunning = false; }
+  }
+  await scanNativeProjects();
+  const nativePoller = setInterval(() => { void scanNativeProjects(); }, 3000);
+  nativePoller.unref?.();
   for (const projectCtx of runtimeProjectContexts()) {
     const dbKey = path.resolve(projectCtx.dbPath);
     if (restoredTmuxDbs.has(dbKey)) continue;
@@ -416,6 +476,9 @@ const {
     prepareRuntimeBufferGc, applyPreparedRuntimeBufferGc,
     detachTmuxSession, safeTmuxKillPlan, executeTmuxKillPlan,
     killDbProvenTmuxSession, attachTmuxSession, writeSessionInput, startSession,
+    startCodexSession, codexAction, stopCodexSession, assertWebWrite,
+    listCodexThreads, readCodexThread, forkCodexThread, readSessionResults, writeSessionResult,
+    discoverNativeSessions, nativeAction,
     webStatusSnapshot, webPeerActionForProject,
     now, addEvent, auditPayload, sendMessage,
     getProcessIdentity: () => processIdentity,
@@ -499,30 +562,53 @@ const {
         return;
       }
       session.actionTokens ||= new Set();
+      session.actionTokenSockets ||= new Map();
       session.actionTokens.add(connectionActionToken);
-      ws.send(JSON.stringify({ type: 'snapshot', data: refreshTmuxSnapshot(session), action_token: connectionActionToken }));
+      session.actionTokenSockets.set(connectionActionToken, ws);
+      controlLease.connect(session, connectionActionToken);
+      const localClients = session.type === 'tmux' ? serializeSession(session).local_clients : null;
+      ws.send(JSON.stringify({ type: 'snapshot', data: refreshTmuxSnapshot(session),
+        action_token: connectionActionToken, control: controlLease.status(session, connectionActionToken),
+        local_clients: localClients, ...(session.adapter ? { state: session.adapter.snapshot() } : {}),
+        ...(session.type === 'native' ? { native_state: session.nativeSnapshot() } : {}) }));
       ws.on('message', (raw) => {
         try {
           if (!cookieSocketValid(ws)) return;
           const msg = JSON.parse(String(raw));
           if (msg.type === 'input' && session.status === 'running') {
             if (!tokenMatches(msg.action_token, connectionActionToken)) return;
+            assertSessionControl(session, connectionActionToken, msg.epoch);
+            if (['app-server', 'native'].includes(session.type)) throw new CliError('BAD_REQUEST', 'Use structured worker actions');
             const data = String(msg.data || '');
+            if (data.length > 100000) throw new CliError('BAD_REQUEST', 'Terminal input is too large');
             writeSessionInput(session, data);
+            ws.send(JSON.stringify({ type: 'input_ack', input_id: msg.input_id || null }));
           } else if (msg.type === 'resize' && session.status === 'running') {
             if (!tokenMatches(msg.action_token, connectionActionToken)) return;
+            assertSessionControl(session, connectionActionToken, msg.epoch);
+            if (['app-server', 'native'].includes(session.type)) return;
             const cols = Math.max(20, Number.parseInt(msg.cols || 100, 10));
             const rows = Math.max(8, Number.parseInt(msg.rows || 30, 10));
+            if (!Number.isFinite(cols) || !Number.isFinite(rows) || cols > 1000 || rows > 1000) return;
             resizeSession(session, cols, rows);
             scheduleTmuxReplace(session);
+          } else if (msg.type === 'control') {
+            if (!tokenMatches(msg.action_token, connectionActionToken)) return;
+            if (msg.action === 'claim') controlLease.claim(session, connectionActionToken,
+              { epoch: msg.epoch, takeover: msg.force === true });
+            else if (msg.action === 'release') controlLease.release(session, connectionActionToken, msg.epoch);
           }
-        } catch {
-          // Ignore malformed terminal frames.
+        } catch (error) {
+          ws.send(JSON.stringify({ type: 'error', error: { code: error.code || 'BAD_REQUEST',
+            message: error.code ? error.message : 'Malformed terminal frame' },
+            control: controlLease.status(session, connectionActionToken) }));
         }
       });
       ws.on('close', () => {
         session.clients.delete(ws);
         session.actionTokens.delete(connectionActionToken);
+        session.actionTokenSockets.delete(connectionActionToken);
+        controlLease.disconnect(session, connectionActionToken);
         if (cookieAuth) cookieAuth.session.sockets.delete(ws);
       });
     });
@@ -576,10 +662,18 @@ const {
     clearInterval(reaperPoller);
     clearInterval(gcPoller);
     clearInterval(webSessionPruner);
+    clearInterval(nativePoller);
+    closeNativeBridge();
     try { for (const w of bufsWatchers.values()) w.close(); } catch {}
     clearInterval(bufsWatcherSyncPoller);
     for (const session of sessions.values()) {
+      controlLease.forget(session);
       closeSessionClients(session);
+      if (session.type === 'app-server') {
+        await session.adapter.close();
+        continue;
+      }
+      if (session.type === 'native') continue;
       if (session.status !== 'running') continue;
       if (session.type === 'external') {
         try { if (session.outputFd) fs.closeSync(session.outputFd); } catch {}
@@ -641,6 +735,7 @@ const {
   // the next start. tmux sessions are intentionally left alive.
   process.on('exit', () => {
     for (const session of sessions.values()) {
+      if (session.type === 'app-server') void session.adapter.close();
       if (session.type !== 'tmux' && session.type !== 'external' && session.pty) {
         try { session.pty.kill(); } catch {}
       }