import { mkdirSync, writeFileSync } from "node:fs";
import path from "node:path";

import {
  parseDeployObservationCliArgs,
  parseGlobalReviewCliArgs,
  parseWorkstreamCloseoutCliArgs,
} from "./core/cli.js";
import { registeredToolNames } from "./core/constants.js";
import { buildBlockerResolution } from "./tools/blocker.js";
import { buildChangeDocSync } from "./tools/docSync.js";
import { resolveInsideRoot } from "./core/workspace.js";
import { hasEntityLoadTimeSerializationMutation } from "./tools/envRisk.js";
import { buildGuardrails } from "./tools/guardrails.js";
import {
  readObsidianContext,
  syncObsidianWorkflow,
  validateObsidianVault,
} from "./tools/obsidian.js";
import {
  cleanupHistoryArtifacts,
  parseCliCleanupArgs,
} from "./tools/cleanup.js";
import { buildWorkflowLoopAudit } from "./tools/loop.js";
import { inspectProject } from "./tools/inspect.js";
import { prepareTask, readWorkflowContext } from "./tools/task.js";
import {
  buildGlobalCodeReview,
  findNapcatImageGovernanceFindings,
  findQqbotNapcatCaptchaFlowFindings,
  findQqbotCommandServiceTestImportFindings,
  findQqbotStatusBoundaryFindings,
  findTaskRecordGovernanceFindings,
  isBenignCredentialReviewValue,
} from "./tools/review.js";
import { buildBusinessTestPlan } from "./tools/testing.js";
import { buildVerificationPlan } from "./tools/verification.js";
import { buildWorkstreamCloseout } from "./tools/closeout.js";
import {
  buildDeployObservation,
  buildDeployObservationSectionMap,
  normalizeDeployObservationEvidence,
} from "./tools/deployObservation.js";
import {
  buildCommitPlan,
  buildComponentWorkflow,
  buildDbSyncPlan,
  buildFinishTask,
  buildPushPlan,
  buildRemoteHealthCheck,
} from "./tools/workflow.js";
export async function runSelfTest(): Promise<void> {
  const reviewClassifier = {
    localizedSecretLabelAllowed: isBenignCredentialReviewValue("密钥"),
    realTokenRejected: !isBenignCredentialReviewValue(
      "eqc2Sbp8ufP2AcS6I2YReLqxnu3XJKC6D7C6PUcx",
    ),
    testTokenAllowed: isBenignCredentialReviewValue("token-test"),
  };
  if (
    !reviewClassifier.localizedSecretLabelAllowed ||
    !reviewClassifier.realTokenRejected ||
    !reviewClassifier.testTokenAllowed
  ) {
    throw new Error("review credential classifier self-check failed");
  }

  const taskRecordFindings = findTaskRecordGovernanceFindings([
    "## 最近记录",
    "### 2026-06-10：长记录污染",
    "- 范围：root",
    "- 关键词：TASKS 治理",
    "- 页面测试用例：配置类任务，无页面测试。",
    "- 验证：global-review",
    "## 历史索引",
  ]);
  if (
    !taskRecordFindings.some(
      (item) => item.category === "tasks-record-extra-field",
    )
  ) {
    throw new Error("TASKS record governance self-check failed");
  }

  const napcatImageFindings = findNapcatImageGovernanceFindings(
    ["QQBOT_NAPCAT_IMAGE=mlikiowa/napcat-docker:latest"],
    {
      file: ".env.example",
      project: "Node/kt-template-online-api",
    },
  );
  if (
    !napcatImageFindings.some((item) => item.category === "napcat-latest-image")
  ) {
    throw new Error("NapCat image governance self-check failed");
  }

  const qqbotCommandServiceImportFindings =
    findQqbotCommandServiceTestImportFindings(
      [
        "import { QqbotCommandService } from '@/qqbot/command/qqbot-command.service';",
      ],
      {
        file: "test/qqbot/command/qqbot-command-cooldown.service.spec.ts",
        project: "Node/kt-template-online-api",
      },
    );
  if (
    !qqbotCommandServiceImportFindings.some(
      (item) => item.category === "qqbot-command-service-heavy-test-import",
    )
  ) {
    throw new Error(
      "QQBot command service test import governance self-check failed",
    );
  }

  const qqbotStatusBoundaryFindings = [
    ...findQqbotStatusBoundaryFindings(
      [
        "async markOnline(",
        "  selfId: string,",
        "  clientRole: QqbotConnectionRole,",
        "  lastError: null | string = null,",
        ") {}",
        "if (account.connectStatus === 'online') return 'online';",
        "return this.toTime(account.lastHeartbeatAt) > checkedAt;",
      ],
      {
        file: "src/qqbot/account/qqbot-account.service.ts",
        project: "Node/kt-template-online-api",
      },
    ),
    ...findQqbotStatusBoundaryFindings(
      [
        "ws.on('close', async () => {",
        "  this.connections.delete(key);",
        "  await this.accountService.markOffline(context.selfId);",
        "});",
      ],
      {
        file: "src/qqbot/connection/qqbot-reverse-ws.service.ts",
        project: "Node/kt-template-online-api",
      },
    ),
  ];
  for (const category of [
    "qqbot-mark-online-clears-login-error",
    "qqbot-connect-status-drives-login-status",
    "qqbot-heartbeat-bypasses-login-check",
    "qqbot-stale-ws-close-marks-offline",
  ]) {
    if (!qqbotStatusBoundaryFindings.some((item) => item.category === category)) {
      throw new Error(`QQBot status boundary self-check failed: ${category}`);
    }
  }

  const qqbotCaptchaFlowFindings = findQqbotNapcatCaptchaFlowFindings(
    [
      "private async resolvePasswordCaptchaUrl(container, loginStatus, sinceMs) {",
      "  return await this.containerService.detectRuntimeCaptchaUrl(container, sinceMs);",
      "  return await this.waitForPasswordCaptchaUrl(container, sinceMs);",
      "}",
      "private async waitForPasswordCaptchaUrl(container, sinceMs) {",
      "  await this.toolsService.sleep(this.getLoginPollIntervalMs());",
      "  return await this.detectPasswordCaptchaUrl(container, sinceMs, true);",
      "}",
      "private async waitForPasswordLoginStatus(container) {",
      "  latestStatus = await this.getLoginStatus(container, true);",
      "}",
      "async status(sessionId) {",
      "  if (session.captchaUrl) {",
      "    return this.failCaptchaLogin(session, container, status.loginError);",
      "  }",
      "}",
      "if (captchaResult?.needNewDevice && captchaResult.jumpUrl) {",
      "  return this.keepSessionPending(session, '请在 NapCat WebUI 继续完成', true);",
      "}",
      "private async tryPasswordRelogin(session, container) {",
      "  await this.containerService.ensureRuntimeLoginEnv(container, { loginPassword: 'x' });",
      "  session.lastRestartedAt = Date.now();",
      "  loginStatus = await this.waitForPasswordLoginStatus(container, session.lastRestartedAt);",
      "  await this.resolvePasswordCaptchaUrl(container, loginStatus, session.lastRestartedAt);",
      "}",
    ],
    {
      file: "src/qqbot/account/qqbot-napcat-login.service.ts",
      project: "Node/kt-template-online-api",
    },
  );
  for (const category of [
    "qqbot-napcat-captcha-error-throws-before-pending",
    "qqbot-napcat-captcha-log-single-read",
    "qqbot-napcat-captcha-status-before-log-url",
    "qqbot-napcat-captcha-status-clears-pending",
    "qqbot-napcat-captcha-log-window-late",
    "qqbot-napcat-new-device-drops-pending",
  ]) {
    if (!qqbotCaptchaFlowFindings.some((item) => item.category === category)) {
      throw new Error(`QQBot captcha flow self-check failed: ${category}`);
    }
  }
  const qqbotCaptchaFlowValidFindings = findQqbotNapcatCaptchaFlowFindings(
    [
      "private async resolvePasswordCaptchaUrl(container, loginStatus, sinceMs) {",
      "  await this.detectPasswordCaptchaUrl(container, sinceMs, false);",
      "  await this.waitForPasswordCaptchaUrl(container, sinceMs);",
      "}",
      "private async waitForPasswordLoginStatus(container, sinceMs) {",
      "  if (this.toolsService.isNapcatCaptchaRequiredMessage(errorMessage)) {",
      "    await this.detectPasswordCaptchaUrl(container, sinceMs);",
      "  }",
      "}",
      "async status(sessionId) {",
      "  if (session.captchaUrl) {",
      "    if (this.isPasswordCaptchaStillRequired(status)) {",
      "      return this.keepPasswordCaptchaPending(session, session.captchaUrl, status.loginError);",
      "    }",
      "  }",
      "}",
      "if (captchaResult?.needNewDevice && captchaResult.jumpUrl) {",
      "  return this.keepDeviceVerifyPending(session, captchaResult.jumpUrl, '验证码已通过');",
      "}",
      "private keepDeviceVerifyPending(session, deviceVerifyUrl) {",
      "  session.deviceVerifyUrl = deviceVerifyUrl;",
      "  session.captchaUrl = undefined;",
      "}",
      "private async detectPasswordCaptchaUrl(container, sinceMs, allowTailFallback = true) {",
      "  await this.containerService.detectRuntimeCaptchaUrl(container, sinceMs);",
      "  await this.containerService.detectRuntimeCaptchaUrl(container);",
      "}",
      "private async waitForPasswordCaptchaUrl(container, sinceMs) {",
      "  const attempts = 5;",
      "  for (let index = 0; index < attempts; index += 1) {",
      "    await this.toolsService.sleep(this.getLoginPollIntervalMs());",
      "    await this.detectPasswordCaptchaUrl(container, sinceMs, true);",
      "  }",
      "}",
      "private async tryPasswordRelogin(session, container) {",
      "  const passwordLogSinceMs = Date.now();",
      "  await this.containerService.ensureRuntimeLoginEnv(container, { loginPassword: 'x' });",
      "  loginStatus = await this.waitForPasswordLoginStatus(container, passwordLogSinceMs);",
      "  await this.resolvePasswordCaptchaUrl(container, loginStatus, passwordLogSinceMs);",
      "}",
    ],
    {
      file: "src/qqbot/account/qqbot-napcat-login.service.ts",
      project: "Node/kt-template-online-api",
    },
  );
  if (
    qqbotCaptchaFlowValidFindings.some(
      (item) =>
        item.category === "qqbot-napcat-captcha-log-window-late" ||
        item.category === "qqbot-napcat-captcha-status-before-log-url" ||
        item.category === "qqbot-napcat-captcha-status-clears-pending",
    )
  ) {
    throw new Error("QQBot captcha flow valid self-check produced false positive");
  }
  const qqbotCaptchaLogTimeoutFindings = findQqbotNapcatCaptchaFlowFindings(
    [
      "async detectRuntimeCaptchaUrl(runtime, sinceMs) {",
      "  const result = await this.runProcess(",
      "    'ssh',",
      "    [...this.getSshArgs(), 'sh -s'],",
      "    script,",
      "    undefined,",
      "    this.getRuntimeCheckTimeoutMs(),",
      "  );",
      "}",
    ],
    {
      file: "src/qqbot/napcat/qqbot-napcat-container.service.ts",
      project: "Node/kt-template-online-api",
    },
  );
  if (
    !qqbotCaptchaLogTimeoutFindings.some(
      (item) => item.category === "qqbot-napcat-captcha-log-timeout-too-short",
    )
  ) {
    throw new Error("QQBot captcha log timeout self-check failed");
  }
  const qqbotCaptchaLogTimeoutValidFindings =
    findQqbotNapcatCaptchaFlowFindings(
      [
        "async detectRuntimeCaptchaUrl(runtime, sinceMs) {",
        "  const result = await this.runProcess(",
        "    'ssh',",
        "    [...this.getSshArgs(), 'sh -s'],",
        "    script,",
        "    undefined,",
        "    this.getCaptchaLogReadTimeoutMs(),",
        "  );",
        "}",
      ],
      {
        file: "src/qqbot/napcat/qqbot-napcat-container.service.ts",
        project: "Node/kt-template-online-api",
      },
    );
  if (qqbotCaptchaLogTimeoutValidFindings.length) {
    throw new Error("QQBot captcha log timeout valid self-check false positive");
  }

  const reviewCliParser = {
    dashedAll: parseGlobalReviewCliArgs([
      "node",
      "server",
      "--global-review",
      "--content-scan-all",
    ]).contentScanMode,
    keyValueAll: parseGlobalReviewCliArgs([
      "node",
      "server",
      "--global-review",
      "--contentScanMode=all",
    ]).contentScanMode,
    splitAll: parseGlobalReviewCliArgs([
      "node",
      "server",
      "--global-review",
      "--content-scan-mode",
      "all",
    ]).contentScanMode,
  };
  if (
    reviewCliParser.dashedAll !== "all" ||
    reviewCliParser.keyValueAll !== "all" ||
    reviewCliParser.splitAll !== "all"
  ) {
    throw new Error(
      "global-review CLI content scan mode parser self-check failed",
    );
  }

  const closeoutCliParser = parseWorkstreamCloseoutCliArgs([
    "node",
    "server",
    "--workstream-closeout",
    "--review",
    "global-review findings=0",
    "--superpowers-review",
    "Superpowers reviewer completed",
  ]);
  if (
    closeoutCliParser.reviewEvidence?.[0] !== "global-review findings=0" ||
    closeoutCliParser.superpowersReviewEvidence?.[0] !==
      "Superpowers reviewer completed"
  ) {
    throw new Error("workstream closeout review CLI parser self-check failed");
  }

  const deployObservationInput = parseDeployObservationCliArgs([
    "node",
    "server",
    "--deploy-observation",
    "--project",
    "api",
    "--job",
    "kt-template-online-api",
    "--build",
    "132",
    "--commit",
    "abc1234",
    "--image-tag",
    "abc1234",
    "--namespace",
    "kt-prod",
    "--deployment",
    "kt-template-online-api",
    "--container",
    "api",
    "--health-url",
    "http://127.0.0.1:48085/health/runtime",
    "--smoke",
    "curl -fsS --max-time 8 http://127.0.0.1:48085/health/runtime",
  ]);
  if (
    deployObservationInput.project !== "api" ||
    deployObservationInput.jobName !== "kt-template-online-api" ||
    deployObservationInput.buildNumber !== "132" ||
    deployObservationInput.expectedCommit !== "abc1234" ||
    deployObservationInput.imageTag !== "abc1234" ||
    deployObservationInput.namespace !== "kt-prod" ||
    deployObservationInput.deployment !== "kt-template-online-api" ||
    deployObservationInput.container !== "api" ||
    deployObservationInput.healthUrl !==
      "http://127.0.0.1:48085/health/runtime" ||
    deployObservationInput.smoke !==
      "curl -fsS --max-time 8 http://127.0.0.1:48085/health/runtime" ||
    deployObservationInput.execute !== false
  ) {
    throw new Error("deploy observation CLI parser self-check failed");
  }

  const buildDeployObservationTestSections = (overrides: {
    desiredReplicas?: number;
    healthStatus?: string;
    jenkinsBuildXml?: string;
    logCommit?: string;
    omitSmoke?: boolean;
    readyReplicas?: number;
    smokeExitCode?: number;
    containerName?: string;
    podContainerName?: string;
    updatedReplicas?: number;
  } = {}) =>
    buildDeployObservationSectionMap([
      "__KT_SECTION:jenkins_meta__",
      "buildNumber=132",
      "result=SUCCESS",
      "__KT_SECTION:jenkins_log_tail__",
      overrides.logCommit === ""
        ? "Finished: SUCCESS"
        : `Checking out Revision ${overrides.logCommit ?? "abc1234"}`,
      "Finished: SUCCESS",
      "__KT_SECTION:jenkins_build_xml__",
      overrides.jenkinsBuildXml ?? "",
      "__KT_SECTION:deployment_json__",
      JSON.stringify({
        metadata: { generation: 12 },
        spec: {
          replicas: overrides.desiredReplicas ?? 1,
          template: {
            spec: {
              containers: [
                {
                  image:
                    "k3d-kt-registry.localhost:5000/kt-template-online-api:abc1234",
                  name: overrides.containerName ?? "api",
                },
              ],
            },
          },
        },
        status: {
          observedGeneration: 12,
          readyReplicas: overrides.readyReplicas ?? 1,
          updatedReplicas: overrides.updatedReplicas ?? 1,
        },
      }),
      "__KT_SECTION:pods_json__",
      JSON.stringify({
        items: [
          {
            metadata: {
              name: "kt-template-online-api-abc",
            },
            spec: {
              containers: [
                {
                  image:
                    "k3d-kt-registry.localhost:5000/kt-template-online-api:abc1234",
                  name: overrides.podContainerName ?? "api",
                },
              ],
            },
            status: {
              containerStatuses: [
                {
                  image:
                    "k3d-kt-registry.localhost:5000/kt-template-online-api:abc1234",
                  name: overrides.podContainerName ?? "api",
                  ready: true,
                  restartCount: 0,
                },
              ],
              phase: "Running",
              startTime: "2026-06-14T00:00:00Z",
            },
          },
        ],
      }),
      "__KT_SECTION:health_json__",
      JSON.stringify({
        checkedAt: "2026-06-14T00:00:01.000Z",
        checks: [
          {
            critical: true,
            message: "NestJS process answered runtime health request",
            name: "process",
            status: "live",
          },
        ],
        service: "kt-template-online-api",
        status: overrides.healthStatus ?? "ready",
      }),
      "__KT_SECTION:smoke_text__",
      overrides.omitSmoke
        ? "no task smoke command provided"
        : '{"service":"kt-template-online-api","status":"ready"}',
      "__KT_SECTION:smoke_status__",
      overrides.omitSmoke ? "exitCode=" : `exitCode=${overrides.smokeExitCode ?? 0}`,
    ].join("\n"));
  const deployObservationSections = buildDeployObservationTestSections();
  const deployObservationEvidence = normalizeDeployObservationEvidence({
    checkedAt: new Date("2026-06-14T00:00:02.000Z"),
    input: deployObservationInput,
    sectionMap: deployObservationSections,
  });
  const deployObservationSmoke = deployObservationEvidence.details.smoke as {
    exitCode?: number | null;
    success?: boolean | null;
  };
  if (
    deployObservationEvidence.status !== "passed" ||
    deployObservationEvidence.details.deployment.image !==
      "k3d-kt-registry.localhost:5000/kt-template-online-api:abc1234" ||
    deployObservationEvidence.details.deployment.observedGeneration !== 12 ||
    deployObservationEvidence.details.pod.name !==
      "kt-template-online-api-abc" ||
    deployObservationEvidence.details.pod.restartCount !== 0 ||
    deployObservationEvidence.details.runtimeHealth.status !== "ready" ||
    deployObservationSmoke.exitCode !== 0 ||
    deployObservationSmoke.success !== true ||
    !deployObservationEvidence.assertions.every((item) => item.passed)
  ) {
    throw new Error("deploy observation evidence normalization self-check failed");
  }

  const deployObservationDegradedHealthEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        healthStatus: "degraded",
      }),
    });
  if (
    deployObservationDegradedHealthEvidence.status !== "passed" ||
    !deployObservationDegradedHealthEvidence.assertions.every(
      (item) => item.passed,
    )
  ) {
    throw new Error("deploy observation degraded health self-check failed");
  }

  const deployObservationBuildXmlCommitEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        jenkinsBuildXml: [
          "<jenkins.scm.api.SCMRevisionAction>",
          "<revision>",
          "<hash>abc1234</hash>",
          "</revision>",
          "</jenkins.scm.api.SCMRevisionAction>",
        ].join("\n"),
        logCommit: "",
      }),
    });
  if (
    deployObservationBuildXmlCommitEvidence.status !== "passed" ||
    deployObservationBuildXmlCommitEvidence.details.jenkins.commitMatched !== true
  ) {
    throw new Error("deploy observation build.xml commit self-check failed");
  }

  const deployObservationFailedSmokeEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        smokeExitCode: 7,
      }),
    });
  const deployObservationFailedSmoke =
    deployObservationFailedSmokeEvidence.details.smoke as {
      exitCode?: number | null;
      success?: boolean | null;
    };
  if (
    deployObservationFailedSmokeEvidence.status === "passed" ||
    deployObservationFailedSmoke.exitCode !== 7 ||
    deployObservationFailedSmoke.success !== false
  ) {
    throw new Error("deploy observation failed smoke self-check failed");
  }

  const deployObservationReplicaLagEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        desiredReplicas: 2,
        readyReplicas: 1,
        updatedReplicas: 2,
      }),
    });
  if (deployObservationReplicaLagEvidence.status === "passed") {
    throw new Error("deploy observation replica lag self-check failed");
  }

  const deployObservationDesiredReplicaLagEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        desiredReplicas: 2,
        readyReplicas: 1,
        updatedReplicas: 1,
      }),
    });
  if (deployObservationDesiredReplicaLagEvidence.status === "passed") {
    throw new Error("deploy observation desired replica lag self-check failed");
  }

  const deployObservationWrongContainerEvidence =
    normalizeDeployObservationEvidence({
      checkedAt: new Date("2026-06-14T00:00:02.000Z"),
      input: deployObservationInput,
      sectionMap: buildDeployObservationTestSections({
        containerName: "sidecar",
        podContainerName: "sidecar",
      }),
    });
  if (deployObservationWrongContainerEvidence.status === "passed") {
    throw new Error("deploy observation wrong container self-check failed");
  }

  const deployObservationNoSmokeEvidence = normalizeDeployObservationEvidence({
    checkedAt: new Date("2026-06-14T00:00:02.000Z"),
    input: { ...deployObservationInput, smoke: undefined },
    sectionMap: buildDeployObservationTestSections({
      omitSmoke: true,
    }),
  });
  const deployObservationNoSmoke = deployObservationNoSmokeEvidence.details
    .smoke as {
    exitCode?: number | null;
    success?: boolean | null;
  };
  if (
    deployObservationNoSmokeEvidence.status === "passed" ||
    deployObservationNoSmoke.exitCode !== null ||
    deployObservationNoSmoke.success !== false
  ) {
    throw new Error("deploy observation no-smoke self-check failed");
  }

  const deployObservationDryRun = await buildDeployObservation({
    deployment: "kt-template-online-api",
    execute: false,
    imageTag: "abc1234",
    jobName: "kt-template-online-api",
    namespace: "kt-prod",
    project: "api",
    smoke: "curl -fsS --max-time 8 http://127.0.0.1:48085/health/runtime",
  });
  const deployObservationCommandText = deployObservationDryRun.commands
    .map((item) => item.command)
    .join("\n");
  if (
    deployObservationDryRun.execute !== false ||
    !deployObservationCommandText.includes("tr -d '\\015' | bash -s") ||
    !deployObservationCommandText.includes("kubectl") ||
    !deployObservationCommandText.includes(
      "http://127.0.0.1:48085/health/runtime",
    ) ||
    !deployObservationCommandText.includes("curl -fsS --max-time 8") ||
    deployObservationDryRun.evidence
  ) {
    throw new Error("deploy observation dry-run self-check failed");
  }
  for (const expected of [
    "KUBECONFIG_ACTIVE",
    "docker port k3d-kt-nas-serverlb 6443/tcp",
    "/tmp/kt-deploy-observation-kubeconfig-$$.yaml",
    "127.0.0.1:${K3D_API_PORT}",
    'rm -f "$KUBECONFIG_TEMP"',
    'kubectl --kubeconfig "$KUBECONFIG_ACTIVE"',
    "section jenkins_build_xml",
  ]) {
    if (!deployObservationCommandText.includes(expected)) {
      throw new Error(`deploy observation kubeconfig self-check failed: ${expected}`);
    }
  }
  if (
    deployObservationCommandText.includes('sed -E "s#.*:([0-9]+)$#') ||
    !deployObservationCommandText.includes("rev | cut -d: -f1 | rev")
  ) {
    throw new Error("deploy observation docker port parser self-check failed");
  }

  const deployObservationDefaultDryRun = await buildDeployObservation({
    deployment: "kt-template-online-api",
    execute: false,
    namespace: "kt-prod",
    project: "api",
  });
  const deployObservationDefaultCommandText =
    deployObservationDefaultDryRun.commands.map((item) => item.command).join("\n");
  if (
    !deployObservationDefaultCommandText.includes(
      "/vol1/docker/jenkins/jenkins_home",
    ) ||
    !deployObservationDefaultCommandText.includes(
      "JOB_NAME='KT-Template/KT-Template-API/main'",
    )
  ) {
    throw new Error("deploy observation Jenkins defaults self-check failed");
  }
  for (const expected of [
    'JOB_DIR="$JENKINS_HOME/jobs/$JOB_NAME/builds"',
    'jobs/$JOB_FOLDER/jobs/$JOB_PIPELINE/branches/$JOB_BRANCH/builds',
    'find "$JENKINS_HOME/jobs"',
  ]) {
    if (!deployObservationDefaultCommandText.includes(expected)) {
      throw new Error(
        `deploy observation Jenkins path self-check failed: ${expected}`,
      );
    }
  }

  const deployObservationExplicitJenkinsDryRun = await buildDeployObservation({
    execute: false,
    jenkinsHome: "/custom/jenkins",
    jobName: "custom-job",
  });
  const deployObservationExplicitJenkinsCommandText =
    deployObservationExplicitJenkinsDryRun.commands
      .map((item) => item.command)
      .join("\n");
  if (
    !deployObservationExplicitJenkinsCommandText.includes(
      "JENKINS_HOME='/custom/jenkins'",
    ) ||
    !deployObservationExplicitJenkinsCommandText.includes("JOB_NAME='custom-job'")
  ) {
    throw new Error("deploy observation explicit Jenkins input self-check failed");
  }

  const deployObservationExplicitHealthDryRun = await buildDeployObservation({
    deployment: "kt-template-online-api",
    execute: false,
    healthUrl: "http://127.0.0.1:30085/health/runtime",
    imageTag: "abc1234",
    jobName: "kt-template-online-api",
    namespace: "kt-prod",
    project: "api",
  });
  const deployObservationExplicitHealthCommandText =
    deployObservationExplicitHealthDryRun.commands
      .map((item) => item.command)
      .join("\n");
  if (
    !deployObservationExplicitHealthCommandText.includes(
      "http://127.0.0.1:30085/health/runtime",
    )
  ) {
    throw new Error("deploy observation explicit health URL self-check failed");
  }

  const deployObservationUnsafeProjectDryRun = await buildDeployObservation({
    deployment: "kt-template-online-api",
    execute: false,
    healthUrl: "http://127.0.0.1:48085/health/runtime",
    imageTag: "abc1234",
    jobName: "kt-template-online-api",
    namespace: "kt-prod",
    project: "../escape",
    smoke: "curl -fsS --max-time 8 http://127.0.0.1:48085/health/runtime",
  });
  if (
    deployObservationUnsafeProjectDryRun.execute !== false ||
    deployObservationUnsafeProjectDryRun.artifactPath ||
    deployObservationUnsafeProjectDryRun.evidence ||
    JSON.stringify(deployObservationUnsafeProjectDryRun.commands).includes(
      "../escape",
    )
  ) {
    throw new Error("deploy observation project dry-run safety self-check failed");
  }

  let unsupportedSmokeRejected = false;
  try {
    await buildDeployObservation({
      execute: false,
      smoke:
        "curl -fsS --max-time 8 http://127.0.0.1:48085/health/runtime; rm -rf /",
    });
  } catch (error) {
    unsupportedSmokeRejected = String(error).includes(
      "Unsupported deploy observation smoke command",
    );
  }
  if (!unsupportedSmokeRejected) {
    throw new Error("deploy observation unsafe smoke self-check failed");
  }

  let unsafeHealthUrlRejected = false;
  try {
    await buildDeployObservation({
      execute: false,
      healthUrl: "http://user:pass@127.0.0.1:48085/health/runtime",
    });
  } catch (error) {
    unsafeHealthUrlRejected = String(error).includes(
      "Unsupported deploy observation healthUrl",
    );
  }
  if (!unsafeHealthUrlRejected) {
    throw new Error("deploy observation unsafe health URL self-check failed");
  }

  let unsafeSshTargetRejected = false;
  try {
    await buildDeployObservation({
      execute: true,
      sshTarget: "root@unexpected-host.example",
    });
  } catch (error) {
    unsafeSshTargetRejected = String(error).includes(
      'Unsafe deploy observation input "sshTarget"',
    );
  }
  if (!unsafeSshTargetRejected) {
    throw new Error("deploy observation unsafe ssh target self-check failed");
  }

  let unsafeInputRejected = false;
  try {
    await buildDeployObservation({
      execute: false,
      jobName: "bad\njob",
    });
  } catch (error) {
    unsafeInputRejected = String(error).includes(
      "Unsafe deploy observation input",
    );
  }
  if (!unsafeInputRejected) {
    throw new Error("deploy observation unsafe input self-check failed");
  }

  const refactorGuardrails = buildGuardrails({
    project: "mcp",
    taskType: "refactor",
    userRequest: "重构 KT 工作流护栏",
  });
  const refactorGuardrailOk =
    refactorGuardrails.guardrails.beforeEdit.some((item) =>
      item.includes("重构前写清楚"),
    ) &&
    refactorGuardrails.guardrails.verification.notes.some((item) =>
      item.includes("重构验证必须覆盖原行为"),
    );
  if (!refactorGuardrailOk) {
    throw new Error("refactor guardrail self-check failed");
  }

  const apiVerification = buildVerificationPlan({
    changeType: "api",
    project: "api",
  });
  const apiVerificationCommands = apiVerification.commands.join("\n");
  if (
    !apiVerificationCommands.includes("pnpm exec jest --runInBand") ||
    apiVerificationCommands.includes("passWithNoTests")
  ) {
    throw new Error("API Jest verification command self-check failed");
  }

  const timeSerializationRisk = {
    bad: hasEntityLoadTimeSerializationMutation(
      "import { AfterLoad } from 'typeorm';\nexport const FormatDateTime = () => {}; formatDateTimeFields(this);",
    ),
    good: hasEntityLoadTimeSerializationMutation(
      "import { Column } from 'typeorm';\nexport class KtDateTime extends Date {}\nexport const KtDateTimeColumn = () => Column({ transformer: { from: (value) => new KtDateTime(value), to: (value) => value } });",
    ),
  };
  if (!timeSerializationRisk.bad || timeSerializationRisk.good) {
    throw new Error("time serialization mutation risk self-check failed");
  }

  const databaseVerification = buildVerificationPlan({
    changeType: "database",
    project: "api",
  });
  const databaseVerificationNotes = databaseVerification.notes.join("\n");
  if (
    !databaseVerificationNotes.includes("备份目标表") ||
    !databaseVerificationNotes.includes("SHOW COLUMNS") ||
    !databaseVerificationNotes.includes("真实接口 smoke")
  ) {
    throw new Error("database migration verification self-check failed");
  }

  const closeoutNeedsUpgrade = buildWorkstreamCloseout({
    cleanupEvidence: ["cleanup-history dry-run deleted=0。"],
    docSyncEvidence: ["kt_change_doc_sync requiredDocs 已处理。"],
    reviewEvidence: ["global-review findings=0。"],
    problemRecords: ["Jenkins 状态需要结合日志和 K8s 状态确认。"],
    reusablePatterns: ["deploy-observation"],
    stableSolutions: [
      "收尾时固定观测 build、commit、镜像、Deployment、Pod 和 smoke。",
    ],
    superpowersReviewEvidence: ["Superpowers reviewer completed; Important findings handled。"],
    title: "发布闭环",
    verificationEvidence: ["Jenkins #132 SUCCESS，K8s Pod Running。"],
  });
  if ((closeoutNeedsUpgrade.canReportComplete as boolean) !== false) {
    throw new Error("workstream closeout upgrade gate self-check failed");
  }

  const closeoutComplete = buildWorkstreamCloseout({
    cleanupEvidence: ["cleanup-history dry-run deleted=0。"],
    docSyncEvidence: ["无需文档更新，已记录原因。"],
    ktWorkflowUpdated: true,
    problemRecords: ["无新卡点。"],
    reviewEvidence: ["global-review findings=0。"],
    reusablePatterns: ["none"],
    stableSolutions: ["无新增稳定解法。"],
    superpowersReviewEvidence: ["Superpowers reviewer completed; no Critical/Important findings。"],
    title: "文档收尾",
    verificationEvidence: ["typecheck/self-test/global-review 通过。"],
  });
  if ((closeoutComplete.canReportComplete as boolean) !== true) {
    throw new Error("workstream closeout complete self-check failed");
  }

  const closeoutInvalidCleanup = buildWorkstreamCloseout({
    cleanupEvidence: ["cleanup-history dry-run deleted=3。"],
    docSyncEvidence: ["kt_change_doc_sync requiredDocs 已处理。"],
    problemRecords: ["无新卡点。"],
    reviewEvidence: ["global-review findings=0。"],
    reusablePatterns: ["none"],
    stableSolutions: ["无新增稳定解法。"],
    superpowersReviewEvidence: ["Superpowers reviewer completed。"],
    title: "无效清理证据",
    verificationEvidence: ["typecheck 通过。"],
  });
  if ((closeoutInvalidCleanup.canReportComplete as boolean) !== false) {
    throw new Error("workstream closeout cleanup evidence self-check failed");
  }

  const closeoutMissingSuperpowersReview = buildWorkstreamCloseout({
    cleanupFinalDeleted: 0,
    docSyncEvidence: ["无需文档更新，已记录原因。"],
    problemRecords: ["无新卡点。"],
    reviewEvidence: ["global-review findings=0。"],
    reusablePatterns: ["none"],
    stableSolutions: ["无新增稳定解法。"],
    title: "缺 Superpowers 审查证据",
    verificationEvidence: ["typecheck 通过。"],
  });
  if ((closeoutMissingSuperpowersReview.canReportComplete as boolean) !== false) {
    throw new Error("workstream closeout Superpowers review gate self-check failed");
  }

  const obsidianContext = readObsidianContext({
    maxDocuments: 6,
    module: "ktWorkflow",
  });
  if (
    (obsidianContext.summary as { returnedDocuments?: number })
      .returnedDocuments === 0
  ) {
    throw new Error("obsidian context self-check failed");
  }
  if ((obsidianContext.summary as { codeAnchors?: number }).codeAnchors === 0) {
    throw new Error("obsidian code anchor self-check failed");
  }

  const obsidianValidation = validateObsidianVault({
    includeStaleReferences: false,
  });
  if ((obsidianValidation.summary as { errors?: number }).errors !== 0) {
    throw new Error("obsidian validation self-check failed");
  }

  const cleanupCliParser = {
    defaultDryRun: parseCliCleanupArgs(["node", "server", "--cleanup-history"])
      .dryRun,
    executeDryRun: parseCliCleanupArgs([
      "node",
      "server",
      "--cleanup-history",
      "--execute",
    ]).dryRun,
  };
  if (!cleanupCliParser.defaultDryRun || cleanupCliParser.executeDryRun) {
    throw new Error("cleanup CLI dry-run parser self-check failed");
  }

  const cleanupPreview = cleanupHistoryArtifacts({
    dryRun: true,
    keep: 3,
    roots: [".kt-workspace/test-artifacts", ".kt-workspace"],
  });
  const cleanupRoots = cleanupPreview.roots as Array<{
    preservedNames: string[];
    root: string;
  }>;
  const testArtifactsRoot = cleanupRoots.find(
    (item) => item.root === ".kt-workspace/test-artifacts",
  );
  const workspaceHistoryRoot = cleanupRoots.find(
    (item) => item.root === ".kt-workspace",
  );
  if (!testArtifactsRoot?.preservedNames.includes("_templates")) {
    throw new Error("cleanup template preservation self-check failed");
  }
  if (!workspaceHistoryRoot?.preservedNames.includes("test-artifacts")) {
    throw new Error("cleanup workspace root preservation self-check failed");
  }

  const docSyncBangDream = await buildChangeDocSync({
    changedFiles: [
      "src/qqbot/plugins/bangDream/application/bangdream-application.service.ts",
    ],
    project: "api",
  });
  const docSyncRequiredDocs = docSyncBangDream.requiredDocs as Array<{
    path: string;
  }>;
  if (
    !docSyncRequiredDocs.some(
      (item) => item.path === "Node/kt-template-online-api/API.md",
    )
  ) {
    throw new Error("doc sync API self-check failed");
  }

  const loopAuditComplete = buildWorkflowLoopAudit({
    cleanupExecuted: true,
    cleanupFinalDeleted: 0,
    cleanupPreviewDeleted: 3,
    docSyncEvidence: ["kt_change_doc_sync requiredDocs 已处理。"],
    ktWorkflowUpdated: true,
    problemRecords: ["测试历史清理流程未自动执行。"],
    reusablePattern: true,
    reviewEvidence: ["global-review findings=0"],
    stableSolutions: [
      "cleanup-history 默认 dry-run，显式 --execute 后复验 deleted=0。",
    ],
    superpowersReviewEvidence: ["Superpowers reviewer completed; no Critical/Important findings"],
    taskTitle: "自动化闭环审计",
    testCases: ["cleanup-history dry-run/execute 回归测试"],
    verificationEvidence: ["typecheck/self-test/cleanup dry-run 通过"],
  });
  if ((loopAuditComplete.canReportComplete as boolean) !== true) {
    throw new Error("workflow loop complete self-check failed");
  }

  const loopAuditBlocked = buildWorkflowLoopAudit({
    cleanupPreviewDeleted: 1,
    taskTitle: "缺证据闭环",
  });
  if ((loopAuditBlocked.canReportComplete as boolean) !== false) {
    throw new Error("workflow loop blocked self-check failed");
  }

  const loopAuditMissingCleanup = buildWorkflowLoopAudit({
    docSyncEvidence: ["kt_change_doc_sync requiredDocs 已处理。"],
    reviewEvidence: ["global-review findings=0。"],
    superpowersReviewEvidence: ["Superpowers reviewer completed。"],
    taskTitle: "缺清理证据闭环",
    testCases: ["self-test"],
    verificationEvidence: ["typecheck 通过。"],
  });
  if ((loopAuditMissingCleanup.canReportComplete as boolean) !== false) {
    throw new Error("workflow loop missing cleanup evidence self-check failed");
  }

  const dbSyncPlan = buildDbSyncPlan({});
  const dbSyncCommands = (dbSyncPlan.commands as string[]).join("\n");
  const backupName = dbSyncPlan.backupName as string;
  if (
    !backupName.includes("_") ||
    !dbSyncCommands.includes(".kt-workspace/db-sync") ||
    dbSyncCommands.includes("CREATE DATABASE IF NOT EXISTS")
  ) {
    throw new Error("DB sync plan safety self-check failed");
  }

  const data = {
    context: readWorkflowContext({ taskRecordCount: 2 }),
    guardrails: buildGuardrails({
      project: "mcp",
      taskType: "mcp",
      userRequest: "扩展 KT 工作区 MCP 可复用能力",
    }),
    cleanupCliParser,
    cleanupPreview,
    docSyncBangDream,
    loopAuditBlocked,
    loopAuditComplete,
    historyCleanup: cleanupHistoryArtifacts({
      dryRun: true,
      keep: 3,
    }),
    inspectAdmin: await inspectProject({ includeGit: false, project: "admin" }),
    inspectKnife4j: await inspectProject({
      includeGit: false,
      project: "knife4j",
    }),
    prepareTask: await prepareTask({
      includeGit: false,
      project: "mcp",
      taskType: "mcp",
      userRequest: "扩展 KT 工作区 MCP 可复用能力",
    }),
    review: await buildGlobalCodeReview({
      includeContentScan: true,
      includeRootScan: true,
      maxFindingsPerProject: 10,
      projects: ["mcp"],
    }),
    reviewCliParser,
    reviewClassifier,
    refactorGuardrails,
    apiVerification,
    businessTestPlan: buildBusinessTestPlan({
      flow: "system-log-visualization",
    }),
    closeoutComplete,
    closeoutNeedsUpgrade,
    obsidianContext,
    obsidianSync: syncObsidianWorkflow({
      includeStaleReferences: false,
    }),
    obsidianValidation,
    blockerResolution: buildBlockerResolution({
      attempts: 2,
      evidence: "self-test",
      problem: "重复超时",
      project: "mcp",
      solution: "改用固定脚本和 timeout 后再验证",
    }),
    commitPlan: await buildCommitPlan({
      projects: ["mcp"],
    }),
    componentWorkflow: buildComponentWorkflow({
      target: "SystemLog",
    }),
    dbSyncPlan,
    finishTask: await buildFinishTask({
      cleanupHistory: false,
      projects: ["mcp"],
      runValidation: false,
    }),
    pushPlan: await buildPushPlan({
      projects: ["mcp"],
    }),
    remoteHealthCheck: await buildRemoteHealthCheck({
      execute: false,
      services: ["ssh", "docker"],
    }),
    verification: buildVerificationPlan({
      changeType: "mcp",
      project: "mcp",
    }),
  };
  const outputDir = resolveInsideRoot(".kt-workspace/verify/ktWorkflow");
  mkdirSync(outputDir, { recursive: true });
  writeFileSync(
    path.join(outputDir, "self-test.json"),
    JSON.stringify(data, null, 2),
    "utf8",
  );
  console.log(
    JSON.stringify(
      { ok: true, outputDir, tools: registeredToolNames.length },
      null,
      2,
    ),
  );
}