@xenonbyte/da-vinci-workflow 0.1.23 → 0.1.24

package/lib/supervisor-review.js

@@ -0,0 +1,680 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFile } = require("child_process");
+const {
+  parseCheckpointStatusMap,
+  getConfiguredDesignSupervisorReviewers
+} = require("./audit-parsers");
+
+const VALID_STATUSES = new Set(["PASS", "WARN", "BLOCK"]);
+const VALID_REVIEW_SOURCES = new Set(["skill", "manual", "inferred"]);
+const REVIEW_STATUS_SEVERITY = Object.freeze({
+  PASS: 0,
+  WARN: 1,
+  BLOCK: 2
+});
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normalizeStatus(status) {
+  if (!status) {
+    return "";
+  }
+
+  const normalized = String(status).trim().toUpperCase();
+  if (!VALID_STATUSES.has(normalized)) {
+    throw new Error("`--status` must be one of PASS, WARN, BLOCK.");
+  }
+  return normalized;
+}
+
+function normalizeReviewSource(source) {
+  if (!source) {
+    return "";
+  }
+  const normalized = String(source).trim().toLowerCase();
+  if (!VALID_REVIEW_SOURCES.has(normalized)) {
+    throw new Error("`--source` must be one of skill, manual, inferred.");
+  }
+  return normalized;
+}
+
+function readTextIfExists(filePath) {
+  if (!pathExists(filePath)) {
+    return "";
+  }
+  return fs.readFileSync(filePath, "utf8");
+}
+
+function parseReviewerList(value) {
+  return String(value || "")
+    .split(/[,\n;]/)
+    .map((token) => token.replace(/`/g, "").trim())
+    .filter(Boolean);
+}
+
+function resolveCodexBinaryPath(explicitPath) {
+  const candidate = String(explicitPath || process.env.DA_VINCI_CODEX_BIN || "codex").trim();
+  if (!candidate) {
+    throw new Error("Unable to resolve Codex binary path.");
+  }
+  return candidate;
+}
+
+function normalizePositiveInt(value, fallback, minimum = 1, maximum = Number.POSITIVE_INFINITY) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+  return Math.max(minimum, Math.min(maximum, parsed));
+}
+
+function collectScreenshotPaths(projectRoot, changeId, options = {}) {
+  if (!changeId) {
+    return [];
+  }
+
+  const exportsDir = path.join(projectRoot, ".da-vinci", "changes", changeId, "exports");
+  if (!pathExists(exportsDir)) {
+    return [];
+  }
+
+  const entries = fs.readdirSync(exportsDir, { withFileTypes: true });
+  const imageFiles = entries
+    .filter((entry) => entry.isFile())
+    .map((entry) => path.join(exportsDir, entry.name))
+    .filter((filePath) => /\.(png|jpe?g|webp)$/i.test(filePath))
+    .sort((a, b) => a.localeCompare(b));
+
+  const maxImagesRaw = Number.parseInt(String(options.maxImages || ""), 10);
+  const maxImages = Number.isFinite(maxImagesRaw) && maxImagesRaw > 0 ? maxImagesRaw : 6;
+  return imageFiles.slice(0, maxImages);
+}
+
+function buildReviewerPrompt({ reviewer, projectRoot, changeId, pencilDesignPath }) {
+  const artifactPath = pencilDesignPath || "(unresolved pencil-design.md)";
+  return [
+    `Use the \`${reviewer}\` skill to review current design screenshots.`,
+    `Project root: ${projectRoot}`,
+    `Change id: ${changeId || "(unspecified)"}`,
+    `Target artifact: ${artifactPath}`,
+    "Return strict JSON with keys:",
+    "- status: PASS | WARN | BLOCK",
+    "- issues: string[]",
+    "- revision_outcome: string",
+    "Do not return markdown."
+  ].join("\n");
+}
+
+function parseReviewerPayload(rawText) {
+  const payload = JSON.parse(String(rawText || "").trim());
+  const status = normalizeStatus(payload.status);
+  const issues = Array.isArray(payload.issues)
+    ? payload.issues.map((issue) => String(issue || "").trim()).filter(Boolean)
+    : [];
+  const revisionOutcome = String(payload.revision_outcome || payload.revisionOutcome || "").trim();
+  return {
+    status,
+    issues,
+    revisionOutcome: revisionOutcome || "approved"
+  };
+}
+
+function execFileAsync(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, options, (error, stdout, stderr) => {
+      if (error) {
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+        return;
+      }
+      resolve({
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+function sleep(delayMs) {
+  if (!Number.isFinite(delayMs) || delayMs <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+async function runReviewerWithCodexOnce(options = {}) {
+  const {
+    codexBin,
+    reviewer,
+    projectRoot,
+    changeId,
+    pencilDesignPath,
+    screenshotPaths,
+    timeoutMs
+  } = options;
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "da-vinci-supervisor-runner-"));
+  const outputPath = path.join(tmpDir, "review.json");
+  const schemaPath = path.join(tmpDir, "schema.json");
+  try {
+    fs.writeFileSync(
+      schemaPath,
+      JSON.stringify(
+        {
+          type: "object",
+          required: ["status", "issues", "revision_outcome"],
+          additionalProperties: false,
+          properties: {
+            status: {
+              type: "string",
+              enum: ["PASS", "WARN", "BLOCK"]
+            },
+            issues: {
+              type: "array",
+              items: {
+                type: "string"
+              }
+            },
+            revision_outcome: {
+              type: "string"
+            }
+          }
+        },
+        null,
+        2
+      )
+    );
+
+    const prompt = buildReviewerPrompt({
+      reviewer,
+      projectRoot,
+      changeId,
+      pencilDesignPath
+    });
+
+    const args = [
+      "exec",
+      "--ephemeral",
+      "--skip-git-repo-check",
+      "-C",
+      projectRoot,
+      "--sandbox",
+      "read-only",
+      "--output-schema",
+      schemaPath,
+      "--output-last-message",
+      outputPath
+    ];
+    for (const screenshotPath of screenshotPaths || []) {
+      args.push("-i", screenshotPath);
+    }
+    args.push(prompt);
+
+    const timeoutValue = normalizePositiveInt(timeoutMs, 0, 0, 30 * 60 * 1000);
+    try {
+      await execFileAsync(codexBin, args, {
+        encoding: "utf8",
+        maxBuffer: 8 * 1024 * 1024,
+        timeout: timeoutValue > 0 ? timeoutValue : undefined
+      });
+    } catch (error) {
+      const stdout = String(error.stdout || "").trim();
+      const stderr = String(error.stderr || "").trim();
+      const timeoutHint = error.killed ? " (timed out)" : "";
+      const message = stderr || stdout || error.message || "unknown error";
+      throw new Error(`Reviewer \`${reviewer}\` failed${timeoutHint}: ${message}`);
+    }
+
+    if (!pathExists(outputPath)) {
+      throw new Error(`Reviewer \`${reviewer}\` completed but produced no output JSON.`);
+    }
+
+    return parseReviewerPayload(fs.readFileSync(outputPath, "utf8"));
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+async function runReviewerWithCodex(options = {}) {
+  const reviewer = String(options.reviewer || "").trim();
+  const retries = normalizePositiveInt(options.retries, 1, 0, 8);
+  const retryDelayMs = normalizePositiveInt(options.retryDelayMs, 400, 0, 60000);
+  const maxAttempts = retries + 1;
+  let attempt = 0;
+  let lastError = null;
+
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      const finding = await runReviewerWithCodexOnce(options);
+      return {
+        ...finding,
+        attempts: attempt
+      };
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxAttempts) {
+        break;
+      }
+      const backoffDelay = retryDelayMs * Math.pow(2, attempt - 1);
+      await sleep(backoffDelay);
+    }
+  }
+
+  throw new Error(
+    `Reviewer \`${reviewer}\` failed after ${maxAttempts} attempt(s): ${lastError ? lastError.message : "unknown error"}`
+  );
+}
+
+async function runReviewersInPool(reviewers, worker, concurrency) {
+  const queue = Array.isArray(reviewers) ? reviewers.slice() : [];
+  if (queue.length === 0) {
+    return [];
+  }
+
+  const findings = new Array(queue.length);
+  const workerCount = Math.min(normalizePositiveInt(concurrency, 2, 1, 16), queue.length);
+  let cursor = 0;
+
+  async function runWorker() {
+    while (true) {
+      const index = cursor;
+      cursor += 1;
+      if (index >= queue.length) {
+        return;
+      }
+      findings[index] = await worker(queue[index], index);
+    }
+  }
+
+  const workers = [];
+  for (let i = 0; i < workerCount; i += 1) {
+    workers.push(runWorker());
+  }
+  await Promise.all(workers);
+  return findings;
+}
+
+function aggregateReviewerFindings(findings, options = {}) {
+  if (!findings || findings.length === 0) {
+    return {
+      status: "BLOCK",
+      issueList: "No reviewer findings were produced.",
+      revisionOutcome: "blocked pending required fixes"
+    };
+  }
+
+  let finalStatus = "PASS";
+  for (const finding of findings) {
+    if (REVIEW_STATUS_SEVERITY[finding.status] > REVIEW_STATUS_SEVERITY[finalStatus]) {
+      finalStatus = finding.status;
+    }
+  }
+
+  const issueListParts = [];
+  for (const finding of findings) {
+    if (!finding.issues || finding.issues.length === 0) {
+      continue;
+    }
+    issueListParts.push(`${finding.reviewer}: ${finding.issues.join("; ")}`);
+  }
+  const issueList = issueListParts.length > 0 ? issueListParts.join(" | ") : "none";
+
+  let revisionOutcome = "approved";
+  if (finalStatus === "WARN") {
+    revisionOutcome = options.acceptWarn
+      ? "accepted with follow-up"
+      : "warn requires follow-up before completion";
+  } else if (finalStatus === "BLOCK") {
+    revisionOutcome = "blocked pending required fixes";
+  }
+
+  return {
+    status: finalStatus,
+    issueList,
+    revisionOutcome
+  };
+}
+
+function resolvePencilDesignPath(projectRoot, options = {}) {
+  if (options.pencilDesignPath) {
+    const explicitPath = path.resolve(projectRoot, options.pencilDesignPath);
+    return {
+      path: explicitPath,
+      changeId: options.changeId || null
+    };
+  }
+
+  const changeId = String(options.changeId || "").trim();
+  if (!changeId) {
+    throw new Error(
+      "`supervisor-review` requires either `--change <id>` or `--pencil-design <path>`."
+    );
+  }
+
+  return {
+    path: path.join(projectRoot, ".da-vinci", "changes", changeId, "pencil-design.md"),
+    changeId
+  };
+}
+
+function extractMcpRuntimeGateStatus(markdownText) {
+  const sectionMatch = String(markdownText || "").match(
+    /(?:^|\n)##\s+MCP Runtime Gate\s*\n([\s\S]*?)(?=\n##\s+|\s*$)/i
+  );
+  if (!sectionMatch) {
+    return "";
+  }
+
+  const statusMatch = String(sectionMatch[1]).match(
+    /(?:^|\n)\s*-\s*(?:Status|状态)\s*:\s*`?(PASS|WARN|BLOCK)`?\b/i
+  );
+  return statusMatch ? String(statusMatch[1]).toUpperCase() : "";
+}
+
+function extractCheckpointStatus(markdownText, checkpointLabel) {
+  const escapedLabel = escapeRegExp(checkpointLabel);
+  const match = String(markdownText || "").match(
+    new RegExp(`(?:^|\\n)\\s*-\\s*\`?${escapedLabel}\`?\\s*:\\s*\`?(PASS|WARN|BLOCK)\`?\\b`, "i")
+  );
+  return match ? String(match[1]).toUpperCase() : "";
+}
+
+function inferReview(markdownText, options = {}) {
+  const issues = [];
+  const checkpointStatuses = parseCheckpointStatusMap(markdownText);
+  const designCheckpointStatus =
+    checkpointStatuses["design checkpoint"] || extractCheckpointStatus(markdownText, "Design checkpoint");
+  const runtimeGateStatus = extractMcpRuntimeGateStatus(markdownText);
+  const hasScreenshotRecords = /(?:^|\n)##\s+Screenshot Review Records\b/i.test(
+    String(markdownText || "")
+  );
+  let status = "PASS";
+
+  if (!hasScreenshotRecords) {
+    issues.push("Missing `## Screenshot Review Records` evidence.");
+    status = "BLOCK";
+  }
+
+  if (designCheckpointStatus === "BLOCK") {
+    issues.push("`Design checkpoint` is BLOCK.");
+    status = "BLOCK";
+  } else if (designCheckpointStatus === "WARN" && status !== "BLOCK") {
+    issues.push("`Design checkpoint` is WARN.");
+    status = "WARN";
+  } else if (!designCheckpointStatus && status !== "BLOCK") {
+    issues.push("`Design checkpoint` status is not recorded.");
+    status = "WARN";
+  }
+
+  if (runtimeGateStatus === "BLOCK") {
+    issues.push("`MCP Runtime Gate` is BLOCK.");
+    status = "BLOCK";
+  } else if (runtimeGateStatus === "WARN" && status !== "BLOCK") {
+    issues.push("`MCP Runtime Gate` is WARN.");
+    status = "WARN";
+  }
+
+  const issueList = issues.length > 0 ? issues.join(" ") : "none";
+  let revisionOutcome = "approved";
+  if (status === "WARN") {
+    revisionOutcome = options.acceptWarn
+      ? "accepted with follow-up"
+      : "warn requires follow-up before completion";
+  } else if (status === "BLOCK") {
+    revisionOutcome = "blocked pending required fixes";
+  }
+
+  return {
+    status,
+    issueList,
+    revisionOutcome,
+    source: "inferred",
+    executedReviewers: [],
+    configuredReviewers: options.configuredReviewers || []
+  };
+}
+
+function hasAcceptedWarn(revisionOutcome) {
+  return /(accepted|accepted with follow-up|accepted warning|warn accepted|接受|已接受|接受警告)/i.test(
+    String(revisionOutcome || "")
+  );
+}
+
+function buildReviewSection(review) {
+  const now = new Date().toISOString();
+  const configuredReviewersText =
+    review.configuredReviewers && review.configuredReviewers.length > 0
+      ? review.configuredReviewers.join(", ")
+      : "none";
+  const executedReviewersText =
+    review.executedReviewers && review.executedReviewers.length > 0
+      ? review.executedReviewers.join(", ")
+      : "none";
+  return [
+    `## Design-Supervisor Review (CLI ${now})`,
+    "- Review runner: `da-vinci supervisor-review`",
+    `- Configured reviewers: ${configuredReviewersText}`,
+    `- Executed reviewers: ${executedReviewersText}`,
+    `- Review source: ${review.source}`,
+    `- Status: ${review.status}`,
+    `- Issue list: ${review.issueList}`,
+    `- Revision outcome: ${review.revisionOutcome}`
+  ].join("\n");
+}
+
+function appendReviewSection(existingText, review) {
+  const section = buildReviewSection(review);
+  const base = String(existingText || "").trim();
+  if (!base) {
+    return `# Pencil Design\n\n${section}\n`;
+  }
+  return `${base}\n\n${section}\n`;
+}
+
+async function runDesignSupervisorReview(options = {}) {
+  const projectRoot = path.resolve(options.projectPath || process.cwd());
+  if (!pathExists(projectRoot)) {
+    throw new Error(`Project path does not exist: ${projectRoot}`);
+  }
+
+  const resolved = resolvePencilDesignPath(projectRoot, {
+    pencilDesignPath: options.pencilDesignPath,
+    changeId: options.changeId
+  });
+  const pencilDesignPath = resolved.path;
+  const changeId = resolved.changeId;
+  const existingText = readTextIfExists(pencilDesignPath);
+  const daVinciText = readTextIfExists(path.join(projectRoot, "DA-VINCI.md"));
+  const configuredReviewers = options.configuredReviewers
+    ? parseReviewerList(options.configuredReviewers)
+    : getConfiguredDesignSupervisorReviewers(daVinciText);
+  const executedReviewersInput = parseReviewerList(options.executedReviewers);
+  const explicitSource = normalizeReviewSource(options.source);
+  const runReviewers = options.runReviewers === true;
+  const reviewConcurrency = normalizePositiveInt(options.reviewConcurrency, 2, 1, 16);
+  const reviewerRetries = normalizePositiveInt(options.reviewerRetries, 1, 0, 8);
+  const reviewerRetryDelayMs = normalizePositiveInt(options.reviewerRetryDelayMs, 400, 0, 60000);
+  const manualStatus = normalizeStatus(options.status);
+  const reviewerAttempts = {};
+  let review = null;
+
+  if (runReviewers) {
+    if (configuredReviewers.length === 0) {
+      throw new Error(
+        "Cannot run reviewers automatically because `Design-supervisor reviewers` is not configured."
+      );
+    }
+
+    const codexBin = resolveCodexBinaryPath(options.codexBin);
+    const screenshotPaths = collectScreenshotPaths(projectRoot, changeId, {
+      maxImages: options.maxImages
+    });
+    const findings = await runReviewersInPool(
+      configuredReviewers,
+      async (reviewer) => {
+        const finding = await runReviewerWithCodex({
+          codexBin,
+          reviewer,
+          projectRoot,
+          changeId,
+          pencilDesignPath,
+          screenshotPaths,
+          timeoutMs: options.reviewerTimeoutMs,
+          retries: reviewerRetries,
+          retryDelayMs: reviewerRetryDelayMs
+        });
+        reviewerAttempts[reviewer] = finding.attempts || 1;
+        return {
+          reviewer,
+          ...finding
+        };
+      },
+      reviewConcurrency
+    );
+
+    const aggregated = aggregateReviewerFindings(findings, {
+      acceptWarn: options.acceptWarn
+    });
+    review = {
+      status: aggregated.status,
+      issueList: aggregated.issueList,
+      revisionOutcome: aggregated.revisionOutcome,
+      source: "skill",
+      configuredReviewers: [...configuredReviewers],
+      executedReviewers: [...configuredReviewers]
+    };
+  }
+
+  if (!review && manualStatus) {
+    const issueList = String(options.issueList || "").trim() || "none";
+    let revisionOutcome = String(options.revisionOutcome || "").trim();
+    if (!revisionOutcome) {
+      if (manualStatus === "PASS") {
+        revisionOutcome = "approved";
+      } else if (manualStatus === "WARN") {
+        revisionOutcome = options.acceptWarn
+          ? "accepted with follow-up"
+          : "warn requires follow-up before completion";
+      } else {
+        revisionOutcome = "blocked pending required fixes";
+      }
+    }
+
+    let source = explicitSource;
+    if (!source) {
+      source = executedReviewersInput.length > 0 ? "skill" : "manual";
+    }
+    const executedReviewers =
+      source === "skill" && executedReviewersInput.length === 0
+        ? [...configuredReviewers]
+        : executedReviewersInput;
+
+    review = {
+      status: manualStatus,
+      issueList,
+      revisionOutcome,
+      source,
+      configuredReviewers: [...configuredReviewers],
+      executedReviewers
+    };
+  } else if (!review) {
+    review = inferReview(existingText, {
+      acceptWarn: options.acceptWarn,
+      configuredReviewers
+    });
+    if (explicitSource) {
+      review.source = explicitSource;
+    }
+    if (review.source === "skill") {
+      review.executedReviewers =
+        executedReviewersInput.length > 0 ? executedReviewersInput : [...configuredReviewers];
+    } else if (review.source !== "inferred") {
+      review.executedReviewers = executedReviewersInput;
+    }
+  }
+
+  let wrote = false;
+  if (options.write) {
+    fs.mkdirSync(path.dirname(pencilDesignPath), { recursive: true });
+    const nextText = appendReviewSection(existingText, review);
+    fs.writeFileSync(pencilDesignPath, nextText);
+    wrote = true;
+  }
+
+  return {
+    projectRoot,
+    changeId,
+    pencilDesignPath,
+    status: review.status,
+    issueList: review.issueList,
+    revisionOutcome: review.revisionOutcome,
+    acceptedWarn: review.status === "WARN" && hasAcceptedWarn(review.revisionOutcome),
+    source: review.source,
+    configuredReviewers: review.configuredReviewers || [],
+    executedReviewers: review.executedReviewers || [],
+    runReviewers,
+    reviewConcurrency: runReviewers ? reviewConcurrency : 0,
+    reviewerRetries: runReviewers ? reviewerRetries : 0,
+    reviewerRetryDelayMs: runReviewers ? reviewerRetryDelayMs : 0,
+    reviewerAttempts: runReviewers ? reviewerAttempts : {},
+    wrote
+  };
+}
+
+function formatDesignSupervisorReviewReport(result) {
+  const lines = [
+    "Design-supervisor review",
+    `Project: ${result.projectRoot}`,
+    `Change: ${result.changeId || "(unspecified)"}`,
+    `Artifact: ${result.pencilDesignPath}`,
+    `Status: ${result.status}`,
+    `Issue list: ${result.issueList}`,
+    `Revision outcome: ${result.revisionOutcome}`,
+    `Accepted WARN: ${result.acceptedWarn ? "yes" : "no"}`,
+    `Source: ${result.source}`,
+    `Configured reviewers: ${
+      result.configuredReviewers.length > 0 ? result.configuredReviewers.join(", ") : "none"
+    }`,
+    `Executed reviewers: ${
+      result.executedReviewers.length > 0 ? result.executedReviewers.join(", ") : "none"
+    }`,
+    `Auto reviewer run: ${result.runReviewers ? "yes" : "no"}`,
+    `Artifact updated: ${result.wrote ? "yes" : "no"}`
+  ];
+
+  if (result.runReviewers) {
+    lines.push(`Review concurrency: ${result.reviewConcurrency}`);
+    lines.push(`Reviewer retries: ${result.reviewerRetries}`);
+    lines.push(`Reviewer retry delay (ms): ${result.reviewerRetryDelayMs}`);
+    const reviewerAttemptTokens = Object.entries(result.reviewerAttempts || {}).map(
+      ([reviewer, attempts]) => `${reviewer}:${attempts}`
+    );
+    lines.push(
+      `Reviewer attempts: ${reviewerAttemptTokens.length > 0 ? reviewerAttemptTokens.join(", ") : "none"}`
+    );
+  }
+
+  if (result.status === "BLOCK") {
+    lines.push("Gate hint: BLOCK should be treated as a completion blocker when required.");
+  } else if (result.status === "WARN" && !result.acceptedWarn) {
+    lines.push("Gate hint: WARN is not accepted yet; completion may still block when required.");
+  }
+
+  return lines.join("\n");
+}
+
+module.exports = {
+  runDesignSupervisorReview,
+  formatDesignSupervisorReviewReport
+};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@xenonbyte/da-vinci-workflow",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Requirement-to-design-to-code workflow skill for Codex, Claude, and Gemini",
   "bin": {
-    "da-vinci": "bin/da-vinci.js"
+    "da-vinci": "bin/da-vinci.js",
+    "design-supervisor": "bin/design-supervisor.js"
   },
   "files": [
     "SKILL.md",
@@ -34,7 +35,9 @@
     "test:pen-persistence": "node scripts/test-pen-persistence.js",
     "test:icon-search": "node scripts/test-icon-search.js",
     "test:icon-sync": "node scripts/test-icon-sync.js",
-    "test:icon-aliases": "node scripts/test-icon-aliases.js"
+    "test:icon-aliases": "node scripts/test-icon-aliases.js",
+    "test:supervisor-review-cli": "node scripts/test-supervisor-review-cli.js",
+    "test:supervisor-review-integration": "node scripts/test-supervisor-review-integration.js"
   },
   "engines": {
     "node": ">=18"

package/references/artifact-templates.md

@@ -559,6 +559,8 @@ Use this structure:
 
 ## Design-Supervisor Review
 - Configured reviewers
+- Executed reviewers
+- Review source (`skill` / `manual` / `inferred`)
 - Review mode
 - Review inputs
 - Whether reviewers were distinct from `Preferred adapters`