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>

backend/src/agent/podman.ts

@@ -0,0 +1,75 @@
+import { RoomEvent, type Room } from '@livekit/rtc-node';
+import type { EngineerContext, Collision, Intervention, DataMessage } from '@podman/shared';
+import { DATA_TOPIC } from '@podman/shared';
+import { analyzeFrame } from '../vision/gemini.js';
+import { detectCollisions } from '../collision/detector.js';
+import { getGithubState } from '../github/client.js';
+import { recordObservation, recordCollision, recordIntervention } from '../memory/store.js';
+import { recallSimilar } from '../memory/vectors.js';
+import { shouldIntervene, preferredAction } from '../memory/policy.js';
+import { speak } from '../voice/live.js';
+
+export class PodMan {
+  private contexts = new Map<string, EngineerContext>();
+  private encoder = new TextEncoder();
+
+  constructor(
+    private room: Room,
+    private podId: string,
+  ) {}
+
+  async start(): Promise<void> {
+    // Tier-2 optional ground-truth + engineer ACKs arrive over the data channel.
+    this.room.on(RoomEvent.DataReceived, (payload) => {
+      try {
+        const msg = JSON.parse(new TextDecoder().decode(payload)) as DataMessage;
+        if (msg.type === 'GIT_REPORT') {
+          const c = this.contexts.get(msg.report.engineerId);
+          if (c) c.hasUnpushedChanges = msg.report.unpushedCount > 0 || msg.report.dirtyFiles.length > 0;
+        }
+      } catch { /* ignore malformed */ }
+    });
+  }
+
+  async onScreenFrame(engineerId: string, jpeg: Buffer): Promise<void> {
+    const ctx = await analyzeFrame(engineerId, this.podId, jpeg);
+    this.contexts.set(engineerId, ctx);
+    await recordObservation(ctx);
+
+    const github = await getGithubState(); // cached
+    const collisions = detectCollisions([...this.contexts.values()], github);
+    for (const collision of collisions) await this.handle(collision);
+  }
+
+  private async handle(collision: Collision): Promise<void> {
+    const prior = await recallSimilar(collision); // Loop A: vector recall raises confidence
+    if (prior) collision.severity = 'critical';
+    if (!shouldIntervene(collision, prior)) return; // Loop B: policy gate
+
+    await recordCollision(collision);
+    const action = preferredAction(collision, prior);
+    const names = collision.engineers.join(' and ');
+    const message = `${names} are both editing ${collision.file}` +
+      (collision.githubState?.unpushed ? ' and one has unpushed changes.' : '.') +
+      (prior ? ` I've seen this conflict pattern before.` : '');
+
+    const intervention: Intervention = {
+      id: `int_${Date.now()}`,
+      collisionId: collision.id,
+      podId: this.podId,
+      kind: 'card',
+      message,
+      suggestedAction: { kind: action },
+      status: 'pending',
+      createdAt: new Date().toISOString(),
+    };
+    await recordIntervention(intervention);
+
+    const data: DataMessage = { type: 'COLLISION', collision, intervention };
+    await this.room.localParticipant?.publishData(
+      this.encoder.encode(JSON.stringify(data)),
+      { reliable: true, topic: DATA_TOPIC },
+    );
+    await speak(this.room, message); // gemini-3.1-flash-live voice into the room
+  }
+}