/**
 * 指示書AY §3 表5 R1〜R43′〜R51（`lib/ds-agent/relay.ts`。★時刻とタイマーを注入★。t は秒）。
 * ブリーフ §5 と監督判断 第2ラウンドから本書で具体化。★P1・P2 の行は §11 Q14・Q15 の採用で確定★。
 * ★R43′ は指示書BJ（一覧の形不正はブラウザを 502）。prepared・complete・fail の形の誤りは状態を変えない（R43）。★R44 はルートで判定するので段階7-4 のルートのテスト★。
 *
 * エクスポートの状態: 準備中（POST が待っている）→ 準備完了（201。受け取り待ち）→ 送信待ち（GET。send を入れた）→ 流れ中
 * → 完了 / 失敗 / 取り消し / 失効。★準備中〜流れ中を「進行中」と数える★。
 *
 * | #   | 操作 | 期待（relay の結果 → ルートの HTTP） |
 * | R1  | t=0 poll(DS-002, wait=25)。t=1 requestList | poll が即座に { command_id, kind: "list", params: {} }。t=2 submitListResult → 一覧 |
 * | R2  | R1 で結果が来ない | t=16（依頼から15秒）で timeout（504）。t=15.999 ではまだ待っている |
 * | R3  | R2 の後 t=17 に submitListResult | gone（410 command_expired） |
 * | R4  | poll が t=0〜t=25（指示なしで 204）。以後なし | t=85 は接続中（ちょうど60秒）、t=85.001 は未接続（409）。last_seen_at は t=25 |
 * | R5  | 一度もリクエストしていない | 未接続。last_seen_at: null・agent_version: null |
 * | R6  | poll 中 | 接続中（last_seen_at が60秒より前でも） |
 * | R7  | poll が t=25 に終わり、t=80 にチャンクの POST（touch） | last_seen_at は t=80。t=140 は接続中、t=140.001 は未接続 |
 * | R8  | wait が 0 / 26 / abc | 422 validation_failed |
 * | R9  | 同じ制御盤の2本目の poll | 1本目が即座に null（204）、2本目が待つ |
 * | R10 | t=0 createExport(DS-002, [f1, f2]) | poll に { kind: "export", params: { file_ids, max_bytes, chunk_bytes } }。t=10 prepared → createExport が prepared（201） |
 * | R11 | prepared が来ない | t=50 はまだ待っている、t=50.001 で timeout（504）。その後の prepared は gone（410） |
 * | R12 | 準備中に fail { code: too_large ほか } | createExport が agent_error（502。agent_code は制御盤の code） |
 * | R13 | prepared の total_bytes が ちょうど EXPORT_MAX_BYTES / +1 | 201 / 502 agent_error（too_large）。後者は失敗にする（prepared の応答は 204 のまま） |
 * | R14 | prepared から t=+60 に claim / t=+60.001 に claim | 受理 / not_found（404。失効） |
 * | R15 | 同じ export_id で2回目の claim | not_found |
 * | R16 | パスのシリアルが違う claim | not_found |
 * | R17 | claim → send → seq 0〜2 → complete | claim が seq 0 の到着でストリーム（200・Content-Length）。読んだバイト列が一致。閉じる |
 * | R18 | claim から t=+30 に seq 0 / 来ないまま t=+30.001 | 受理 / timeout（504）。その後のチャンクは 410 |
 * | R19 | send の後・最初のチャンクの前に fail（export_not_found を含む） | claim が agent_error（502） |
 * | R20 | prepared の後・send の前にチャンク | 409 chunk_out_of_order |
 * | R21 | seq 0 の後に seq 2 | 409。ストリームを error |
 * | R22 | ハッシュ不一致（流し始めた後） | 400 chunk_invalid。ストリームを error |
 * | R23 | 最初のチャンクのハッシュ不一致 | チャンクは 400。claim は agent_error（chunk_invalid） |
 * | R24 | チャンクの長さ ちょうど CHUNK_MAX_BYTES / +1 / 0 | 受理 / 400 / 400 |
 * | R25 | 受け取った合計が prepared の total_bytes を超えた | 400。ストリームを error |
 * | R26 | complete の total_bytes が違う／受け取った合計が足りない | 400。ストリームを error |
 * | R27 | complete の sha256 が prepared と違う／受け取ったバイト列の SHA-256 が prepared と違う | 400。ストリームを error |
 * | R28 | 流し始めた後に fail（URL は export の指示の command_id） | ストリームを error。fail は 204 |
 * | R29 | 流し始めた後にブラウザが切断（cancel / abort） | 次のチャンクは cancelled（410） |
 * | R30 | seq 0 を受けたがブラウザが読んでいない | pushChunk は保留。reader.read() で解決。relay が持つチャンクは常に2つ以下 |
 * | R31 | R30 の保留が t=+45 / t=+45.001 まで続く | まだ保留 / 410 export_cancelled・失敗（ストリームを error） |
 * | R32 | 流し始めた後、次のチャンクが来ないまま t=+45 / t=+45.001 | 流れたまま / ストリームを error。その後のチャンクは 410 |
 * | R33 | 進行中（準備中・受け取り待ち・送信待ち・流れ中）に2本目の createExport | busy（429 export_busy）。完了・失敗・失効の後は受理 |
 * | R34 | 3台で進行中に4台目 | busy（429） |
 * | R35 | DS-003 で DS-002 の command_id に result・prepared・チャンク | not_found（404）。403 にしない |
 * | R36 | list の command_id に prepared | not_found |
 * | R37 | 待ち行列に PENDING_COMMANDS_PER_DEVICE 件 | busy（429 agent_busy） |
 * | R38 | 一覧の結果に truncated: true | そのままブラウザへ |
 * | R39 | 状態の変化 | connected / disconnected を変化のときだけ1回 |
 * | R40 | t=0 prepared。GET が来ない → t=60 / t=60.001 | 進行中のまま（429）/ 失効: 進行中から外れ受理。claim は 404。その後の fail / チャンクは gone（410） |
 * | R41 | エクスポートの流れ中（または準備中）に requestList | 待ち行列に入れ、poll に list が渡る。一覧が返る |
 * | R42 | send の指示の command_id にチャンク・complete | not_found |
 * | R43 | prepared / complete / fail の本体の形の誤り | 400 result_invalid。状態は変えない（正しい結果を受け取れる） |
 * | R43′ | 一覧の形の誤り → rejectListResult | ブラウザは agent_error（result_invalid）。その後の submit は not_found |
 * | R49 | 保留中に次のチャンク | out_of_order。先の POST は cancelled。flow_timeout は出ない |
 * | R50 | touch(serial, "1.2.3") で未接続から接続 | connected の agent_version が "1.2.3" |
 * | R51 | touch(serial, null) | agent_version は null |
 *
 * ★書き方（§3 のテストの書き方の注意）★: 本物のタイマーで待たない（偽の時計の `at(t)` で進める）。
 * 4MB・9MB は `limits.chunkMaxBytes` を 16 バイトに差し替えて同じ規則を確かめる。境界（ちょうど・+1）は差し替えた値で書く。
 * 期待値は設定値から作る。★わざと違う値（R21〜R23・R27）だけは直書きし、理由をコメントに書く★。
 */
import { createHash } from "node:crypto";
import { describe, expect, it } from "vitest";
import {
  AGENT_OFFLINE_AFTER_SEC,
  CHUNK_MAX_BYTES,
  EXPORT_CLAIM_TIMEOUT_SEC,
  EXPORT_CONCURRENCY_PER_DEVICE,
  EXPORT_CONCURRENCY_TOTAL,
  EXPORT_FIRST_CHUNK_TIMEOUT_SEC,
  EXPORT_IDLE_TIMEOUT_SEC,
  EXPORT_MAX_BYTES,
  EXPORT_PREPARE_TIMEOUT_SEC,
  LIST_TIMEOUT_SEC,
  PENDING_COMMANDS_PER_DEVICE,
} from "@/lib/config/ds-agent";
import { createRelay, type RelayEvent, type RelayLimits } from "@/lib/ds-agent/relay";
import {
  parseAgentComplete,
  parseAgentFail,
  parseAgentListResult,
  parseAgentPollWait,
  parseAgentPrepared,
} from "@/lib/ds-logs/validate";
import { toJstIso } from "@/lib/format/date";
import type { DsAgentListResult } from "@/lib/types";

// ── 偽の時計 ──

const BASE = Date.parse("2026-10-19T12:00:00+09:00");

const DEFAULT_LIMITS: RelayLimits = {
  offlineAfterSec: AGENT_OFFLINE_AFTER_SEC,
  listTimeoutSec: LIST_TIMEOUT_SEC,
  exportPrepareTimeoutSec: EXPORT_PREPARE_TIMEOUT_SEC,
  exportClaimTimeoutSec: EXPORT_CLAIM_TIMEOUT_SEC,
  exportFirstChunkTimeoutSec: EXPORT_FIRST_CHUNK_TIMEOUT_SEC,
  exportIdleTimeoutSec: EXPORT_IDLE_TIMEOUT_SEC,
  chunkMaxBytes: CHUNK_MAX_BYTES,
  exportMaxBytes: EXPORT_MAX_BYTES,
  exportConcurrencyPerDevice: EXPORT_CONCURRENCY_PER_DEVICE,
  exportConcurrencyTotal: EXPORT_CONCURRENCY_TOTAL,
  pendingCommandsPerDevice: PENDING_COMMANDS_PER_DEVICE,
};

/** 送信の試験では 4MB の代わりに 16 バイトで同じ規則を確かめる（§3 のテストの書き方の注意） */
const SMALL_CHUNK = 16;

async function flush(): Promise<void> {
  for (let i = 0; i < 20; i++) await new Promise<void>((resolve) => setImmediate(resolve));
}

function createHarness(overrides: Partial<RelayLimits> = {}) {
  let nowMs = BASE;
  let nextHandle = 1;
  const timers = new Map<number, { at: number; fn: () => void }>();
  const events: RelayEvent[] = [];
  const limits: RelayLimits = { ...DEFAULT_LIMITS, ...overrides };
  const relay = createRelay({
    now: () => nowMs,
    setTimer: (fn, ms) => {
      const handle = nextHandle++;
      timers.set(handle, { at: nowMs + ms, fn });
      return handle;
    },
    clearTimer: (handle) => {
      timers.delete(handle as number);
    },
    limits,
    onEvent: (e) => events.push(e),
  });

  /** 時計を t 秒（BASE からの経過）まで進め、その間に期限の来たタイマーを順に発火させる */
  async function at(t: number): Promise<void> {
    const target = BASE + Math.round(t * 1000);
    for (;;) {
      let next: [number, { at: number; fn: () => void }] | undefined;
      for (const entry of timers) {
        if (entry[1].at <= target && (!next || entry[1].at < next[1].at)) next = entry;
      }
      if (!next) break;
      timers.delete(next[0]);
      nowMs = Math.max(nowMs, next[1].at);
      next[1].fn();
      await flush();
    }
    nowMs = target;
    await flush();
  }

  return { relay, limits, events, at };
}

type Harness = ReturnType<typeof createHarness>;

function track<T>(promise: Promise<T>) {
  const state: { settled: boolean; value?: T; rejected: boolean } = { settled: false, rejected: false };
  promise.then(
    (value) => {
      state.settled = true;
      state.value = value;
    },
    () => {
      state.settled = true;
      state.rejected = true;
    }
  );
  return state;
}

const signal = () => new AbortController().signal;
const jstAt = (t: number) => toJstIso(new Date(BASE + t * 1000));
const sha = (bytes: Uint8Array) => createHash("sha256").update(bytes).digest("hex");
const filled = (length: number, value: number) => new Uint8Array(length).fill(value);

function concat(chunks: readonly Uint8Array[]): Uint8Array {
  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
  let offset = 0;
  for (const c of chunks) {
    out.set(c, offset);
    offset += c.length;
  }
  return out;
}

async function expectErrored(reader: ReadableStreamDefaultReader<Uint8Array>): Promise<void> {
  const outcome = await reader.read().then(
    () => "resolved",
    () => "rejected"
  );
  expect(outcome).toBe("rejected");
}

const LIST_RESULT = {
  types: [{ key: "app", label: "アプリ" }],
  items: [
    { file_id: "f1", name: "app_20261019_1100.log", type: "app", size_bytes: 1000, modified_at: "2026-10-19T11:00:00+09:00" },
  ],
  truncated: false,
} satisfies DsAgentListResult;

// ── 段取り ──

/** poll を待たせた状態で createExport し、export の指示を受けて prepared を返す */
async function prepareExport(
  h: Harness,
  prepared: { total_bytes: number; sha256: string; file_count: number },
  serial = "DS-002",
  fileIds: string[] = ["f1", "f2"]
) {
  const poll = h.relay.poll(serial, "1.0.0", 25, signal());
  const created = h.relay.createExport(serial, fileIds, signal());
  const command = await poll;
  if (!command || command.kind !== "export") throw new Error("export の指示が来ない");
  expect(h.relay.submitPrepared(serial, command.command_id, prepared)).toBe("ok");
  const result = await created;
  if (result.kind !== "prepared") throw new Error(`prepared にならない: ${result.kind}`);
  return { exportCommandId: command.command_id, exportId: result.exportId, result };
}

/** claim して send の指示を受け取る */
async function startSend(h: Harness, exportId: string, claimSignal: AbortSignal = signal(), serial = "DS-002") {
  const poll = h.relay.poll(serial, "1.0.0", 25, signal());
  const claim = h.relay.claimExport(serial, exportId, claimSignal);
  const sendCommand = await poll;
  if (!sendCommand || sendCommand.kind !== "send") throw new Error("send の指示が来ない");
  return { claim, sendCommand };
}

/** 3チャンク（16・16・4 バイト）＝ 4MB・4MB・1MB の縮小版 */
const CHUNKS = [filled(SMALL_CHUNK, 1), filled(SMALL_CHUNK, 2), filled(4, 3)];
const PAYLOAD = concat(CHUNKS);

/** 送信を始め、seq 0 を流してストリームを受け取る（seq 0 の pushChunk はまだ保留のまま返す） */
async function startStream(
  h: Harness,
  opts: { chunks?: Uint8Array[]; prepared?: { total_bytes: number; sha256: string }; claimSignal?: AbortSignal } = {}
) {
  const chunks = opts.chunks ?? CHUNKS;
  const payload = concat(chunks);
  const preparedBody = opts.prepared ?? { total_bytes: payload.length, sha256: sha(payload) };
  const { exportCommandId, exportId } = await prepareExport(h, { ...preparedBody, file_count: 2 });
  const { claim, sendCommand } = await startSend(h, exportId, opts.claimSignal);
  const push0 = h.relay.pushChunk("DS-002", exportCommandId, 0, chunks[0], sha(chunks[0]));
  const claimed = await claim;
  if (claimed.kind !== "stream") throw new Error(`stream にならない: ${claimed.kind}`);
  const reader = claimed.body.getReader();
  return { exportCommandId, exportId, sendCommand, push0, claimed, reader, payload };
}

/** startStream の後、seq 0 を読んで pushChunk の 204 を受け取る */
async function startStreamAndReadFirst(h: Harness, opts: Parameters<typeof startStream>[1] = {}) {
  const s = await startStream(h, opts);
  const first = await s.reader.read();
  await expect(s.push0).resolves.toBe("ok");
  return { ...s, first };
}

async function expectExportAccepted(h: Harness, serial = "DS-002") {
  const poll = h.relay.poll(serial, "1.0.0", 25, signal());
  const created = track(h.relay.createExport(serial, ["f9"], signal()));
  const command = await poll;
  expect(command?.kind).toBe("export");
  expect(created.settled).toBe(false);
}

// ── 一覧・接続 ──

describe("relay — 一覧と接続（表5 R1〜R9・R37〜R39・R41）", () => {
  it("R1 poll が即座に list を受け、submitListResult で一覧が返る", async () => {
    const h = createHarness();
    const poll = track(h.relay.poll("DS-002", "1.0.0", 25, signal()));
    await h.at(1);
    const list = h.relay.requestList("DS-002");
    await flush();
    expect(poll.settled).toBe(true);
    expect(poll.value).toEqual({ command_id: expect.any(String), kind: "list", params: {} });
    await h.at(2);
    expect(h.relay.submitListResult("DS-002", poll.value!.command_id, LIST_RESULT)).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "ok", result: LIST_RESULT });
  });

  it("R2 結果が来なければ t=16（依頼から LIST_TIMEOUT_SEC）で timeout。t=15.999 ではまだ待っている", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    await h.at(1);
    const list = track(h.relay.requestList("DS-002"));
    await poll;
    await h.at(1 + LIST_TIMEOUT_SEC - 0.001);
    expect(list.settled).toBe(false);
    await h.at(1 + LIST_TIMEOUT_SEC);
    expect(list.value).toEqual({ kind: "timeout" });
  });

  it("R3 timeout の後の submitListResult は gone", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    await h.at(1);
    const list = h.relay.requestList("DS-002");
    const command = await poll;
    await h.at(1 + LIST_TIMEOUT_SEC);
    await expect(list).resolves.toEqual({ kind: "timeout" });
    await h.at(17);
    expect(h.relay.submitListResult("DS-002", command!.command_id, LIST_RESULT)).toBe("gone");
  });

  it("R4 poll が t=25 に null で返った後、t=85 は接続中・t=85.001 は未接続（409）", async () => {
    const h = createHarness();
    const poll = track(h.relay.poll("DS-002", "1.0.0", 25, signal()));
    await h.at(25);
    expect(poll.settled).toBe(true);
    expect(poll.value).toBeNull();

    await h.at(25 + AGENT_OFFLINE_AFTER_SEC);
    expect(h.relay.agentStatus("DS-002")).toEqual({
      connected: true,
      last_seen_at: jstAt(25),
      agent_version: "1.0.0",
    });
    await h.at(25 + AGENT_OFFLINE_AFTER_SEC + 0.001);
    expect(h.relay.agentStatus("DS-002")).toEqual({
      connected: false,
      last_seen_at: jstAt(25),
      agent_version: "1.0.0",
    });
    await expect(h.relay.requestList("DS-002")).resolves.toEqual({ kind: "offline" });
  });

  it("R5 一度もリクエストしていない制御盤は未接続", async () => {
    const h = createHarness();
    expect(h.relay.agentStatus("DS-002")).toEqual({ connected: false, last_seen_at: null, agent_version: null });
    await expect(h.relay.requestList("DS-002")).resolves.toEqual({ kind: "offline" });
  });

  it("R6 poll が待っている間は、last_seen_at が未接続の閾値より前でも接続中", async () => {
    const h = createHarness({ offlineAfterSec: 10 });
    h.relay.poll("DS-002", "1.0.0", 25, signal());
    await h.at(20);
    expect(h.relay.agentStatus("DS-002")).toEqual({
      connected: true,
      last_seen_at: jstAt(0),
      agent_version: "1.0.0",
    });
  });

  it("R7 ポーリングが途切れても touch（チャンク等の POST）で last_seen_at が進む（D19）", async () => {
    const h = createHarness();
    h.relay.poll("DS-002", "1.0.0", 25, signal());
    await h.at(25);
    await h.at(80);
    h.relay.touch("DS-002", null);
    expect(h.relay.agentStatus("DS-002").last_seen_at).toBe(jstAt(80));
    await h.at(80 + AGENT_OFFLINE_AFTER_SEC);
    expect(h.relay.agentStatus("DS-002").connected).toBe(true);
    await h.at(80 + AGENT_OFFLINE_AFTER_SEC + 0.001);
    expect(h.relay.agentStatus("DS-002").connected).toBe(false);
  });

  it.each(["0", "26", "abc"])("R8 wait=%s → 422 validation_failed（ルートの検証。段階3-3 V10）", (value) => {
    const parsed = parseAgentPollWait(value);
    expect(parsed.ok).toBe(false);
    if (!parsed.ok) {
      expect(parsed.status).toBe(422);
      expect(parsed.error.error.code).toBe("validation_failed");
    }
  });

  it("R9 同じ制御盤の2本目の poll は、1本目を即座に null にして自分が待つ", async () => {
    const h = createHarness();
    const first = track(h.relay.poll("DS-002", "1.0.0", 25, signal()));
    const second = track(h.relay.poll("DS-002", "1.0.0", 25, signal()));
    await flush();
    expect(first.settled).toBe(true);
    expect(first.value).toBeNull();
    expect(second.settled).toBe(false);

    h.relay.requestList("DS-002");
    await flush();
    expect(second.value).toMatchObject({ kind: "list" });
  });

  it("R37 待ち行列に PENDING_COMMANDS_PER_DEVICE 件あれば requestList / createExport は busy（429 agent_busy）", async () => {
    const h = createHarness();
    h.relay.touch("DS-002", null);
    for (let i = 0; i < PENDING_COMMANDS_PER_DEVICE; i++) {
      track(h.relay.requestList("DS-002"));
    }
    await flush();
    await expect(h.relay.requestList("DS-002")).resolves.toEqual({ kind: "busy" });
    await expect(h.relay.createExport("DS-002", ["f1"], signal())).resolves.toEqual({
      kind: "busy",
      code: "agent_busy",
    });
  });

  it("R38 一覧の結果の truncated: true はそのままブラウザへ", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const list = h.relay.requestList("DS-002");
    const command = await poll;
    const truncated = { ...LIST_RESULT, truncated: true };
    expect(h.relay.submitListResult("DS-002", command!.command_id, truncated)).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "ok", result: truncated });
  });

  it("一覧の結果が { error } なら agent_error（agent_code は制御盤の code。段階7-2 W9）", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const list = h.relay.requestList("DS-002");
    const command = await poll;
    expect(
      h.relay.submitListResult("DS-002", command!.command_id, { error: { code: "io_error", message: "m" } })
    ).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "agent_error", code: "io_error" });
  });

  it("R39 connected / disconnected は状態が変わったときだけ1回（リクエストのたびには出さない）", async () => {
    const h = createHarness();
    const connected = () => h.events.filter((e) => e.event === "ds_agent.connected");
    const disconnected = () => h.events.filter((e) => e.event === "ds_agent.disconnected");

    h.relay.poll("DS-002", "1.0.0", 25, signal());
    await h.at(5);
    h.relay.touch("DS-002", null);
    await h.at(10);
    h.relay.touch("DS-002", null);
    await h.at(25);
    expect(connected()).toHaveLength(1);
    expect(connected()[0]).toMatchObject({ serial_number: "DS-002" });
    expect(disconnected()).toHaveLength(0);

    await h.at(25 + AGENT_OFFLINE_AFTER_SEC + 1);
    expect(disconnected()).toHaveLength(1);
    expect(disconnected()[0]).toMatchObject({ serial_number: "DS-002" });
    expect(connected()).toHaveLength(1);
  });

  it.each(["準備中", "流れ中"])("R41 エクスポートの%sでも requestList は待ち行列に入り、一覧が返る（D25 ③）", async (state) => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    if (state === "準備中") {
      const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
      track(h.relay.createExport("DS-002", ["f1"], signal()));
      await poll;
    } else {
      await startStreamAndReadFirst(h);
    }
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const list = h.relay.requestList("DS-002");
    const command = await poll;
    expect(command).toMatchObject({ kind: "list" });
    expect(h.relay.submitListResult("DS-002", command!.command_id, LIST_RESULT)).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "ok", result: LIST_RESULT });
  });
});

// ── エクスポートの準備 ──

describe("relay — エクスポートの準備（表5 R10〜R13）", () => {
  it("R10 export の指示が渡り、prepared で createExport が prepared（201）になる", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const created = h.relay.createExport("DS-002", ["f1", "f2"], signal());
    const command = await poll;
    expect(command).toEqual({
      command_id: expect.any(String),
      kind: "export",
      params: { file_ids: ["f1", "f2"], max_bytes: EXPORT_MAX_BYTES, chunk_bytes: CHUNK_MAX_BYTES },
    });
    await h.at(10);
    expect(
      h.relay.submitPrepared("DS-002", command!.command_id, { total_bytes: 9437184, sha256: "a".repeat(64), file_count: 2 })
    ).toBe("ok");
    await expect(created).resolves.toEqual({
      kind: "prepared",
      exportId: expect.any(String),
      totalBytes: 9437184,
      fileCount: 2,
      expiresInSec: EXPORT_CLAIM_TIMEOUT_SEC,
    });
  });

  it("R11 prepared が来なければ t=50 はまだ待ち、t=50.001 で timeout。その後の prepared は gone", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const created = track(h.relay.createExport("DS-002", ["f1"], signal()));
    const command = await poll;
    await h.at(EXPORT_PREPARE_TIMEOUT_SEC);
    expect(created.settled).toBe(false);
    await h.at(EXPORT_PREPARE_TIMEOUT_SEC + 0.001);
    expect(created.value).toEqual({ kind: "timeout" });
    expect(
      h.relay.submitPrepared("DS-002", command!.command_id, { total_bytes: 1, sha256: "a".repeat(64), file_count: 1 })
    ).toBe("gone");
  });

  it.each(["too_large", "file_not_allowed", "file_not_found", "io_error"])(
    "R12 準備中に fail { code: %s } → createExport が agent_error",
    async (code) => {
      const h = createHarness();
      const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
      const created = h.relay.createExport("DS-002", ["f1"], signal());
      const command = await poll;
      expect(h.relay.failCommand("DS-002", command!.command_id, code, "失敗しました")).toBe("ok");
      await expect(created).resolves.toEqual({ kind: "agent_error", code });
    }
  );

  it("R13 prepared の total_bytes がちょうど EXPORT_MAX_BYTES なら prepared", async () => {
    const h = createHarness();
    const { result } = await prepareExport(h, { total_bytes: h.limits.exportMaxBytes, sha256: "a".repeat(64), file_count: 1 });
    expect(result.totalBytes).toBe(h.limits.exportMaxBytes);
  });

  it("R13 EXPORT_MAX_BYTES + 1 なら agent_error（too_large）。prepared の応答は ok のまま、エクスポートは失敗（進行中から外れる）", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const created = h.relay.createExport("DS-002", ["f1"], signal());
    const command = await poll;
    expect(
      h.relay.submitPrepared("DS-002", command!.command_id, {
        total_bytes: h.limits.exportMaxBytes + 1,
        sha256: "a".repeat(64),
        file_count: 1,
      })
    ).toBe("ok");
    await expect(created).resolves.toEqual({ kind: "agent_error", code: "too_large" });
    await expectExportAccepted(h);
  });
});

// ── 受け取り（claim）──

describe("relay — 受け取り（表5 R14〜R16・R40）", () => {
  const PREPARED = { total_bytes: 36, sha256: "a".repeat(64), file_count: 2 };

  it("R14 prepared から t=+60 の claim は受理（send の指示が渡る）", async () => {
    const h = createHarness();
    const { exportCommandId, exportId } = await prepareExport(h, PREPARED);
    await h.at(EXPORT_CLAIM_TIMEOUT_SEC);
    const { claim, sendCommand } = await startSend(h, exportId);
    expect(sendCommand).toEqual({
      command_id: expect.any(String),
      kind: "send",
      params: { export_command_id: exportCommandId },
    });
    expect(sendCommand.command_id).not.toBe(exportCommandId);
    expect(track(claim).settled).toBe(false);
  });

  it("R14 prepared から t=+60.001 の claim は not_found（失効）", async () => {
    const h = createHarness();
    const { exportId } = await prepareExport(h, PREPARED);
    await h.at(EXPORT_CLAIM_TIMEOUT_SEC + 0.001);
    await expect(h.relay.claimExport("DS-002", exportId, signal())).resolves.toEqual({ kind: "not_found" });
  });

  it("R15 同じ export_id の2回目の claim は not_found", async () => {
    const h = createHarness();
    const { exportId } = await prepareExport(h, PREPARED);
    await startSend(h, exportId);
    await expect(h.relay.claimExport("DS-002", exportId, signal())).resolves.toEqual({ kind: "not_found" });
  });

  it("R16 パスのシリアルが違う claim は not_found", async () => {
    const h = createHarness();
    const { exportId } = await prepareExport(h, PREPARED);
    await expect(h.relay.claimExport("DS-003", exportId, signal())).resolves.toEqual({ kind: "not_found" });
  });

  it("R40 prepared の後 GET が来ない: t=60 は進行中（429）、t=60.001 で失効して受理・claim は 404・その後の fail / チャンクは 410", async () => {
    const h = createHarness();
    const { exportCommandId, exportId } = await prepareExport(h, PREPARED);

    await h.at(EXPORT_CLAIM_TIMEOUT_SEC);
    h.relay.touch("DS-002", null);
    await expect(h.relay.createExport("DS-002", ["f9"], signal())).resolves.toEqual({
      kind: "busy",
      code: "export_busy",
    });

    await h.at(EXPORT_CLAIM_TIMEOUT_SEC + 0.001);
    await expectExportAccepted(h);
    await expect(h.relay.claimExport("DS-002", exportId, signal())).resolves.toEqual({ kind: "not_found" });
    expect(h.relay.failCommand("DS-002", exportCommandId, "io_error", "m")).toBe("gone");
    const chunk = filled(4, 1);
    // ★pushChunk の戻り値に gone は無い（段階6-1）。cancelled も 410（export_cancelled）に写るので、どちらでも 410 になる★
    expect(["gone", "cancelled"]).toContain(
      await h.relay.pushChunk("DS-002", exportCommandId, 0, chunk, sha(chunk))
    );
  });
});

// ── 送信 ──

describe("relay — 送信（表5 R17〜R32・R42）", () => {
  it("R17 claim → send → seq 0〜2 → complete: seq 0 の到着でストリーム、バイト列が一致し、閉じる", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStream(h);
    expect(s.claimed.totalBytes).toBe(PAYLOAD.length);

    const received: Uint8Array[] = [];
    const r0 = await s.reader.read();
    received.push(r0.value!);
    await expect(s.push0).resolves.toBe("ok");

    for (const seq of [1, 2]) {
      const push = h.relay.pushChunk("DS-002", s.exportCommandId, seq, CHUNKS[seq], sha(CHUNKS[seq]));
      const r = await s.reader.read();
      received.push(r.value!);
      await expect(push).resolves.toBe("ok");
    }

    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length, sha(PAYLOAD))).toBe("ok");
    const end = await s.reader.read();
    expect(end.done).toBe(true);
    expect(concat(received)).toEqual(PAYLOAD);
  });

  it("R18 claim から t=+30 の seq 0 は受理（ストリーム）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const { exportCommandId, exportId } = await prepareExport(h, {
      total_bytes: PAYLOAD.length,
      sha256: sha(PAYLOAD),
      file_count: 2,
    });
    const { claim } = await startSend(h, exportId);
    const claimed = track(claim);
    await h.at(EXPORT_FIRST_CHUNK_TIMEOUT_SEC);
    expect(claimed.settled).toBe(false);
    h.relay.pushChunk("DS-002", exportCommandId, 0, CHUNKS[0], sha(CHUNKS[0]));
    await flush();
    expect(claimed.value).toMatchObject({ kind: "stream", totalBytes: PAYLOAD.length });
  });

  it("R18 seq 0 が来ないまま t=+30.001 で timeout（504）。その後のチャンクは 410", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const { exportCommandId, exportId } = await prepareExport(h, {
      total_bytes: PAYLOAD.length,
      sha256: sha(PAYLOAD),
      file_count: 2,
    });
    const { claim } = await startSend(h, exportId);
    await h.at(EXPORT_FIRST_CHUNK_TIMEOUT_SEC + 0.001);
    await expect(claim).resolves.toEqual({ kind: "timeout" });
    // ★pushChunk の戻り値に gone は無い（段階6-1）。410 は cancelled（export_cancelled）で返す★
    await expect(
      h.relay.pushChunk("DS-002", exportCommandId, 0, CHUNKS[0], sha(CHUNKS[0]))
    ).resolves.toBe("cancelled");
  });

  it.each(["export_not_found", "io_error"])(
    "R19 send の後・最初のチャンクの前に fail { code: %s } → claim が agent_error（D25 ②）",
    async (code) => {
      const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
      const { exportCommandId, exportId } = await prepareExport(h, {
        total_bytes: PAYLOAD.length,
        sha256: sha(PAYLOAD),
        file_count: 2,
      });
      const { claim } = await startSend(h, exportId);
      expect(h.relay.failCommand("DS-002", exportCommandId, code, "zip がありません")).toBe("ok");
      await expect(claim).resolves.toEqual({ kind: "agent_error", code });
    }
  );

  it("R20 prepared の後・send の前のチャンクは out_of_order（409）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const { exportCommandId } = await prepareExport(h, {
      total_bytes: PAYLOAD.length,
      sha256: sha(PAYLOAD),
      file_count: 2,
    });
    await expect(
      h.relay.pushChunk("DS-002", exportCommandId, 0, CHUNKS[0], sha(CHUNKS[0]))
    ).resolves.toBe("out_of_order");
  });

  it("R21 seq 0 の後に seq 2 → out_of_order（409）。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    // ★わざと seq を飛ばす（1 を送らずに 2）★
    await expect(
      h.relay.pushChunk("DS-002", s.exportCommandId, 2, CHUNKS[2], sha(CHUNKS[2]))
    ).resolves.toBe("out_of_order");
    await expectErrored(s.reader);
  });

  it("R22 流し始めた後のハッシュ不一致 → invalid（400 chunk_invalid）。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    // ★わざと違うハッシュ（全部 0）。CHUNKS[1] の SHA-256 がこれになることはない★
    await expect(
      h.relay.pushChunk("DS-002", s.exportCommandId, 1, CHUNKS[1], "0".repeat(64))
    ).resolves.toBe("invalid");
    await expectErrored(s.reader);
  });

  it("R23 最初のチャンクのハッシュ不一致 → チャンクは invalid、claim は agent_error（chunk_invalid）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const { exportCommandId, exportId } = await prepareExport(h, {
      total_bytes: PAYLOAD.length,
      sha256: sha(PAYLOAD),
      file_count: 2,
    });
    const { claim } = await startSend(h, exportId);
    // ★わざと違うハッシュ（全部 0）★
    await expect(
      h.relay.pushChunk("DS-002", exportCommandId, 0, CHUNKS[0], "0".repeat(64))
    ).resolves.toBe("invalid");
    await expect(claim).resolves.toEqual({ kind: "agent_error", code: "chunk_invalid" });
  });

  it("R24 チャンクの長さがちょうど chunkMaxBytes なら受理", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const chunk = filled(h.limits.chunkMaxBytes, 7);
    const s = await startStream(h, { chunks: [chunk] });
    const r = await s.reader.read();
    expect(r.value).toEqual(chunk);
    await expect(s.push0).resolves.toBe("ok");
  });

  it.each<[string, (limits: RelayLimits) => number]>([
    ["chunkMaxBytes + 1", (l) => l.chunkMaxBytes + 1],
    ["0バイト", () => 0],
  ])("R24 チャンクの長さが %s なら invalid（400）", async (_label, lengthOf) => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const chunk = filled(lengthOf(h.limits), 7);
    const total = Math.max(chunk.length, 1);
    const { exportCommandId, exportId } = await prepareExport(h, {
      total_bytes: total,
      sha256: sha(filled(total, 7)),
      file_count: 1,
    });
    const { claim } = await startSend(h, exportId);
    await expect(h.relay.pushChunk("DS-002", exportCommandId, 0, chunk, sha(chunk))).resolves.toBe("invalid");
    await expect(claim).resolves.toMatchObject({ kind: "agent_error" });
  });

  it("R25 受け取った合計が prepared の total_bytes を超えたら invalid。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const intended = filled(20, 1);
    const s = await startStreamAndReadFirst(h, {
      chunks: [filled(SMALL_CHUNK, 1), filled(SMALL_CHUNK, 1)],
      prepared: { total_bytes: intended.length, sha256: sha(intended) },
    });
    const over = filled(SMALL_CHUNK, 1);
    await expect(h.relay.pushChunk("DS-002", s.exportCommandId, 1, over, sha(over))).resolves.toBe("invalid");
    await expectErrored(s.reader);
  });

  /** seq 0〜2 をすべて流し終えた状態にする（complete の前） */
  async function streamAll(h: Harness, prepared?: { total_bytes: number; sha256: string }) {
    const s = await startStreamAndReadFirst(h, { prepared });
    for (const seq of [1, 2]) {
      const push = h.relay.pushChunk("DS-002", s.exportCommandId, seq, CHUNKS[seq], sha(CHUNKS[seq]));
      await s.reader.read();
      await expect(push).resolves.toBe("ok");
    }
    return s;
  }

  it("R26 complete の total_bytes が prepared と違えば invalid。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await streamAll(h);
    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length - 1, sha(PAYLOAD))).toBe("invalid");
    await expectErrored(s.reader);
  });

  it("R26 受け取った合計が total_bytes に足りないまま complete → invalid。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length, sha(PAYLOAD))).toBe("invalid");
    await expectErrored(s.reader);
  });

  it("R27 complete の sha256 が prepared の sha256 と違えば invalid。ストリームを error", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await streamAll(h);
    // ★わざと違うハッシュ（全部 f）。PAYLOAD の SHA-256 がこれになることはない★
    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length, "f".repeat(64))).toBe("invalid");
    await expectErrored(s.reader);
  });

  it("R27 受け取ったバイト列の SHA-256 が prepared の sha256 と違えば invalid（complete は prepared と同じ値でも）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    // ★わざと違うハッシュ（全部 0）を prepared に書く。チャンクごとのハッシュは正しい★
    const wrong = "0".repeat(64);
    const s = await streamAll(h, { total_bytes: PAYLOAD.length, sha256: wrong });
    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length, wrong)).toBe("invalid");
    await expectErrored(s.reader);
  });

  it("R28 流し始めた後の fail（export の指示の command_id）→ fail は ok、ストリームを error（D25 ①②）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    expect(h.relay.failCommand("DS-002", s.exportCommandId, "export_not_found", "zip がありません")).toBe("ok");
    await expectErrored(s.reader);
  });

  it.each(["cancel", "abort"] as const)(
    "R29 流し始めた後にブラウザが切断（%s）→ 次のチャンクは cancelled（410）",
    async (how) => {
      const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
      const controller = new AbortController();
      const s = await startStreamAndReadFirst(h, { claimSignal: controller.signal });
      if (how === "cancel") {
        await s.reader.cancel();
      } else {
        controller.abort();
      }
      await flush();
      await expect(
        h.relay.pushChunk("DS-002", s.exportCommandId, 1, CHUNKS[1], sha(CHUNKS[1]))
      ).resolves.toBe("cancelled");
    }
  );

  it("R30 流量制御: ブラウザが読むまで seq 0 の pushChunk は保留し、reader.read() で解決する", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStream(h);
    const push0 = track(s.push0);
    await flush();
    expect(push0.settled).toBe(false);
    await s.reader.read();
    await flush();
    expect(push0.value).toBe("ok");
  });

  it("R31 保留が t=+45 まではまだ保留、t=+45.001 で cancelled（410）・ストリームを error（D20）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStream(h);
    const push0 = track(s.push0);
    await h.at(EXPORT_IDLE_TIMEOUT_SEC);
    expect(push0.settled).toBe(false);
    await h.at(EXPORT_IDLE_TIMEOUT_SEC + 0.001);
    expect(push0.value).toBe("cancelled");
    await expectErrored(s.reader);
  });

  it("R32 次のチャンクが来ないまま t=+45 は流れたまま、t=+45.001 でストリームを error。その後のチャンクは 410", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    const pending = track(s.reader.read());
    await h.at(EXPORT_IDLE_TIMEOUT_SEC);
    expect(pending.settled).toBe(false);
    await h.at(EXPORT_IDLE_TIMEOUT_SEC + 0.001);
    expect(pending.rejected).toBe(true);
    await expect(
      h.relay.pushChunk("DS-002", s.exportCommandId, 1, CHUNKS[1], sha(CHUNKS[1]))
    ).resolves.toBe("cancelled");
  });

  it("R42 send の指示の command_id にチャンク・complete を送ると not_found（D25 ①）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const { exportId } = await prepareExport(h, { total_bytes: PAYLOAD.length, sha256: sha(PAYLOAD), file_count: 2 });
    const { sendCommand } = await startSend(h, exportId);
    await expect(
      h.relay.pushChunk("DS-002", sendCommand.command_id, 0, CHUNKS[0], sha(CHUNKS[0]))
    ).resolves.toBe("not_found");
    expect(h.relay.completeExport("DS-002", sendCommand.command_id, PAYLOAD.length, sha(PAYLOAD))).toBe("not_found");
  });
});

// ── 同時実行・取り違え ──

describe("relay — 同時実行と取り違え（表5 R33〜R36・R43）", () => {
  const PREPARED = () => ({ total_bytes: PAYLOAD.length, sha256: sha(PAYLOAD), file_count: 2 });

  it.each(["準備中", "受け取り待ち", "送信待ち", "流れ中"] as const)(
    "R33 同じ制御盤で%sに2本目の createExport → busy（429 export_busy）",
    async (state) => {
      const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
      if (state === "準備中") {
        const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
        track(h.relay.createExport("DS-002", ["f1"], signal()));
        await poll;
      } else if (state === "受け取り待ち") {
        await prepareExport(h, PREPARED());
      } else if (state === "送信待ち") {
        const { exportId } = await prepareExport(h, PREPARED());
        await startSend(h, exportId);
      } else {
        await startStreamAndReadFirst(h);
      }
      h.relay.touch("DS-002", null);
      await expect(h.relay.createExport("DS-002", ["f9"], signal())).resolves.toEqual({
        kind: "busy",
        code: "export_busy",
      });
    }
  );

  it("R33 1本目が完了した後は受理", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStreamAndReadFirst(h);
    for (const seq of [1, 2]) {
      const push = h.relay.pushChunk("DS-002", s.exportCommandId, seq, CHUNKS[seq], sha(CHUNKS[seq]));
      await s.reader.read();
      await push;
    }
    expect(h.relay.completeExport("DS-002", s.exportCommandId, PAYLOAD.length, sha(PAYLOAD))).toBe("ok");
    await expectExportAccepted(h);
  });

  it("R33 1本目が失敗した後は受理", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const created = h.relay.createExport("DS-002", ["f1"], signal());
    const command = await poll;
    h.relay.failCommand("DS-002", command!.command_id, "io_error", "m");
    await created;
    await expectExportAccepted(h);
  });

  it("R34 3台で進行中なら4台目は busy（429 export_busy）", async () => {
    const h = createHarness();
    for (const serial of ["DS-002", "DS-003", "DS-004"]) {
      const poll = h.relay.poll(serial, "1.0.0", 25, signal());
      track(h.relay.createExport(serial, ["f1"], signal()));
      await poll;
    }
    h.relay.touch("DS-005", null);
    await expect(h.relay.createExport("DS-005", ["f1"], signal())).resolves.toEqual({
      kind: "busy",
      code: "export_busy",
    });
  });

  it("R35 DS-003 から DS-002 の command_id に result・prepared・チャンク・complete・fail → not_found（403 にしない）", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const pollList = h.relay.poll("DS-002", "1.0.0", 25, signal());
    track(h.relay.requestList("DS-002"));
    const listCommand = await pollList;
    const pollExport = h.relay.poll("DS-002", "1.0.0", 25, signal());
    track(h.relay.createExport("DS-002", ["f1"], signal()));
    const exportCommand = await pollExport;

    expect(h.relay.submitListResult("DS-003", listCommand!.command_id, LIST_RESULT)).toBe("not_found");
    expect(h.relay.submitPrepared("DS-003", exportCommand!.command_id, PREPARED())).toBe("not_found");
    await expect(
      h.relay.pushChunk("DS-003", exportCommand!.command_id, 0, CHUNKS[0], sha(CHUNKS[0]))
    ).resolves.toBe("not_found");
    expect(h.relay.completeExport("DS-003", exportCommand!.command_id, PAYLOAD.length, sha(PAYLOAD))).toBe(
      "not_found"
    );
    expect(h.relay.failCommand("DS-003", exportCommand!.command_id, "io_error", "m")).toBe("not_found");
  });

  it("R36 list の command_id に prepared → not_found", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    track(h.relay.requestList("DS-002"));
    const command = await poll;
    expect(h.relay.submitPrepared("DS-002", command!.command_id, PREPARED())).toBe("not_found");
  });

  it("R43 prepared / complete / fail の形の誤りは 400 result_invalid。状態は変えない（正しい結果を受け取れる）", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const list = h.relay.requestList("DS-002");
    const command = await poll;

    const rejected = [
      parseAgentPrepared(JSON.stringify({ total_bytes: "1", sha256: "a".repeat(64), file_count: 1 })),
      parseAgentComplete(JSON.stringify({ total_bytes: 1 })),
      parseAgentFail(JSON.stringify({ code: 1, message: "m" })),
    ];
    for (const result of rejected) {
      expect(result.ok).toBe(false);
      if (!result.ok) {
        expect(result.status).toBe(400);
        expect(result.error.error.code).toBe("result_invalid");
      }
    }

    // ★prepared・complete・fail の形の誤りは状態を変えない（指示書BJ: 一覧だけ rejectListResult）★
    expect(h.relay.submitListResult("DS-002", command!.command_id, LIST_RESULT)).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "ok", result: LIST_RESULT });
  });

  it("R43′ 一覧の形の誤りは rejectListResult → agent_error（result_invalid）。その後は not_found", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const list = h.relay.requestList("DS-002");
    const command = await poll;

    const bad = parseAgentListResult(JSON.stringify({ types: [], items: [] }));
    expect(bad.ok).toBe(false);
    expect(h.relay.rejectListResult("DS-002", command!.command_id)).toBe("ok");
    await expect(list).resolves.toEqual({ kind: "agent_error", code: "result_invalid" });
    expect(h.relay.submitListResult("DS-002", command!.command_id, LIST_RESULT)).toBe("not_found");
  });

  it("R43‴ export の指示 id への rejectListResult は not_found（エクスポートは続く）", async () => {
    const h = createHarness();
    const poll = h.relay.poll("DS-002", "1.0.0", 25, signal());
    const created = h.relay.createExport("DS-002", ["f1"], signal());
    const command = await poll;
    expect(h.relay.rejectListResult("DS-002", command!.command_id)).toBe("not_found");
    expect(
      h.relay.submitPrepared("DS-002", command!.command_id, {
        total_bytes: 4,
        sha256: sha(filled(4, 1)),
        file_count: 1,
      })
    ).toBe("ok");
    await expect(created).resolves.toMatchObject({ kind: "prepared", totalBytes: 4 });
  });

  it("R50 touch に版を渡すと connected の agent_version が入る", async () => {
    const h = createHarness();
    h.relay.touch("DS-002", "1.2.3");
    const connected = h.events.filter((e) => e.event === "ds_agent.connected");
    expect(connected).toHaveLength(1);
    expect(connected[0]).toMatchObject({ serial_number: "DS-002", agent_version: "1.2.3" });
    expect(h.relay.agentStatus("DS-002").agent_version).toBe("1.2.3");
  });

  it("R51 touch の版が null なら agent_version は null（拒否しない）", async () => {
    const h = createHarness();
    h.relay.touch("DS-002", null);
    const connected = h.events.filter((e) => e.event === "ds_agent.connected");
    expect(connected[0]).toMatchObject({ agent_version: null });
    expect(h.relay.agentStatus("DS-002").agent_version).toBeNull();
  });
});

describe("relay — 流量制御の並列送信（表R R49）", () => {
  it("R49 保留中に次のチャンク → out_of_order。先の POST は cancelled。flow_timeout は出ない", async () => {
    const h = createHarness({ chunkMaxBytes: SMALL_CHUNK });
    const s = await startStream(h);
    const push0 = track(s.push0);
    await flush();
    expect(push0.settled).toBe(false);

    await expect(
      h.relay.pushChunk("DS-002", s.exportCommandId, 1, CHUNKS[1], sha(CHUNKS[1]))
    ).resolves.toBe("out_of_order");
    expect(push0.value).toBe("cancelled");
    await expectErrored(s.reader);

    const failed = h.events.filter((e) => e.event === "ds_logs.export_failed");
    expect(failed).toHaveLength(1);
    expect(failed[0]).toMatchObject({ reason: "chunk_out_of_order", agent_code: "chunk_out_of_order" });

    await h.at(EXPORT_IDLE_TIMEOUT_SEC + 1);
    expect(h.events.filter((e) => e.event === "ds_logs.export_failed" && e.reason === "flow_timeout")).toHaveLength(0);
  });
});