Integrate canonical architecture: two-process backend + LiveKit agent

Promote all 12 staged canonical files from docs/generated/files/ to their
live paths, creating the full PodMan architecture:

Backend:
- server.ts: HTTP service (token mint, sync-PR, outcome recording, /health, WS relay)
- agent.ts: worker joining LiveKit room, grabbing screenshare frames at ~1fps
- agent/podman.ts: orchestrator loop (vision -> collision detection -> intervention)
- env.ts: flat env var accessors replacing nested stub
- vision/gemini.ts: JPEG -> Gemini vision -> EngineerContext (real implementation)
- collision/detector.ts: fused vision+GitHub collision detection (the moat)
- github/client.ts: Octokit wrapper with caching + sync PR creation
- memory/store.ts: extended with recordObservation/recordCollision/recordIntervention/recordOutcome helpers
- memory/vectors.ts: stub for Voyage+Atlas vector recall (Loop A)
- memory/policy.ts: stub for intervention policy gate (Loop B)
- voice/live.ts: stub for Gemini Live TTS voice output

Shared:
- messages.ts: LiveKit data-channel wire protocol (DataMessage, InterventionOutcome, TeamModel, LocalGitReport)
- index.ts: re-exports messages module

Frontend:
- livekit/useScreenPublish.ts: hook for joining pod and publishing screenshare
- livekit/useInterventions.ts: hook for receiving collision cards and responding
- lib/api.ts: fetchToken + postOutcome HTTP helpers

Database:
- database/init.ts: MongoDB Atlas collections + indexes + vector search index

Infra:
- infra/.do/app.yaml: DO App Platform spec (static_site + service + worker)

Retire stubs superseded by canonical decomposition:
- backend/src/index.ts (replaced by server.ts)
- backend/src/intervention/engine.ts (logic now in agent/podman.ts)
- backend/src/livekit/token.ts (token minting now in server.ts)

Install missing dependencies: @livekit/rtc-node, sharp, mongodb, ws, @types/ws

Type error fixes:
- vision/gemini.ts: use MediaResolution.MEDIA_RESOLUTION_LOW enum value (not string literal)
- agent/podman.ts: wrap SuggestedActionKind into { kind: action } SuggestedAction object

All packages pass pnpm -r typecheck and pnpm -r build.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

frontend/src/lib/api.ts

@@ -0,0 +1,29 @@
+import type { InterventionOutcome } from '@podman/shared';
+
+const BACKEND_URL = import.meta.env.VITE_BACKEND_URL || 'http://localhost:8787';
+
+/** Mint a LiveKit token from the backend. */
+export async function fetchToken(params: {
+  room: string;
+  identity: string;
+  name: string;
+  githubLogin?: string;
+}): Promise<{ token: string; url: string }> {
+  const res = await fetch(`${BACKEND_URL}/api/token`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(params),
+  });
+  if (!res.ok) throw new Error(`token request failed: ${res.status}`);
+  return res.json() as Promise<{ token: string; url: string }>;
+}
+
+/** Record an intervention outcome for the policy learning loop. */
+export async function postOutcome(outcome: InterventionOutcome): Promise<void> {
+  const res = await fetch(`${BACKEND_URL}/api/outcome`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(outcome),
+  });
+  if (!res.ok) throw new Error(`outcome post failed: ${res.status}`);
+}

frontend/src/livekit/useInterventions.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState, useCallback } from 'react';
+import { RoomEvent, type Room } from 'livekit-client';
+import type { DataMessage, Intervention, InterventionStatus } from '@podman/shared';
+import { DATA_TOPIC } from '@podman/shared';
+import { postOutcome } from '../lib/api';
+
+export function useInterventions(room: Room | null) {
+  const [active, setActive] = useState<Intervention | null>(null);
+
+  useEffect(() => {
+    if (!room) return;
+    const onData = (payload: Uint8Array, _p: unknown, _k: unknown, topic?: string) => {
+      if (topic !== DATA_TOPIC) return;
+      const msg = JSON.parse(new TextDecoder().decode(payload)) as DataMessage;
+      if (msg.type === 'COLLISION') setActive(msg.intervention);
+    };
+    room.on(RoomEvent.DataReceived, onData);
+    return () => { room.off(RoomEvent.DataReceived, onData); };
+  }, [room]);
+
+  const respond = useCallback(
+    async (status: InterventionStatus, accepted: boolean) => {
+      if (!active) return;
+      await postOutcome({
+        interventionId: active.id,
+        collisionId: active.collisionId,
+        podId: active.podId,
+        wasRealCollision: true,
+        accepted,
+        recordedAt: new Date().toISOString(),
+      });
+      setActive(null);
+      return status;
+    },
+    [active],
+  );
+
+  return { active, respond };
+}

frontend/src/livekit/useScreenPublish.ts

@@ -0,0 +1,38 @@
+import { useCallback, useRef, useState } from 'react';
+import { Room, Track, createLocalScreenTracks, VideoPresets } from 'livekit-client';
+import { fetchToken } from '../lib/api';
+
+export function useScreenPublish() {
+  const roomRef = useRef<Room | null>(null);
+  const [connected, setConnected] = useState(false);
+  const [sharing, setSharing] = useState(false);
+
+  const join = useCallback(async (pod: string, identity: string, name: string, githubLogin?: string) => {
+    const { token, url } = await fetchToken({ room: pod, identity, name, githubLogin });
+    const room = new Room({ adaptiveStream: true, dynacast: true });
+    await room.connect(url, token);
+    roomRef.current = room;
+    setConnected(true);
+    return room;
+  }, []);
+
+  const startSharing = useCallback(async () => {
+    const room = roomRef.current;
+    if (!room) throw new Error('join the pod first');
+    const tracks = await createLocalScreenTracks({
+      audio: true,
+      resolution: VideoPresets.h1080.resolution,
+    });
+    for (const t of tracks) {
+      await room.localParticipant.publishTrack(t.mediaStreamTrack, {
+        source:
+          t.kind === Track.Kind.Audio ? Track.Source.ScreenShareAudio : Track.Source.ScreenShare,
+      });
+    }
+    await room.localParticipant.setMicrophoneEnabled(true);
+    await room.localParticipant.setCameraEnabled(true);
+    setSharing(true);
+  }, []);
+
+  return { join, startSharing, connected, sharing, room: roomRef };
+}