import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";

import {
  classifyRuntimeDurableReadiness,
  classifyWorkbenchLiveStatus
} from "../live-status.mjs";
import { wiringPresentationFromSummary } from "../wiring-status.mjs";

const statusMatrix = JSON.parse(readFileSync(
  new URL("../../../fixtures/cloud-web/durable-readiness-status-matrix.json", import.meta.url),
  "utf8"
));

const okApi = Object.freeze({
  ok: true,
  status: 200,
  data: {
    serviceId: "hwlab-cloud-api",
    status: "ok",
    ready: true,
    readiness: {
      status: "ok",
      ready: true,
      durability: {
        status: "ready",
        ready: true
      }
    },
    runtime: {
      status: "ready",
      durable: true,
      ready: true,
      liveRuntimeEvidence: true
    }
  }
});

const okRest = Object.freeze({
  ok: true,
  status: 200,
  data: {
    serviceId: "hwlab-cloud-api",
    status: "ok",
    ready: true,
    readiness: {
      status: "ok",
      ready: true,
      durability: {
        status: "ready",
        ready: true,
        queryResult: "durable_readiness_ready"
      }
    },
    runtime: {
      adapter: "postgres",
      status: "ready",
      durable: true,
      ready: true,
      liveRuntimeEvidence: true,
      connection: {
        queryResult: "durable_readiness_ready"
      }
    },
    codeAgent: {
      endpoint: "POST /v1/agent/chat",
      status: "available",
      ready: true,
      provider: "openai-responses",
      backend: "hwlab-cloud-api/openai-responses",
      capabilityLevel: "available"
    }
  }
});

const codexStdioRest = Object.freeze({
  ok: true,
  status: 200,
  data: {
    serviceId: "hwlab-cloud-api",
    status: "ok",
    ready: true,
    readiness: {
      status: "ok",
      ready: true,
      durability: {
        status: "ready",
        ready: true,
        queryResult: "durable_readiness_ready"
      }
    },
    runtime: {
      adapter: "postgres",
      status: "ready",
      durable: true,
      ready: true,
      liveRuntimeEvidence: true,
      connection: {
        queryResult: "durable_readiness_ready"
      }
    },
    codeAgent: {
      endpoint: "POST /v1/agent/chat",
      status: "codex-stdio-feasible",
      ready: true,
      provider: "codex-stdio",
      backend: "hwlab-cloud-api/codex-mcp-stdio",
      capabilityLevel: "long-lived-codex-stdio-session",
      agentKind: "codex-stdio-feasible",
      codexStdioFeasibility: {
        canStartLongLivedCodexStdio: true
      },
      longLivedSessionGate: {
        status: "pass",
        pass: true
      }
    }
  }
});

const readonlyOnlyRest = Object.freeze({
  ok: true,
  status: 200,
  data: {
    serviceId: "hwlab-cloud-api",
    status: "degraded",
    ready: false,
    readiness: {
      status: "ok",
      ready: true,
      durability: {
        status: "ready",
        ready: true,
        queryResult: "durable_readiness_ready"
      }
    },
    runtime: {
      adapter: "postgres",
      status: "ready",
      durable: true,
      ready: true,
      liveRuntimeEvidence: true,
      connection: {
        queryResult: "durable_readiness_ready"
      }
    },
    codeAgent: {
      endpoint: "POST /v1/agent/chat",
      status: "partial",
      ready: false,
      partialReady: true,
      agentKind: "controlled-readonly-session-registry",
      provider: "openai-responses",
      backend: "hwlab-cloud-api/openai-responses",
      capabilityLevel: "read-only-session-tools",
      runner: {
        kind: "hwlab-readonly-runner",
        ready: true,
        writeCapable: false
      },
      blockerCodes: ["codex_stdio_supervisor_disabled", "provider_token_boundary"],
      codexStdioFeasibility: {
        status: "blocked",
        blockers: [{ code: "codex_stdio_supervisor_disabled" }]
      },
      longLivedSessionGate: {
        status: "blocked",
        pass: false
      }
    }
  }
});

const okM3Control = Object.freeze({
  ok: true,
  status: 200,
  data: {
    status: "available",
    readiness: {
      status: "ready",
      controlReady: true,
      sourceKind: "DEV-LIVE",
      evidenceLevel: "DEV-LIVE"
    }
  }
});

const okM3Status = Object.freeze({
  ok: true,
  status: 200,
  data: {
    status: "live",
    sourceKind: "DEV-LIVE",
    summary: "M3 硬件状态与可信持久化均为 DEV-LIVE。"
  }
});

test("cloud web live build surface renders Beijing summary, details, missing time, and external images", async () => {
  const { readFileSync } = await import("node:fs");
  const html = readFileSync(new URL("../index.html", import.meta.url), "utf8");
  const app = readFileSync(new URL("../app.mjs", import.meta.url), "utf8");
  const styles = readFileSync(new URL("../styles.css", import.meta.url), "utf8");

  assert.match(html, /id="live-build-summary"/u);
  assert.match(html, /id="live-build-latest"/u);
  assert.match(html, /id="live-build-list"/u);
  assert.match(app, /formatBeijingTime/u);
  assert.match(app, /Asia\/Shanghai/u);
  assert.match(app, /liveBuildSourceLabel/u);
  assert.match(app, /liveBuildDesiredStateText/u);
  assert.match(app, /外部镜像或非 HWLAB 构建产物/u);
  assert.doesNotMatch(app, /artifact report|artifact-report/u);
  assert.match(styles, /\.live-build-summary-label\s*\{[^}]*min-width:\s*0;[^}]*max-width:\s*100%;[^}]*overflow-wrap:\s*anywhere;/su);
  assert.match(styles, /\.live-build-list\s*\{[^}]*min-width:\s*0;[^}]*max-height:\s*min\(352px,\s*calc\(58dvh - 54px\)\);[^}]*overflow:\s*auto;/su);
  assert.match(styles, /@media \(max-width: 860px\)[\s\S]*?\.live-build-row-head\s*\{[\s\S]*?grid-template-columns:\s*1fr;/u);
});

test("classifies fully ready workbench runtime as API 正常", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: codexStdioRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "pass");
  assert.equal(status.label, "API 正常");
  assert.match(status.detail, /hwlab-cloud-api \/health\/live/u);
  assert.equal(status.internalRawStatuses.includes("degraded"), false);
});

test("classifies controlled readonly Code Agent as read-only, not full pass", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: readonlyOnlyRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "readonly");
  assert.equal(status.label, "只读模式");
  assert.equal(status.reasonCode, "codex_stdio_blocked_readonly_session_available");
  assert.match(status.detail, /controlled-readonly-session-registry/u);
});

test("structured readiness shows current codex stdio blocker instead of stale provider or DB blockers", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        ready: false,
        readiness: {
          status: "degraded",
          ready: false,
          durability: {
            status: "ready",
            ready: true,
            queryResult: "durable_readiness_ready"
          },
          codeAgent: {
            status: "blocked",
            ready: false,
            providerReady: true,
            durableDbReady: true,
            sessionRunnerReady: true,
            codexStdioFeasible: false,
            currentBlocker: "codex_stdio_supervisor_disabled",
            currentBlockers: ["codex_stdio_supervisor_disabled"],
            provider: {
              status: "ready",
              ready: true,
              provider: "openai-responses",
              backend: "hwlab-cloud-api/openai-responses",
              mode: "openai",
              blocker: null
            },
            sessionRunner: {
              status: "read_only_long_lived_ready",
              ready: true,
              kind: "hwlab-readonly-runner",
              mode: "controlled-readonly-session-registry",
              capabilityLevel: "read-only-session-tools"
            },
            codexStdio: {
              status: "blocked",
              ready: false,
              blocker: "codex_stdio_supervisor_disabled",
              blockerCodes: ["codex_stdio_supervisor_disabled"]
            }
          }
        },
        runtime: {
          adapter: "postgres",
          status: "ready",
          durable: true,
          ready: true,
          liveRuntimeEvidence: true,
          connection: {
            queryResult: "durable_readiness_ready"
          }
        },
        codeAgent: {
          status: "partial",
          ready: false,
          provider: "openai-responses",
          backend: "hwlab-cloud-api/openai-responses",
          capabilityLevel: "read-only-session-tools",
          blockerCodes: [
            "provider_unavailable",
            "runtime_durable_adapter_auth_blocked"
          ]
        }
      }
    },
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "readonly");
  assert.equal(status.reasonCode, "codex_stdio_supervisor_disabled");
  assert.match(status.detail, /providerReady=true/u);
  assert.match(status.detail, /durableDbReady=true/u);
  assert.doesNotMatch(status.detail, /provider_unavailable|runtime_durable_adapter_auth_blocked/u);
});

test("structured readiness missing legacy codeAgent payload degrades with concrete current blocker", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        ready: false,
        readiness: {
          status: "degraded",
          ready: false,
          durability: {
            status: "ready",
            ready: true
          },
          codeAgent: {
            status: "blocked",
            ready: false,
            providerReady: false,
            durableDbReady: true,
            sessionRunnerReady: false,
            codexStdioFeasible: false,
            currentBlocker: "provider_config_blocked",
            currentBlockers: ["provider_config_blocked"],
            provider: {
              status: "blocked",
              ready: false,
              provider: "openai-responses",
              backend: "hwlab-cloud-api/openai-responses",
              mode: "openai",
              blocker: "provider_config_blocked"
            },
            sessionRunner: {
              status: "blocked",
              ready: false,
              kind: "unknown",
              capabilityLevel: "blocked"
            },
            codexStdio: {
              status: "blocked",
              ready: false,
              blocker: "codex_stdio_supervisor_disabled",
              blockerCodes: ["codex_stdio_supervisor_disabled"]
            }
          }
        },
        runtime: {
          adapter: "postgres",
          durable: true,
          ready: true,
          liveRuntimeEvidence: true
        }
      }
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "error");
  assert.equal(status.reasonCode, "provider_config_blocked");
  assert.match(status.detail, /providerReady=false/u);
});

test("classifies concrete API failure with service path and HTTP status", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: false,
      path: "/health/live",
      status: 503,
      error: "/health/live HTTP 503：runtime unavailable"
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "error");
  assert.equal(status.label, "API 错误");
  assert.equal(status.serviceId, "hwlab-cloud-api");
  assert.equal(status.apiPath, "/health/live");
  assert.equal(status.reasonCode, "HTTP 503");
  assert.match(status.detail, /错误：hwlab-cloud-api \/health\/live \/ HTTP 503/u);
});

test("classifies durable runtime degraded as explicit read-only mode", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        ready: false,
        runtime: {
          durable: true,
          ready: false,
          liveRuntimeEvidence: false,
          status: "blocked",
          blocker: "runtime_durable_adapter_schema_blocked",
          connection: {
            queryResult: "schema_blocked"
          }
        },
        readiness: {
          status: "degraded",
          ready: false,
          durability: {
            status: "blocked",
            ready: false,
            blocker: "runtime_durable_adapter_schema_blocked",
            blockedLayer: "schema",
            queryResult: "schema_blocked"
          }
        },
        blockerCodes: ["runtime_durable_adapter_schema_blocked"]
      }
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "readonly");
  assert.equal(status.label, "只读模式");
  assert.equal(status.reasonCode, "runtime_durable_adapter_schema_blocked");
  assert.match(status.detail, /只读：hwlab-cloud-api \/health\/live/u);
  assert.match(status.detail, /runtime_durable_adapter_schema_blocked/u);
  assert.match(status.detail, /schema_blocked/u);
  assert.deepEqual(status.internalRawStatuses.filter((item) => item === "degraded"), ["degraded"]);
});

test("does not classify ready queryResult durable runtime as blocked", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "ready",
        ready: true,
        runtime: {
          adapter: "postgres",
          durable: true,
          ready: true,
          liveRuntimeEvidence: true,
          status: "ready",
          blocker: null,
          connection: {
            queryResult: "durable_readiness_ready"
          }
        },
        readiness: {
          status: "ready",
          ready: true,
          durability: {
            status: "ready",
            ready: true,
            blocker: null,
            blockedLayer: null,
            queryResult: "durable_readiness_ready"
          }
        },
        blockerCodes: []
      }
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "pass");
  assert.equal(status.reasonCode, "ready");
  assert.equal(status.probes.find((probe) => probe.apiPath === "/health/live")?.reasonCode, "ready");
});

test("classifies auth and migration durable blockers with shared runtime reason", () => {
  for (const [reasonCode, queryResult, blockedLayer] of [
    ["runtime_durable_adapter_auth_blocked", "auth_blocked", "auth"],
    ["runtime_durable_adapter_migration_blocked", "migration_blocked", "migration"]
  ]) {
    const status = classifyWorkbenchLiveStatus({
      healthLive: {
        ok: true,
        status: 200,
        data: {
          serviceId: "hwlab-cloud-api",
          status: "degraded",
          ready: false,
          runtime: {
            adapter: "postgres",
            durable: false,
            durableRequested: true,
            ready: false,
            liveRuntimeEvidence: false,
            status: "blocked",
            blocker: reasonCode,
            connection: { queryResult },
            durabilityContract: { blockedLayer },
            gates: {
              [blockedLayer]: {
                checked: true,
                ready: false,
                status: "blocked",
                blocker: reasonCode
              }
            }
          },
          readiness: {
            ready: false,
            status: "blocked",
            durability: {
              ready: false,
              status: "blocked",
              blocker: reasonCode,
              blockedLayer,
              queryResult
            }
          },
          blockerCodes: [reasonCode]
        }
      },
      restIndex: okRest,
      health: okApi,
      adapter: okApi,
      m3Control: okM3Control,
      m3Status: okM3Status
    });

    assert.equal(status.kind, "readonly");
    assert.equal(status.reasonCode, reasonCode);
    assert.match(status.detail, new RegExp(reasonCode, "u"));
    assert.match(status.detail, new RegExp(queryResult, "u"));
  }
});

test("classifies missing probes as unverified instead of degraded", () => {
  const status = classifyWorkbenchLiveStatus({});

  assert.equal(status.kind, "unverified");
  assert.equal(status.label, "等待验证");
  assert.match(status.detail, /等待验证/u);
  assert.doesNotMatch(`${status.label} ${status.detail}`, /降级/u);
});

test("classifies memory or non-durable runtime as read-only with explicit reason", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: okRest,
    health: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        runtime: {
          adapter: "memory",
          durable: false
        }
      }
    },
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "readonly");
  assert.equal(status.label, "只读模式");
  assert.equal(status.reasonCode, "runtime_durable_false");
  assert.match(status.detail, /runtime durable=false/u);
});

test("classifies raw degraded without durable/read-only reason as API error", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        ready: false,
        traceId: "trc_degraded_without_attribution"
      }
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "error");
  assert.equal(status.label, "API 错误");
  assert.equal(status.reasonCode, "ready_false_without_blocker");
  assert.match(status.detail, /API readiness is not pass and no concrete blocker was provided/u);
  assert.match(status.detail, /trace=trc_degraded_without_attribution/u);
  assert.equal(status.internalRawStatuses.includes("degraded"), true);
  assert.doesNotMatch(`${status.label} ${status.detail}`, /API 降级/u);
  assert.doesNotMatch(`${status.label} ${status.detail}`, /API returned degraded/u);
});

test("classifies Code Agent provider timeout or fallback with concrete attribution", () => {
  const providerTimeout = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "ok",
        ready: true,
        codeAgent: {
          endpoint: "POST /v1/agent/chat",
          status: "blocked",
          ready: false,
          provider: "openai-responses",
          backend: "hwlab-cloud-api/openai-responses",
          traceId: "trc_provider_timeout",
          error: {
            providerStatus: 504
          },
          summary: "/v1/agent/chat timeout"
        }
      }
    },
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });
  assert.equal(providerTimeout.kind, "error");
  assert.equal(providerTimeout.apiPath, "POST /v1/agent/chat");
  assert.equal(providerTimeout.reasonCode, "provider_http_504");
  assert.match(providerTimeout.detail, /hwlab-cloud-api POST \/v1\/agent\/chat/u);
  assert.match(providerTimeout.detail, /trace=trc_provider_timeout/u);

  const fallback = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "ok",
        ready: true,
        codeAgent: {
          endpoint: "POST /v1/agent/chat",
          status: "available",
          ready: true,
          provider: "openai-responses",
          backend: "hwlab-cloud-api/openai-responses",
          capabilityLevel: "text-chat-only",
          runner: {
            kind: "openai-responses-fallback"
          }
        }
      }
    },
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });
  assert.equal(fallback.kind, "readonly");
  assert.equal(fallback.label, "只读模式");
  assert.equal(fallback.reasonCode, "fallback_text_chat_only");
  assert.match(fallback.detail, /capability=text-chat-only/u);
});

test("keeps ready durable runtime green while attributing read-only mode to Code Agent session-tools", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "ok",
        ready: true,
        runtime: {
          status: "ready",
          ready: true,
          durable: true,
          liveRuntimeEvidence: true,
          blocker: null,
          connection: {
            queryResult: "durable_readiness_ready"
          }
        },
        readiness: {
          status: "ready",
          ready: true,
          durability: {
            status: "ready",
            ready: true,
            runtimeStatus: "ready",
            blockedLayer: null,
            blocker: null,
            queryResult: "durable_readiness_ready"
          }
        },
        codeAgent: {
          endpoint: "POST /v1/agent/chat",
          status: "available",
          ready: true,
          provider: "codex-readonly-runner",
          backend: "hwlab-cloud-api/controlled-readonly-session-registry",
          capabilityLevel: "read-only-session-tools",
          trackingIssue: "#317",
          runnerLimitations: ["not-codex-stdio", "not-write-capable", "process-local-session-registry"]
        }
      }
    },
    restIndex: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "ok",
        ready: true,
        codeAgent: {
          endpoint: "POST /v1/agent/chat",
          status: "available",
          ready: true,
          provider: "codex-readonly-runner",
          backend: "hwlab-cloud-api/controlled-readonly-session-registry",
          capabilityLevel: "read-only-session-tools",
          trackingIssue: "#317",
          runnerLimitations: ["not-codex-stdio", "not-write-capable", "process-local-session-registry"]
        }
      }
    },
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  assert.equal(status.kind, "readonly");
  assert.equal(status.label, "只读模式");
  assert.equal(status.serviceId, "hwlab-cloud-api");
  assert.equal(status.apiPath, "POST /v1/agent/chat");
  assert.equal(status.reasonCode, "code_agent_read_only_session_tools");
  assert.match(status.detail, /capability=read-only-session-tools/u);
  assert.match(status.detail, /#317 full pass not complete/u);
  assert.doesNotMatch(status.detail, /runtime durable blocked/u);
  assert.doesNotMatch(status.detail, /blocked at durability/u);
  const healthLiveProbe = status.probes.find((probe) => probe.apiPath === "/health/live");
  assert.equal(healthLiveProbe.kind, "pass");
  assert.doesNotMatch(healthLiveProbe.reason, /blocked/u);
});

test("classifies Codex stdio session facts as pass even when unrelated runtime durability is blocked", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: {
      ok: true,
      status: 200,
      data: {
        serviceId: "hwlab-cloud-api",
        status: "degraded",
        ready: false,
        readiness: {
          status: "degraded",
          ready: false,
          durability: {
            status: "blocked",
            ready: false,
            blocker: "runtime_durable_adapter_query_blocked"
          },
          codeAgent: {
            status: "blocked",
            ready: false,
            providerReady: true,
            durableDbReady: false,
            sessionRunnerReady: true,
            codexStdioFeasible: true,
            currentBlocker: "runtime_durable_adapter_query_blocked",
            currentBlockers: ["runtime_durable_adapter_query_blocked"],
            provider: {
              status: "ready",
              ready: true,
              provider: "codex-stdio",
              backend: "hwlab-cloud-api/codex-mcp-stdio",
              mode: "codex-stdio"
            },
            sessionRunner: {
              status: "codex_stdio_ready",
              ready: true,
              kind: "codex-mcp-stdio-runner",
              mode: "codex-mcp-stdio-long-lived",
              capabilityLevel: "long-lived-codex-stdio-session",
              longLivedSession: true,
              durableSession: true,
              codexStdio: true,
              writeCapable: true,
              blocker: null
            },
            codexStdio: {
              status: "ready",
              ready: true,
              feasible: true,
              blocker: null,
              blockerCodes: []
            },
            secretMaterialRead: false,
            valuesRedacted: true
          }
        },
        codeAgent: {
          endpoint: "POST /v1/agent/chat",
          status: "codex-stdio-feasible",
          ready: true,
          provider: "codex-stdio",
          backend: "hwlab-cloud-api/codex-mcp-stdio",
          capabilityLevel: "long-lived-codex-stdio-session",
          sessionMode: "codex-mcp-stdio-long-lived",
          workspace: "/workspace/hwlab",
          sandbox: "workspace-write",
          runner: {
            kind: "codex-mcp-stdio-runner",
            sessionMode: "codex-mcp-stdio-long-lived",
            codexStdio: true,
            writeCapable: true,
            durableSession: true
          },
          runnerLimitations: [
            "hardware-control-via-cloud-api-only",
            "no-direct-gateway-link",
            "no-direct-box-simu-link",
            "no-direct-patch-panel-link",
            "secret-values-redacted"
          ],
          longLivedSessionGate: {
            status: "pass",
            pass: true
          },
          codexStdioFeasibility: {
            ready: true,
            canStartLongLivedCodexStdio: true,
            commandProbe: { ready: true },
            blockerCodes: []
          }
        },
        runtime: {
          status: "degraded",
          durable: true,
          ready: false,
          blocker: "runtime_durable_adapter_query_blocked"
        }
      }
    },
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });

  const codeAgentProbe = status.probes.find((probe) => probe.apiPath === "POST /v1/agent/chat");
  assert.equal(codeAgentProbe.kind, "pass");
  assert.equal(codeAgentProbe.reasonCode, "codex_stdio_ready");
  assert.match(codeAgentProbe.reason, /capability=long-lived-codex-stdio-session/u);
  assert.doesNotMatch(codeAgentProbe.reason, /not-codex-stdio|not-write-capable|process-local-session-registry/u);
  assert.notEqual(status.reasonCode, "codex_stdio_blocked_readonly_session_available");
});

test("fixture matrix keeps durable_readiness_ready green and attributes read-only mode to Code Agent", () => {
  const restPayload = {
    serviceId: "hwlab-cloud-api",
    status: "ok",
    ready: true,
    ...statusMatrix.runtime.durableReady,
    codeAgent: statusMatrix.codeAgent.readOnlySessionTools
  };
  const durable = classifyRuntimeDurableReadiness(restPayload);
  const status = classifyWorkbenchLiveStatus({
    healthLive: jsonProbe({
      serviceId: "hwlab-cloud-api",
      status: "ok",
      ready: true,
      ...statusMatrix.runtime.durableReady
    }),
    restIndex: jsonProbe(restPayload),
    health: okApi,
    adapter: okApi,
    m3Control: jsonProbe(statusMatrix.m3.controlReady),
    m3Status: jsonProbe(statusMatrix.m3.trustedGreenSummary)
  });

  assert.equal(durable.ready, true);
  assert.equal(durable.evidence.blocker, null);
  assert.equal(durable.evidence.blockedLayer, null);
  assert.equal(durable.evidence.queryResult, "durable_readiness_ready");
  assert.equal(status.kind, "readonly");
  assert.equal(status.reasonCode, "code_agent_read_only_session_tools");
  assert.equal(status.apiPath, "POST /v1/agent/chat");
  assert.match(status.detail, /#317 full pass not complete/u);
  assert.doesNotMatch(status.detail, /runtime durable blocked|blocked at durability/u);
});

test("fixture matrix preserves runtime durable blocked attribution when durability is actually blocked", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: jsonProbe(statusMatrix.runtime.durableQueryBlocked),
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: okM3Status
  });
  const durable = classifyRuntimeDurableReadiness(statusMatrix.runtime.durableQueryBlocked);

  assert.equal(durable.ready, false);
  assert.equal(durable.reasonCode, "runtime_durable_adapter_query_blocked");
  assert.equal(durable.evidence.blockedLayer, "durability_query");
  assert.equal(status.kind, "readonly");
  assert.equal(status.reasonCode, "runtime_durable_adapter_query_blocked");
  assert.match(status.detail, /runtime_durable_adapter_query_blocked/u);
  assert.match(status.detail, /query_blocked/u);
});

test("fixture matrix keeps auth and schema runtime blockers on their exact layers", () => {
  for (const [name, expectedReason, expectedLayer, expectedQuery] of [
    ["authBlocked", "runtime_durable_adapter_auth_blocked", "auth", "auth_blocked"],
    ["schemaBlocked", "runtime_durable_adapter_schema_blocked", "schema", "schema_blocked"]
  ]) {
    const durable = classifyRuntimeDurableReadiness(statusMatrix.runtime[name]);
    const status = classifyWorkbenchLiveStatus({
      healthLive: jsonProbe(statusMatrix.runtime[name]),
      restIndex: okRest,
      health: okApi,
      adapter: okApi,
      m3Control: okM3Control,
      m3Status: okM3Status
    });

    assert.equal(durable.reasonCode, expectedReason);
    assert.equal(durable.evidence.blockedLayer, expectedLayer);
    assert.equal(durable.evidence.queryResult, expectedQuery);
    assert.equal(status.kind, "readonly");
    assert.equal(status.reasonCode, expectedReason);
    assert.match(status.detail, new RegExp(expectedReason, "u"));
  }
});

test("fixture matrix treats unknown or missing readiness as unverified, not runtime durable blocked", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: jsonProbe(statusMatrix.runtime.unknownMissingReadiness)
  });

  assert.equal(status.kind, "unverified");
  assert.equal(status.label, "等待验证");
  assert.doesNotMatch(`${status.reasonCode} ${status.detail}`, /runtime durable blocked|blocked at durability/u);
});

test("fixture matrix keeps M3 trusted green summary aligned with live status and wiring presentation", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: codexStdioRest,
    health: okApi,
    adapter: okApi,
    m3Control: jsonProbe(statusMatrix.m3.controlReady),
    m3Status: jsonProbe(statusMatrix.m3.trustedGreenSummary)
  });
  const wiring = wiringPresentationFromSummary(statusMatrix.m3.trustedGreenSummary);
  const m3Probe = status.probes.find((probe) => probe.apiPath === "/v1/m3/status");

  assert.equal(status.kind, "pass");
  assert.equal(m3Probe.kind, "pass");
  assert.equal(wiring.m3Live, true);
  assert.equal(wiring.stateLabel, "实况已验证");
  assert.equal(wiring.badgeTone, "dev-live");
});

test("classifies M3 control blockers by cloud-api/gateway/box/patch-panel layer", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: {
      ok: true,
      status: 200,
      data: {
        status: "blocked",
        traceId: "trc_m3_wiring_missing",
        readiness: {
          status: "blocked",
          controlReady: false,
          blocker: {
            code: "m3_wiring_missing",
            layer: "hwlab-patch-panel",
            zh: "hwlab-patch-panel route unavailable"
          }
        }
      }
    },
    m3Status: okM3Status
  });

  assert.equal(status.kind, "error");
  assert.equal(status.serviceId, "hwlab-patch-panel");
  assert.equal(status.apiPath, "/v1/m3/io");
  assert.equal(status.reasonCode, "m3_wiring_missing");
  assert.match(status.detail, /hwlab-patch-panel \/v1\/m3\/io/u);
  assert.match(status.detail, /trace=trc_m3_wiring_missing/u);
});

test("includes trusted M3 evidence identifiers in probe attribution", () => {
  const status = classifyWorkbenchLiveStatus({
    healthLive: okApi,
    restIndex: okRest,
    health: okApi,
    adapter: okApi,
    m3Control: okM3Control,
    m3Status: {
      ok: true,
      status: 200,
      data: {
        status: "live",
        sourceKind: "DEV-LIVE",
        summary: "M3 硬件状态与可信持久化均为 DEV-LIVE。",
        trust: {
          operationId: "op_m3_live",
          traceId: "trc_m3_live",
          auditId: "aud_m3_live",
          evidenceId: "evd_m3_live"
        }
      }
    }
  });

  const m3Probe = status.probes.find((probe) => probe.apiPath === "/v1/m3/status");
  assert.equal(status.kind, "pass");
  assert.match(m3Probe?.evidenceSummary ?? "", /operation=op_m3_live/u);
  assert.match(m3Probe?.evidenceSummary ?? "", /audit=aud_m3_live/u);
  assert.match(m3Probe?.evidenceSummary ?? "", /evidence=evd_m3_live/u);
});

function jsonProbe(data, status = 200) {
  return {
    ok: true,
    status,
    data
  };
}