The End of the Cloud-LLM Economy: The Foundational Theory of the 'Local-First Agentic Web' Designed with Next.js 16 × WebGPU × CRDT

1960s  Mainframe (centralized: compute is far, terminals are dumb)
1980s  PC revolution (distributed: compute descends to your hands)
2000s  Web / SPA (centralized: compute returns to the server)
2010s  Cloud-native microservices (the apex of centralization)
2020s  Edge / CDN Workers (re-distributed: bring computation geographically closer)
2023-  Generative AI (hyper-centralized: inference consolidates into hyperscalers)
202X-  ?

                              ┌───────────────────────────────┐
                              │  The user's device             │
                              │  ─ M3/M4/Snapdragon X/Lunar Lake ─│
                              │                                 │
  Cloud (BFF / Relay)         │   ┌───────────────────────┐     │
  ─ Next.js 16 Server ─        │   │ Next.js 16 App Router │     │
  ─ Go (Routing/Policy)  ◄──RSC┼───┤  (RSC + Client)       │     │
                              │   └────────┬──────────────┘     │
                              │            │ Structured         │
                              │            ▼ Concurrency         │
                              │   ┌──────────────────────────┐   │
                              │   │ Agent Supervisor (Actor) │   │
                              │   │  ─ Planner / Critic /    │   │
                              │   │    Executor / Retriever  │   │
                              │   └───┬────────────┬─────────┘   │
                              │       │            │             │
                              │       ▼            ▼             │
                              │  ┌──────────┐ ┌────────────┐    │
                              │  │ Inference│ │  CRDT Store│    │
                              │  │  Engine  │ │ (LWW + HLC)│    │
                              │  │ (WebGPU) │ │            │    │
                              │  └────┬─────┘ └────┬───────┘    │
                              │       │            │             │
                              │  ┌────▼────┐ ┌─────▼──────┐    │
                              │  │ WGSL   │  │ IndexedDB  │    │
                              │  │ Kernels│  │ (encrypted)│    │
                              │  └────────┘  └─────┬──────┘    │
                              │                    │            │
                              └────────────────────┼────────────┘
                                                   │ E2EE sync
                                                   ▼
                                     ┌─────────────────────────┐
                                     │ Relay (Zero-knowledge)  │
                                     │ CFW / D1: ciphertext only│
                                     └─────────────────────────┘

// shaders/matvec_q4_0.wgsl
// 概要: y = W · x
//   W: [M, K], Q4_0 量子化（32要素ブロックごとに fp16 scale 1つ + 4bit nibble 32個）
//   x: [K], fp16
//   y: [M], fp16
// タイリング: 各ワークグループが M方向の 1行 を 256スレッドで共同処理し、
//           K方向をストライド=256 で舐める。部分和は workgroup memory で木状リダクション。
//
// 前提: device features ['shader-f16'] が有効化されていること。

enable f16;

struct Meta {
    M: u32,
    K: u32,             // K は 32 の倍数
    blocks_per_row: u32, // K / 32
};

@group(0) @binding(0) var<uniform> meta : Meta;

// W は「[M, blocks_per_row]」に詰め、1ブロック = 18バイト = 9 × u16
// -> u32 で読むため、1ブロックを 5 × u32 の先頭部分として扱い、tail を mask する。
// 実装を簡素化するため、ここでは 1ブロック = 20バイト = 5 × u32 にパディング。
struct Q4Block {
    scale : u32,    // lower 16bit: fp16 scale, upper 16bit: padding
    q0 : u32,       // 4bit × 8 = 32bit
    q1 : u32,
    q2 : u32,
    q3 : u32,       // 4bit × 8 = 32bit（32要素を 4 つの u32 に格納）
};

@group(0) @binding(1) var<storage, read>       W_q : array<Q4Block>;
@group(0) @binding(2) var<storage, read>       X   : array<f16>;
@group(0) @binding(3) var<storage, read_write> Y   : array<f16>;

const WG_SIZE : u32 = 256u;
var<workgroup> partial : array<f32, WG_SIZE>;

// 4bit nibble を符号付き整数(−8..+7) に変換
fn dequant_nibble(n: u32) -> f32 {
    // Q4_0 は (nibble - 8) * scale
    let s = i32(n) - 8;
    return f32(s);
}

@compute @workgroup_size(WG_SIZE)
fn main(
    @builtin(workgroup_id)        wg : vec3<u32>,
    @builtin(local_invocation_id) lid: vec3<u32>,
) {
    let row = wg.x;
    if (row >= meta.M) { return; }

    var acc : f32 = 0.0;

    // K方向をストライド WG_SIZE で走査。各スレッドは約 K/WG_SIZE 要素担当。
    var k : u32 = lid.x;
    loop {
        if (k >= meta.K) { break; }

        // 対応ブロック
        let blk_idx   = (row * meta.blocks_per_row) + (k / 32u);
        let in_block  = k % 32u;
        let u32_idx   = in_block / 8u;        // 0..3
        let nibble_sh = (in_block % 8u) * 4u; // 0,4,8,...28

        let blk = W_q[blk_idx];
        let scale_bits = blk.scale & 0xFFFFu;
        let scale = f32(bitcast<f16>(u32(scale_bits)));

        // 5要素のQを走査するのではなく、対応するu32ワードを選択
        var q_word : u32;
        switch (u32_idx) {
            case 0u: { q_word = blk.q0; }
            case 1u: { q_word = blk.q1; }
            case 2u: { q_word = blk.q2; }
            default: { q_word = blk.q3; }
        }

        let nibble = (q_word >> nibble_sh) & 0xFu;
        let w = dequant_nibble(nibble) * scale;
        let x = f32(X[k]);
        acc = acc + w * x;

        k = k + WG_SIZE;
    }

    // workgroup 内で木状リダクション
    partial[lid.x] = acc;
    workgroupBarrier();

    var stride : u32 = WG_SIZE / 2u;
    loop {
        if (stride == 0u) { break; }
        if (lid.x < stride) {
            partial[lid.x] = partial[lid.x] + partial[lid.x + stride];
        }
        workgroupBarrier();
        stride = stride / 2u;
    }

    if (lid.x == 0u) {
        Y[row] = f16(partial[0]);
    }
}

// src/inference/webgpu/runtime.ts
// WebGPUデバイスの「準備完了状態」を phantom type で表現する。
// これにより「createBufferを未初期化のdeviceで呼ぶ」類の事故がコンパイル時に消える。

declare const __GpuReadyBrand: unique symbol;
export type ReadyDevice = GPUDevice & { readonly [__GpuReadyBrand]: true };

export interface GpuCapabilities {
  readonly f16: boolean;
  readonly maxComputeWorkgroupSizeX: number;
  readonly maxStorageBufferBindingSize: number;
}

export async function acquireDevice(): Promise<{
  device: ReadyDevice;
  caps: GpuCapabilities;
}> {
  if (!("gpu" in navigator)) throw new Error("WebGPU unavailable");
  const adapter = await navigator.gpu.requestAdapter({ powerPreference: "high-performance" });
  if (!adapter) throw new Error("No WebGPU adapter");

  const f16 = adapter.features.has("shader-f16");
  if (!f16) throw new Error("shader-f16 required for Q4 kernels");

  const device = await adapter.requestDevice({
    requiredFeatures: ["shader-f16"],
    requiredLimits: {
      maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
      maxComputeWorkgroupStorageSize: 16384,
    },
  });

  device.lost.then((info) => {
    // GPUコンテキストロスト（Windowsスリープ復帰、別アプリのVRAM圧迫等）は常態的に発生する。
    // ここで全バッファ・パイプラインを破棄し、上位のSupervisorにrestart通知を送る。
    gpuLostBus.emit({ reason: info.reason, message: info.message });
  });

  const caps: GpuCapabilities = {
    f16,
    maxComputeWorkgroupSizeX: adapter.limits.maxComputeWorkgroupSizeX,
    maxStorageBufferBindingSize: adapter.limits.maxStorageBufferBindingSize,
  };
  return { device: device as ReadyDevice, caps };
}

// 型レベルで「カーネルはバインディングレイアウトに適合したバッファ群でのみ呼べる」ことを強制
export interface KernelBinding<Name extends string, Mode extends "uniform" | "storage" | "storage-rw"> {
  readonly name: Name;
  readonly mode: Mode;
  readonly buffer: GPUBuffer;
}

export interface Kernel<Bindings extends readonly KernelBinding<string, "uniform" | "storage" | "storage-rw">[]> {
  dispatch(device: ReadyDevice, bindings: Bindings, workgroups: readonly [number, number, number]): void;
}

// src/agent/domain.ts
import { z } from "zod";

// Branded ID：異種のIDを混同できない。
// AgentIdをTaskIdに渡した瞬間にコンパイルが止まる。
export type Brand<T, B extends string> = T & { readonly __brand: B };
export type AgentId = Brand<string, "AgentId">;
export type TaskId  = Brand<string, "TaskId">;
export type TraceId = Brand<string, "TraceId">;

// エージェントの役割（閉じた集合として設計）
export type Role =
  | "planner"     // 目的分解
  | "retriever"   // ローカルベクタ検索
  | "executor"    // ツール呼び出し / 推論
  | "critic"      // 結果検証 / ハルシネーション検知
  | "memorian";   // 長期記憶（CRDTへの書き戻し）

// 予算（FinOpsの最小単位をドメインに持ち込む）
// 「使える電力」「使えるトークン」「使える時間」を明示的に資源として扱う。
export interface Budget {
  readonly wallClockMs: number;
  readonly tokens: number;
  readonly joules: number; // バッテリー残量からの許容量（推定）
}

// エージェント状態：代数的データ型として網羅性を担保
export type AgentState<TResult> =
  | { readonly kind: "idle" }
  | { readonly kind: "planning";   plan: Plan; since: number }
  | { readonly kind: "awaiting";   toolCall: ToolCall; since: number }
  | { readonly kind: "reflecting"; draft: TResult; critiques: readonly Critique[] }
  | { readonly kind: "done";       result: TResult; tokensUsed: number }
  | { readonly kind: "failed";     error: AgentError; retriable: boolean };

export interface Plan {
  readonly steps: readonly PlanStep[];
  readonly createdAt: number;
}

export type PlanStep =
  | { readonly kind: "retrieve"; query: string }
  | { readonly kind: "infer";    prompt: string; maxTokens: number }
  | { readonly kind: "tool";     name: string; args: Readonly<Record<string, unknown>> };

export interface ToolCall {
  readonly id: TaskId;
  readonly name: string;
  readonly args: Readonly<Record<string, unknown>>;
}

export interface Critique {
  readonly reason: string;
  readonly severity: "minor" | "major" | "blocking";
}

export type AgentError =
  | { readonly kind: "budget_exhausted"; resource: keyof Budget }
  | { readonly kind: "tool_denied";      policy: string }
  | { readonly kind: "gpu_lost" }
  | { readonly kind: "inference_failed"; cause: string }
  | { readonly kind: "poisoned";         score: number }; // 敵対的入力検知

// 遷移の合法性を型で縛る：不正な状態遷移を書けないヘルパ
export function transition<TResult>(
  from: AgentState<TResult>,
  event: AgentEvent<TResult>
): AgentState<TResult> {
  switch (from.kind) {
    case "idle":
      if (event.kind === "start") return { kind: "planning", plan: event.plan, since: event.at };
      return from;
    case "planning":
      if (event.kind === "call_tool")
        return { kind: "awaiting", toolCall: event.call, since: event.at };
      if (event.kind === "produced")
        return { kind: "reflecting", draft: event.draft, critiques: [] };
      if (event.kind === "fail")
        return { kind: "failed", error: event.error, retriable: event.retriable };
      return from;
    case "awaiting":
      if (event.kind === "tool_result")
        return { kind: "reflecting", draft: event.draft, critiques: [] };
      return from;
    case "reflecting":
      if (event.kind === "approve")
        return { kind: "done", result: from.draft, tokensUsed: event.tokens };
      if (event.kind === "critique") {
        const next: AgentState<TResult> = {
          kind: "reflecting",
          draft: event.revision ?? from.draft,
          critiques: [...from.critiques, event.critique],
        };
        // 3回以上重大な批評がついたら失敗
        const blocking = next.critiques.filter((c) => c.severity === "blocking").length;
        if (blocking >= 2) {
          return { kind: "failed", error: { kind: "inference_failed", cause: "too many critiques" }, retriable: false };
        }
        return next;
      }
      return from;
    case "done":
    case "failed":
      return from; // 終端状態は不変
  }
}

export type AgentEvent<TResult> =
  | { kind: "start";      plan: Plan; at: number }
  | { kind: "call_tool";  call: ToolCall; at: number }
  | { kind: "tool_result"; draft: TResult }
  | { kind: "produced";   draft: TResult }
  | { kind: "approve";    tokens: number }
  | { kind: "critique";   critique: Critique; revision?: TResult }
  | { kind: "fail";       error: AgentError; retriable: boolean };

// src/agent/actor.ts
import type { AgentId, TraceId } from "./domain";

export interface Envelope<M> {
  readonly to: AgentId;
  readonly from: AgentId;
  readonly trace: TraceId;
  readonly msg: M;
  readonly deadline: number; // epoch ms, 過ぎたら drop
}

// 有界Mailbox：バックプレッシャを型に表す
export class Mailbox<M> {
  private buf: Envelope<M>[] = [];
  private waiters: Array<(e: Envelope<M>) => void> = [];
  constructor(private readonly capacity: number) {}

  /** 満杯なら `false` を返す。呼び出し側は計画段階でretry戦略を決める。 */
  trySend(e: Envelope<M>): boolean {
    if (this.buf.length >= this.capacity) return false;
    const w = this.waiters.shift();
    if (w) { w(e); return true; }
    this.buf.push(e);
    return true;
  }

  async receive(signal: AbortSignal): Promise<Envelope<M>> {
    const now = Date.now();
    // 既存メッセージから期限切れを捨てる
    while (this.buf.length && this.buf[0]!.deadline < now) this.buf.shift();
    const head = this.buf.shift();
    if (head) return head;

    return new Promise<Envelope<M>>((resolve, reject) => {
      const onAbort = () => {
        this.waiters = this.waiters.filter((w) => w !== resolve);
        reject(new DOMException("aborted", "AbortError"));
      };
      signal.addEventListener("abort", onAbort, { once: true });
      this.waiters.push(resolve);
    });
  }
}

export type RestartStrategy = "one-for-one" | "one-for-all" | "rest-for-one";

export interface Actor<M, R> {
  readonly id: AgentId;
  run(inbox: Mailbox<M>, signal: AbortSignal): Promise<R>;
}

interface ChildSpec<M, R> {
  readonly actor: Actor<M, R>;
  readonly maxRestarts: number;
  readonly withinMs: number;
}

export class Supervisor {
  private controllers = new Map<AgentId, AbortController>();
  private inboxes     = new Map<AgentId, Mailbox<unknown>>();
  private restartLog  = new Map<AgentId, number[]>();

  constructor(private readonly strategy: RestartStrategy) {}

  // child を起動。型パラメータで各アクターのメッセージ型を保持
  spawn<M, R>(spec: ChildSpec<M, R>): void {
    const ctrl = new AbortController();
    const inbox = new Mailbox<M>(/* cap */ 256);

    this.controllers.set(spec.actor.id, ctrl);
    this.inboxes.set(spec.actor.id, inbox as Mailbox<unknown>);

    const loop = async () => {
      try {
        await spec.actor.run(inbox, ctrl.signal);
      } catch (err) {
        if (ctrl.signal.aborted) return;
        if (this.shouldRestart(spec)) {
          this.onChildCrash(spec.actor.id);
          this.spawn(spec);
        } else {
          // エスカレーション：親Supervisorへ伝播
          this.abortAll(err);
        }
      }
    };
    void loop();
  }

  private shouldRestart<M, R>(spec: ChildSpec<M, R>): boolean {
    const log = this.restartLog.get(spec.actor.id) ?? [];
    const now = Date.now();
    const recent = log.filter((t) => now - t < spec.withinMs);
    recent.push(now);
    this.restartLog.set(spec.actor.id, recent);
    return recent.length <= spec.maxRestarts;
  }

  private onChildCrash(id: AgentId): void {
    if (this.strategy === "one-for-one") return;
    if (this.strategy === "one-for-all") this.abortAll(new Error(`${id} crashed`));
    if (this.strategy === "rest-for-one") {
      // TODO: 起動順を保持して、このidの後続だけ再起動
    }
  }

  private abortAll(reason: unknown): void {
    for (const c of this.controllers.values()) c.abort(reason);
  }

  /** Typedなsend。msg の型とactor の型がミスマッチなら compile error */
  send<M>(to: AgentId, env: Envelope<M>): boolean {
    const ib = this.inboxes.get(to) as Mailbox<M> | undefined;
    if (!ib) return false;
    return ib.trySend(env);
  }
}

// src/crdt/hlc.ts
export interface HLC {
  readonly l: number; // 論理時刻（ミリ秒単位、物理時間に追随）
  readonly c: number; // カウンタ
  readonly nodeId: string; // tiebreaker
}

const MAX_DRIFT_MS = 60_000;

export function hlcNow(prev: HLC, pt: number = Date.now(), nodeId = prev.nodeId): HLC {
  const l = Math.max(prev.l, pt);
  const c = l === prev.l ? prev.c + 1 : 0;
  assertDrift(l, pt);
  return { l, c, nodeId };
}

export function hlcRecv(local: HLC, remote: HLC, pt: number = Date.now()): HLC {
  const l = Math.max(local.l, remote.l, pt);
  let c: number;
  if (l === local.l && l === remote.l) c = Math.max(local.c, remote.c) + 1;
  else if (l === local.l) c = local.c + 1;
  else if (l === remote.l) c = remote.c + 1;
  else c = 0;
  assertDrift(l, pt);
  return { l, c, nodeId: local.nodeId };
}

function assertDrift(l: number, pt: number): void {
  if (l - pt > MAX_DRIFT_MS) {
    // 悪意あるピアによる偽の未来時刻。受信時点で拒否する（ゼロトラスト）。
    throw new Error("HLC drift exceeds threshold: possibly malicious clock");
  }
}

export function hlcCompare(a: HLC, b: HLC): number {
  if (a.l !== b.l) return a.l - b.l;
  if (a.c !== b.c) return a.c - b.c;
  return a.nodeId.localeCompare(b.nodeId); // tiebreaker で決定的に
}

// src/crdt/lwwMap.ts
import { HLC, hlcCompare, hlcNow, hlcRecv } from "./hlc";

export interface Cell<V> {
  readonly v: V | null; // nullで tombstone（削除を表す）
  readonly ts: HLC;
}

// 内部 Op 形式。アプリ層は Op のみをやり取りする。
export type Op<V> = { k: string; v: V | null; ts: HLC };

export class LWWMap<V> {
  private cells = new Map<string, Cell<V>>();
  private clock: HLC;

  constructor(nodeId: string) {
    this.clock = { l: 0, c: 0, nodeId };
  }

  get(k: string): V | null {
    const c = this.cells.get(k);
    return c ? c.v : null;
  }

  /** ローカル書き込み。副作用として返す Op を同期層へ放流する。 */
  set(k: string, v: V | null): Op<V> {
    this.clock = hlcNow(this.clock);
    const cell: Cell<V> = { v, ts: this.clock };
    this.cells.set(k, cell);
    return { k, v, ts: this.clock };
  }

  /** リモートOp受信。冪等・可換・結合的（ACI）な merge。 */
  apply(op: Op<V>): void {
    this.clock = hlcRecv(this.clock, op.ts);
    const cur = this.cells.get(op.k);
    if (!cur || hlcCompare(op.ts, cur.ts) > 0) {
      this.cells.set(op.k, { v: op.v, ts: op.ts });
    }
    // 劣位Opは黙殺（idempotent）
  }

  /** Strong Eventual Consistency（SEC）の保証：
   *  同じOp集合を任意順で適用した任意レプリカは、同一状態に収束する。
   *  証明スケッチ：applyはACI（次節）のため、lub（上限）として一意に定まる。 */
}

// src/sync/e2ee.ts
// WebAuthn の PRF 拡張（Prf Extension, Level 3）からデバイス鍵を派生させる。
// ユーザー認証が再度行われない限り派生鍵は取り出せない → デバイス紛失時も安全。

export interface DerivedKey {
  readonly aesKey: CryptoKey;    // AES-GCM 256
  readonly kid: string;           // key id（ユーザーごとに一意）
}

export async function deriveDeviceKey(
  credentialId: Uint8Array,
  salt: Uint8Array, // ユーザー固有ソルト
): Promise<DerivedKey> {
  const assertion = await navigator.credentials.get({
    publicKey: {
      challenge: crypto.getRandomValues(new Uint8Array(32)),
      allowCredentials: [{ id: credentialId, type: "public-key" }],
      userVerification: "required",
      extensions: { prf: { eval: { first: salt } } } as AuthenticationExtensionsClientInputs,
    },
  }) as PublicKeyCredential | null;
  if (!assertion) throw new Error("auth failed");

  const exts = assertion.getClientExtensionResults() as AuthenticationExtensionsClientOutputs & {
    prf?: { results?: { first?: ArrayBuffer } };
  };
  const prf = exts.prf?.results?.first;
  if (!prf) throw new Error("PRF not supported; enforce hardware key");

  const keyMaterial = await crypto.subtle.importKey("raw", prf, "HKDF", false, ["deriveKey"]);
  const aesKey = await crypto.subtle.deriveKey(
    { name: "HKDF", hash: "SHA-256", salt, info: new TextEncoder().encode("sync-aes-256-gcm") },
    keyMaterial,
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"],
  );
  const kid = await sha256Hex(prf);
  return { aesKey, kid };
}

export interface EncryptedEnvelope {
  readonly kid: string;
  readonly iv: string;  // base64url
  readonly ct: string;  // base64url (ciphertext || tag)
  readonly aad?: string;
}

export async function sealOp<V>(
  key: DerivedKey,
  op: unknown, // Opや任意のJSON値
  aad?: string,
): Promise<EncryptedEnvelope> {
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const plain = new TextEncoder().encode(JSON.stringify(op));
  const additional = aad ? new TextEncoder().encode(aad) : undefined;
  const cipher = await crypto.subtle.encrypt(
    { name: "AES-GCM", iv, additionalData: additional },
    key.aesKey,
    plain,
  );
  return {
    kid: key.kid,
    iv: b64u(iv),
    ct: b64u(new Uint8Array(cipher)),
    aad,
  };
}

export async function openOp<V>(
  key: DerivedKey,
  env: EncryptedEnvelope,
): Promise<unknown> {
  if (env.kid !== key.kid) throw new Error("key id mismatch");
  const iv = b64uDecode(env.iv);
  const ct = b64uDecode(env.ct);
  const aad = env.aad ? new TextEncoder().encode(env.aad) : undefined;
  const plain = await crypto.subtle.decrypt(
    { name: "AES-GCM", iv, additionalData: aad },
    key.aesKey,
    ct,
  );
  return JSON.parse(new TextDecoder().decode(plain));
}

async function sha256Hex(buf: BufferSource): Promise<string> {
  const h = new Uint8Array(await crypto.subtle.digest("SHA-256", buf));
  return Array.from(h, (b) => b.toString(16).padStart(2, "0")).join("");
}

function b64u(b: Uint8Array): string {
  return btoa(String.fromCharCode(...b)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
function b64uDecode(s: string): Uint8Array {
  const pad = "=".repeat((4 - (s.length % 4)) % 4);
  const b = atob(s.replace(/-/g, "+").replace(/_/g, "/") + pad);
  return Uint8Array.from(b, (ch) => ch.charCodeAt(0));
}

// relay/worker.ts (Cloudflare Workers)
// サーバー側は暗号文にアクセスできない。できる保証のあるオペレーションだけを提供する。
export default {
  async fetch(req: Request, env: { RELAY: KVNamespace }): Promise<Response> {
    const u = new URL(req.url);
    const tenant = u.searchParams.get("t");
    if (!tenant) return new Response("tenant required", { status: 400 });

    // WebAuthn 署名 JWT の検証（鍵はユーザーデバイスの公開鍵）のみ実施
    const ok = await verifyAttestationJWT(req.headers.get("Authorization"));
    if (!ok) return new Response("unauthorized", { status: 401 });

    if (req.method === "POST") {
      const body = await req.text(); // EncryptedEnvelope のJSON
      // 内容を読まない。サイズ制限とレート制限のみ。
      if (body.length > 64 * 1024) return new Response("too large", { status: 413 });
      await env.RELAY.put(`${tenant}/${crypto.randomUUID()}`, body, { expirationTtl: 30 * 86400 });
      return new Response(null, { status: 204 });
    }

    if (req.method === "GET") {
      const list = await env.RELAY.list({ prefix: `${tenant}/` });
      const envelopes = await Promise.all(list.keys.map((k) => env.RELAY.get(k.name)));
      return Response.json(envelopes.filter(Boolean));
    }
    return new Response("method not allowed", { status: 405 });
  },
};

// app/ai/page.tsx  （RSC；サーバーで描画される）
import { selectModelForDevice, type ModelDescriptor } from "@/lib/model-registry";
import { AgentRoot } from "@/components/agent/AgentRoot";

export const dynamic = "force-dynamic";

export default async function AIPage({
  headers,
}: {
  // Next.js 16: async params / headers パターン
  params: Promise<Record<string, string>>;
  searchParams: Promise<Record<string, string>>;
}) {
  // クライアントヒント（Sec-CH-UA-Platform, Device-Memory, Viewport-Width）を読む
  const uaHints = await readClientHints();
  const model: ModelDescriptor = selectModelForDevice(uaHints);

  // クライアントにはモデルのメタデータ（URL, 量子化形式, 期待帯域）だけを渡す。
  // 実バイナリは署名付きURLでCDNから直接取得するため、ここでは流れない。
  return <AgentRoot model={model} />;
}

// components/agent/AgentRoot.tsx
"use client";
import { useEffect, useMemo, useRef, useState } from "react";
import { Supervisor } from "@/agent/actor";
import { LWWMap } from "@/crdt/lwwMap";
import { acquireDevice } from "@/inference/webgpu/runtime";
import { loadModel } from "@/inference/webgpu/loader";
import { PlannerAgent } from "@/agent/planner";
import { ExecutorAgent } from "@/agent/executor";
import { CriticAgent } from "@/agent/critic";
import type { ModelDescriptor } from "@/lib/model-registry";

export function AgentRoot({ model }: { readonly model: ModelDescriptor }) {
  const [state, setState] = useState<"booting" | "ready" | "failed">("booting");
  const supRef = useRef<Supervisor | null>(null);

  useEffect(() => {
    let cancelled = false;
    (async () => {
      try {
        const { device, caps } = await acquireDevice();
        if (!caps.f16) throw new Error("fp16 required");

        const runtime = await loadModel(device, model); // CDN→IndexedDB（一度きり）
        const crdt    = new LWWMap<string>(crypto.randomUUID());

        const sup = new Supervisor("one-for-one");
        sup.spawn({ actor: new PlannerAgent(runtime, crdt),  maxRestarts: 3, withinMs: 30_000 });
        sup.spawn({ actor: new ExecutorAgent(runtime, crdt), maxRestarts: 3, withinMs: 30_000 });
        sup.spawn({ actor: new CriticAgent(runtime),         maxRestarts: 5, withinMs: 30_000 });

        if (cancelled) return;
        supRef.current = sup;
        setState("ready");
      } catch {
        if (!cancelled) setState("failed");
      }
    })();
    return () => {
      cancelled = true;
      supRef.current = null;
    };
  }, [model]);

  if (state === "booting") return <BootingView model={model} />;
  if (state === "failed")  return <FallbackCloudView />;
  return <ChatView supervisor={supRef.current!} />;
}

// components/agent/useSpeculativeCompletion.ts
"use client";
import { useEffect, useRef, useState } from "react";
import type { Supervisor } from "@/agent/actor";

export function useSpeculativeCompletion(
  supervisor: Supervisor,
  input: string,
  debounceMs = 150,
) {
  const [draft, setDraft] = useState<string>("");
  const abortRef = useRef<AbortController | null>(null);
  const budgetRef = useRef<number>(0);

  useEffect(() => {
    // 1文字ごとにキャンセル→再投機。キャンセルが軽いのはローカル推論の特権。
    abortRef.current?.abort();
    if (input.length < 3) { setDraft(""); return; }

    const ac = new AbortController();
    abortRef.current = ac;
    const t = setTimeout(async () => {
      // バッテリー予算が尽きていれば投機しない（UXより電池を守る）
      if (budgetRef.current <= 0) return;
      try {
        // idle callback で UI を阻害しないよう待つ
        await whenIdle();
        const result = await supervisor
          .speculativeInfer(input, ac.signal, { maxTokens: 16 });
        setDraft(result.text);
        budgetRef.current -= result.joules;
      } catch { /* aborted */ }
    }, debounceMs);

    return () => { clearTimeout(t); ac.abort(); };
  }, [input, supervisor, debounceMs]);

  return draft;
}

function whenIdle(): Promise<void> {
  return new Promise((r) => {
    if ("requestIdleCallback" in window) {
      (window as Window & { requestIdleCallback: (cb: IdleRequestCallback) => void })
        .requestIdleCallback(() => r());
    } else {
      setTimeout(r, 16);
    }
  });
}