iterate-plugin 3.15.0 → 3.17.0

package/lib/parse.js

@@ -1967,6 +1967,198 @@ export function buildQualityGateClearInstruction() {
   )
 }
 
+/**
+ * `iterate_quality_gate` compute payload — the one-click "recompute the gate
+ * from THIS session" builder.
+ *
+ * The gate's `compute` operation needs a hand-shaped payload
+ * (`dimensions` / `findings` / `validationResults` / `findingsByRound` /
+ * `fixedByDimension`) that a human cannot reliably type by hand — especially
+ * the per-dimension per-round convergence series. This builder turns the
+ * observatory's manifest (already normalized into the session stream) into
+ * that payload, so the model applies the exact data the user is looking at.
+ *
+ * Every field is optional and only included when non-empty (an empty findings
+ * list is still a legal `compute` — it yields a `pending` certificate, never
+ * a fabricated FAIL — so a caller may still emit a bare `{ operation }`).
+ * The returned text is a paste-able natural-language instruction, mirroring
+ * the rest of the panel's copy-to-command payloads.
+ *
+ * @param {{
+ *   dimensions?: string[],
+ *   findings?: Array<{ dimension: string, severity: string, file: string, line?: number }>,
+ *   validationResults?: Array<{ command: string, exitCode: number }>,
+ *   findingsByRound?: Record<string, number[]>,
+ *   fixedByDimension?: Record<string, number>,
+ * } | null | undefined} input
+ * @returns {string}
+ */
+export function buildQualityGateComputeInstruction(input) {
+  const src = input && typeof input === 'object' ? input : {}
+  const cleanStr = (v) => typeof v === 'string' && v.length > 0
+  const dimensions = Array.isArray(src.dimensions)
+    ? src.dimensions.filter((d) => typeof d === 'string' && d.length > 0)
+    : []
+  const findings = Array.isArray(src.findings)
+    ? src.findings.filter((f) => f && typeof f === 'object' && cleanStr(f.dimension) && cleanStr(f.file))
+        .map((f) => ({
+          dimension: f.dimension,
+          severity: typeof f.severity === 'string' && f.severity ? f.severity : 'medium',
+          file: f.file,
+          ...(typeof f.line === 'number' && Number.isFinite(f.line) && f.line > 0 ? { line: f.line } : {}),
+        }))
+    : []
+  const validationResults = Array.isArray(src.validationResults)
+    ? src.validationResults
+        .filter((v) => v && typeof v === 'object' && cleanStr(v.command) && typeof v.exitCode === 'number' && Number.isFinite(v.exitCode))
+        .map((v) => ({ command: v.command, exitCode: v.exitCode }))
+    : []
+  const findingsByRound = {}
+  if (src.findingsByRound && typeof src.findingsByRound === 'object' && !Array.isArray(src.findingsByRound)) {
+    for (const [dim, series] of Object.entries(src.findingsByRound)) {
+      const clean = Array.isArray(series)
+        ? series.filter((n) => typeof n === 'number' && Number.isFinite(n) && n >= 0)
+        : []
+      if (clean.length > 0) findingsByRound[dim] = clean
+    }
+  }
+  const fixedByDimension = {}
+  if (src.fixedByDimension && typeof src.fixedByDimension === 'object' && !Array.isArray(src.fixedByDimension)) {
+    for (const [dim, n] of Object.entries(src.fixedByDimension)) {
+      if (typeof n === 'number' && Number.isFinite(n) && n >= 0) fixedByDimension[dim] = n
+    }
+  }
+  const payload = { operation: 'compute' }
+  if (dimensions.length > 0) payload.dimensions = dimensions
+  if (findings.length > 0) payload.findings = findings
+  if (validationResults.length > 0) payload.validationResults = validationResults
+  if (Object.keys(findingsByRound).length > 0) payload.findingsByRound = findingsByRound
+  if (Object.keys(fixedByDimension).length > 0) payload.fixedByDimension = fixedByDimension
+  return (
+    '请调用 `iterate_quality_gate` 重算质量门禁证书（从当前会话推导维度/发现/验证结果并持久化）：\n\n' +
+    '```json\n' +
+    `${JSON.stringify(payload, null, 2)}\n` +
+    '```'
+  )
+}
+
+/**
+ * Reduce a normalized transcript manifest (+ the session-scanned quality gate)
+ * into the `iterate_quality_gate compute` input. Pure: reads only the fields
+ * the observatory already renders, so the one-click recompute can never
+ * disagree with what the user is looking at.
+ *
+ * @param {Record<string, unknown> | null | undefined} manifest normalized transcript
+ * @param {{ dimensions?: Array<{ dimension?: string }> } | null | undefined} qualityGate
+ * @returns {{
+ *   dimensions: string[],
+ *   findings: Array<{ dimension: string, severity: string, file: string, line?: number }>,
+ *   validationResults: Array<{ command: string, exitCode: number }>,
+ *   findingsByRound: Record<string, number[]>,
+ *   fixedByDimension: Record<string, number>,
+ * }}
+ */
+export function deriveQualityGateComputeInput(manifest, qualityGate) {
+  const m = manifest && typeof manifest === 'object' ? manifest : {}
+  const asArray = (v) => (Array.isArray(v) ? v : [])
+
+  // dimensions: union of every thread dimension across rounds, falling back
+  // to the already-computed gate's dimension names (a dry-run with no threads
+  // but a previous certificate still recomputes with the same gated set).
+  const dims = []
+  for (const r of asArray(m.rounds)) {
+    for (const t of asArray(r && r.threads)) {
+      const d = t && typeof t.dimension === 'string' ? t.dimension : ''
+      if (d && !dims.includes(d)) dims.push(d)
+    }
+  }
+  if (dims.length === 0 && qualityGate && Array.isArray(qualityGate.dimensions)) {
+    for (const d of qualityGate.dimensions) {
+      const name = d && typeof d.dimension === 'string' ? d.dimension : ''
+      if (name && !dims.includes(name)) dims.push(name)
+    }
+  }
+
+  const findings = []
+  for (const f of asArray(m.findings)) {
+    if (!f || typeof f !== 'object') continue
+    if (typeof f.dimension !== 'string' || !f.dimension) continue
+    if (typeof f.file !== 'string' || !f.file) continue
+    findings.push({
+      dimension: f.dimension,
+      severity: typeof f.severity === 'string' && f.severity ? f.severity : 'medium',
+      file: f.file,
+      ...(typeof f.line === 'number' && Number.isFinite(f.line) && f.line > 0 ? { line: f.line } : {}),
+    })
+  }
+
+  const validationResults = []
+  for (const v of asArray(m.validations)) {
+    if (!v || typeof v !== 'object') continue
+    if (typeof v.command !== 'string' || !v.command) continue
+    if (typeof v.exitCode !== 'number' || !Number.isFinite(v.exitCode)) continue
+    validationResults.push({ command: v.command, exitCode: v.exitCode })
+  }
+
+  // findingsByRound: per dimension, per review round, the number of findings
+  // raised that round — a true convergence series (latest last), padded to the
+  // round count so the gate's convergenceRate measures the actual first→last
+  // shrink even when a dimension is absent from a round's threads (0).
+  const rounds = asArray(m.rounds)
+  const allDims = dims.slice()
+  for (const r of rounds) {
+    for (const t of asArray(r && r.threads)) {
+      const d = t && typeof t.dimension === 'string' ? t.dimension : ''
+      if (d && !allDims.includes(d)) allDims.push(d)
+    }
+  }
+  const byRound = {}
+  for (const d of allDims) {
+    byRound[d] = []
+  }
+  for (const r of rounds) {
+    for (const d of allDims) {
+      let n = 0
+      for (const t of asArray(r && r.threads)) {
+        if (!t || t.dimension !== d) continue
+        for (const f of asArray(t && t.findings)) {
+          if (f && typeof f === 'object' && typeof f.dimension === 'string' && f.dimension === d) n += 1
+        }
+      }
+      byRound[d].push(n)
+    }
+  }
+
+  // fixedByDimension: attribute successful fixes to a dimension by matching
+  // the fixed file (and line, when both sides carry one) to a finding. A fix
+  // with no match is left unattributed — the field is optional and a gate
+  // recompute stays correct without it.
+  const fixedByDimension = {}
+  const findingsIndex = findings
+  for (const fx of asArray(m.fixes)) {
+    if (!fx || typeof fx !== 'object' || fx.success !== true) continue
+    const file = typeof fx.file === 'string' ? fx.file : ''
+    if (!file) continue
+    let dim = ''
+    for (const f of findingsIndex) {
+      if (f.file !== file) continue
+      if (typeof f.line === 'number' && typeof fx.line === 'number' && f.line !== fx.line) continue
+      dim = f.dimension
+      break
+    }
+    if (!dim) continue
+    fixedByDimension[dim] = (fixedByDimension[dim] || 0) + 1
+  }
+
+  return {
+    dimensions: dims,
+    findings,
+    validationResults,
+    findingsByRound: byRound,
+    fixedByDimension,
+  }
+}
+
 /**
  * `iterate_preflight` readiness-check payload (runs the pre-run checklist).
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iterate-plugin",
-  "version": "3.15.0",
+  "version": "3.17.0",
   "description": "dsh plugin that turns the iterate skill into an autonomous closed-loop harness with quality command center and experience bank (v3.3). Features: plan -> parallel review xN -> atomic fixes -> validate -> loop -> auto-stop, plus dry-run pure-review mode, quality gate compute/persist, writable experience bank, defense events stream (record + bilingual labels), and native command buttons — with a live quality command center (F8/F9/F10 render real session data), §8 assign-fix instruction, and task_mode indicator wired end to end.",
   "type": "module",
   "license": "MIT",

package/src/client/i18n.ts

@@ -296,8 +296,30 @@ export const EN: Record<string, string> = {
   '各轮发现数量：{a0}{a1}': 'Findings per round: {a0}{a1}',
   ' · 当前 Round {a0}': ' · current round {a0}',
   '跨轮对比（本会话）': 'Cross-round comparison (this session)',
-  '跨会话对比：本表只覆盖当前会话；点「拉取磁盘快照」让模型回显 iterate_history，再用「导出 JSON」并排比较两次运行':
-    'Cross-session comparison: this table only covers the current session — click "Pull disk snapshot" to have the model echo iterate_history, then use "Export JSON" to compare two runs side by side',
+  '跨会话对比：本表只覆盖当前会话；要跨两次迭代对比，用下方「存为对比基准」保存本次运行，再与下一次迭代对比。':
+    'Cross-session comparison: this table only covers the current session — to compare two iterations, save this run with \"Save as comparison baseline\" below, then compare the next iteration against it.',
+  跨会话对比: 'Cross-session comparison',
+  '基准已保存：{a0}': 'Baseline saved: {a0}',
+  '先保存当前运行为基准，再跑下一次迭代后一键对比':
+    'Save the current run as the baseline, then one-click compare the next iteration against it',
+  '把当前运行摘要保存为对比基准（含轮次/发现/修复/验证/门禁）':
+    'Save the current run summary as the comparison baseline (rounds / findings / fixes / validation / gate)',
+  '当前没有可保存的运行数据': 'No run data to save yet',
+  已存为基准: 'Saved as baseline',
+  存为对比基准: 'Save as comparison baseline',
+  '显示或隐藏与已保存基准的对比表': 'Show or hide the comparison against the saved baseline',
+  收起对比: 'Hide comparison',
+  与基准对比: 'Compare with baseline',
+  '清除已保存的对比基准': 'Clear the saved comparison baseline',
+  清除基准: 'Clear baseline',
+  '当前会话没有运行数据可对比': 'This session has no run data to compare yet',
+  指标: 'Metric',
+  基准: 'Baseline',
+  当前: 'Current',
+  变化: 'Delta',
+  复制对比表: 'Copy comparison table',
+  '复制跨会话对比表为 Markdown（可粘贴进 PR / issue / CI 注释）':
+    'Copy the cross-session comparison as a Markdown table (paste into a PR / issue / CI comment)',
 
   // ── F3 finding locations ─────────────────────────────────────────────────
   暂无发现: 'No findings',
@@ -379,6 +401,11 @@ export const EN: Record<string, string> = {
   '复制 iterate_quality_gate clear 指令文本（重置陈旧的 FAIL 证书）':
     'Copy the iterate_quality_gate clear instruction (resets a stale FAIL certificate)',
   清除门禁: 'Clear gate',
+  重算门禁: 'Recompute gate',
+  '复制 iterate_quality_gate compute 指令：从当前会话推导维度/发现/验证结果，一键重算并持久化门禁证书':
+    'Copy the iterate_quality_gate compute instruction: derive dimensions / findings / validation results from this session and recompute + persist the gate certificate',
+  '当前会话没有可重算的门禁数据（需先有审查/验证结果）':
+    'No gate data in this session to recompute (need review / validation results first)',
   '复制拉取磁盘快照指令：让模型回显 .iterate/ 下的门禁、经验、防御事件与 transcript':
     'Copy the disk-snapshot instruction: have the model echo the gate, experience, defense events and transcript artifacts under .iterate/',
   质量门禁视图: 'Quality gate view',

package/src/client/index.ts

@@ -101,6 +101,8 @@ import {
   buildRollbackInstruction, // #10: shared rollback payload
   buildQualityGateQueryInstruction, // #10: JSON-carrying query instruction
   buildQualityGateClearInstruction, // #10: JSON-carrying clear instruction
+  buildQualityGateComputeInstruction, // v3.17: one-click recompute payload from THIS session
+  deriveQualityGateComputeInput, // v3.17: manifest → compute input reducer
   buildTriageReadbackInstruction, // #7: close the write-back loop
   buildExperienceListInstruction, // #3/#10: JSON list payload for F9
   buildDefenseEventsListInstruction, // #3/#10: JSON list payload for F10
@@ -146,6 +148,18 @@ import {
   registerIterateShortcuts,
   type ShortcutsService,
 } from './shortcuts.ts'
+// v3.16: cross-session run comparison — the F2 tab compares two iterations of
+// the same project (save the current run as a baseline, then compare any later
+// run against it), instead of the old export-two-JSONs-and-diff-by-hand chore.
+import {
+  buildRunBaseline,
+  parseRunBaseline,
+  compareRuns,
+  buildRunCompareMarkdown,
+  RUN_BASELINE_STORAGE_KEY,
+  type RunBaseline,
+  type RunCompareMetric,
+} from './run-compare.ts'
 
 // ─── Module contract ─────────────────────────────────────────────────────────
 
@@ -2318,6 +2332,17 @@ const OBS_LIVE_META: Record<string, { label: { zh: string; en: string }; color:
 }
 const OBS_LIVE_FALLBACK_COLOR = 'var(--dsw-alias-label-secondary)'
 
+/** v3.16: cross-session comparison metric labels (inline {zh,en} pair, like OBS_TABS). */
+const RUN_COMPARE_METRIC_LABELS: Record<string, { zh: string; en: string }> = {
+  rounds: { zh: '轮次', en: 'Rounds' },
+  findings: { zh: '发现', en: 'Findings' },
+  criticalHigh: { zh: '严重（critical+high）', en: 'Critical + high' },
+  fixed: { zh: '修复成功', en: 'Fixes applied' },
+  failedFixes: { zh: '修复失败', en: 'Failed fixes' },
+  validationPassRate: { zh: '验证通过率', en: 'Validation pass rate' },
+  qualityGateScore: { zh: '门禁得分', en: 'Quality gate score' },
+}
+
 /**
  * Format a live-event timestamp as DD/MM HH:mm:ss (0-padded). Accepts an epoch
  * ms number or an ISO-ish string; any unparseable value degrades to ''.
@@ -2428,6 +2453,20 @@ function ObservatoryPanel(props: SlotProps) {
   // v3.0: Defense events filter
   const [defenseFilter, setDefenseFilter] = React.useState('')
 
+  // v3.16: cross-session comparison — the baseline is read from localStorage
+  // once on mount (a corrupt/stale payload reads as "no baseline", never as a
+  // phantom run); `showCompare` toggles the side-by-side table, `baselineFlash`
+  // confirms the save action.
+  const [baseline, setBaseline] = React.useState<RunBaseline | null>(() => {
+    try {
+      return parseRunBaseline(storage ? storage.get(RUN_BASELINE_STORAGE_KEY) : null)
+    } catch {
+      return null
+    }
+  })
+  const [showCompare, setShowCompare] = React.useState(false)
+  const [baselineFlash, setBaselineFlash] = React.useState(false)
+
   // Single shared "copied" flash timer (reused across all copy buttons).
   const copyTimer = React.useRef<ReturnType<typeof setTimeout> | null>(null)
   React.useEffect(() => () => { if (copyTimer.current) clearTimeout(copyTimer.current) }, [])
@@ -2691,18 +2730,62 @@ function ObservatoryPanel(props: SlotProps) {
     }))
   }
 
+  // ── v3.16: cross-session run comparison handlers ────────────────────────
+  // The summary is built from the SAME manifest the F2 tab renders, so a saved
+  // baseline can never disagree with what the user is looking at.
+  const currentRunSummary = (): RunBaseline | null => {
+    const hasRun =
+      (manifest.convergence || []).length > 0 ||
+      (manifest.findings || []).length > 0 ||
+      (manifest.fixes || []).length > 0 ||
+      (typeof manifest.round === 'number' && manifest.round > 0)
+    if (!hasRun) return null
+    return buildRunBaseline(
+      {
+        project: manifest.project || undefined,
+        mode: manifest.mode || undefined,
+        convergence: manifest.convergence || [],
+        findings: (manifest.findings || []) as Array<{ severity?: string }>,
+        fixes: (manifest.fixes || []) as Array<{ success?: boolean }>,
+        validations: (manifest.validations || []) as Array<{ allowed?: boolean }>,
+        qualityGateStatus: (qualityGate && qualityGate.overallStatus) || null,
+        qualityGateScore: qualityGate && typeof qualityGate.overallScore === 'number' ? qualityGate.overallScore : null,
+        stoppedReason: manifest.stoppedReason || null,
+      },
+      new Date().toISOString(),
+    )
+  }
+  const saveBaseline = () => {
+    const summary = currentRunSummary()
+    if (!summary || !storage) return
+    try {
+      storage.set(RUN_BASELINE_STORAGE_KEY, JSON.stringify(summary))
+      setBaseline(summary)
+      setShowCompare(true)
+      setBaselineFlash(true)
+      if (copyTimer.current) clearTimeout(copyTimer.current)
+      copyTimer.current = setTimeout(() => setBaselineFlash(false), 1600)
+    } catch (err) {
+      log('failed to persist run baseline', err)
+    }
+  }
+  const clearBaseline = () => {
+    if (storage) {
+      try { storage.remove(RUN_BASELINE_STORAGE_KEY) } catch (err) { log('failed to clear run baseline', err) }
+    }
+    setBaseline(null)
+    setShowCompare(false)
+  }
+
   // ── F2: convergence trend (inline bars, reusing TrendChart) ─────────────
   const renderTrend = () => {
     const conv = manifest.convergence || []
-    if (conv.length === 0) {
-      return React.createElement('div', { className: 'iterate-obs-empty' }, t('暂无收敛数据'))
-    }
     const points = conv.map((n, i) => ({ round: i + 1, count: n }))
     // Gap #13 (step ①): single-session cross-round comparison. One row per
     // round — findings raised / fixed / severity mix / validation outcome.
-    // Cross-SESSION comparison rides on the #4 pull instruction instead (the
-    // client has no filesystem access, so `iterate_history` aggregates have to
-    // be echoed back into the session first).
+    // v3.16: the cross-SESSION half is now the `renderCrossSessionCompare`
+    // block below (save the current run as a baseline, then compare any later
+    // run against it) instead of the old export-two-JSONs-and-diff-by-hand chore.
     const report = latestReport(session)
     const comparison = buildRoundComparison(report, manifest.validations || [], manifest.fixes || [])
     const comparisonTable = comparison.length === 0
@@ -2742,22 +2825,132 @@ function ObservatoryPanel(props: SlotProps) {
             }),
           ),
         )
-    return React.createElement('div', {},
-      React.createElement(TrendChart, { points }),
-      React.createElement('div', { className: 'iterate-obs-bar', style: { marginTop: 6 } },
-        tf(`各轮发现数量：{a0}{a1}`, { a0: conv.join(' → '), a1: typeof manifest.round === 'number' ? tf(` · 当前 Round {a0}`, { a0: manifest.round }) : '' }),
-      ),
-      comparisonTable
-        ? React.createElement('div', { className: 'iterate-obs-block', style: { marginTop: 8 } },
-            React.createElement('div', { className: 'iterate-obs-block-head' },
-              React.createElement('span', {}, t('跨轮对比（本会话）')),
-              React.createElement('span', { className: 'iterate-obs-head-meta' },
-                t('跨会话对比：本表只覆盖当前会话；点「拉取磁盘快照」让模型回显 iterate_history，再用「导出 JSON」并排比较两次运行'),
-              ),
+    const trendBody = conv.length === 0
+      ? React.createElement('div', { className: 'iterate-obs-empty' }, t('暂无收敛数据'))
+      : React.createElement('div', {},
+          React.createElement(TrendChart, { points }),
+          React.createElement('div', { className: 'iterate-obs-bar', style: { marginTop: 6 } },
+            tf(`各轮发现数量：{a0}{a1}`, { a0: conv.join(' → '), a1: typeof manifest.round === 'number' ? tf(` · 当前 Round {a0}`, { a0: manifest.round }) : '' }),
+          ),
+          comparisonTable
+            ? React.createElement('div', { className: 'iterate-obs-block', style: { marginTop: 8 } },
+                React.createElement('div', { className: 'iterate-obs-block-head' },
+                  React.createElement('span', {}, t('跨轮对比（本会话）')),
+                  React.createElement('span', { className: 'iterate-obs-head-meta' },
+                    t('跨会话对比：本表只覆盖当前会话；要跨两次迭代对比，用下方「存为对比基准」保存本次运行，再与下一次迭代对比。'),
+                  ),
+                ),
+                React.createElement('div', { className: 'iterate-obs-block-body' }, comparisonTable),
+              )
+            : null,
+        )
+    return React.createElement('div', {}, trendBody, renderCrossSessionCompare())
+  }
+
+  // ── v3.16: cross-session run comparison (F2) ─────────────────────────────
+  // Side-by-side comparison of the CURRENT run against a previously saved
+  // baseline, persisted in localStorage. This replaces the manual
+  // export-JSON-and-diff chore the old cross-session hint pointed at: save the
+  // current run once, then compare any later run against it in one click.
+  const renderCrossSessionCompare = () => {
+    const current = currentRunSummary()
+    const hasRun = current !== null
+    const metricLabel = (key: string): string => {
+      const m = RUN_COMPARE_METRIC_LABELS[key]
+      return m ? m[getLang()] : key
+    }
+    const fmtCell = (v: number | null, key: string): string => {
+      if (v === null) return '—'
+      return key === 'validationPassRate' ? `${v}%` : String(v)
+    }
+    const deltaText = (row: RunCompareMetric): string => {
+      if (row.baseline === null || row.current === null) return '—'
+      const d = row.current - row.baseline
+      return d === 0 ? '0' : `${d > 0 ? '+' : ''}${d}`
+    }
+    const deltaTint = (row: RunCompareMetric): { color: string; fontWeight: number } | undefined => {
+      if (row.baseline === null || row.current === null || row.higherIsBetter === null) return undefined
+      const d = row.current - row.baseline
+      if (d === 0) return undefined
+      const improved = row.higherIsBetter ? d > 0 : d < 0
+      return improved
+        ? { color: 'var(--dsw-alias-state-success-primary)', fontWeight: 600 }
+        : { color: 'var(--dsw-alias-state-error-primary)', fontWeight: 600 }
+    }
+    let compareBody: React.ReactNode = null
+    if (baseline && current && showCompare) {
+      const rows = compareRuns(baseline, current)
+      compareBody = React.createElement('table', { className: 'iterate-obs-table' },
+        React.createElement('thead', {},
+          React.createElement('tr', {},
+            React.createElement('th', {}, t('指标')),
+            React.createElement('th', {}, t('基准')),
+            React.createElement('th', {}, t('当前')),
+            React.createElement('th', {}, t('变化')),
+          ),
+        ),
+        React.createElement('tbody', {},
+          ...rows.map((row) =>
+            React.createElement('tr', { key: `rc-${row.key}` },
+              React.createElement('td', {}, metricLabel(row.key)),
+              React.createElement('td', {}, fmtCell(row.baseline, row.key)),
+              React.createElement('td', {}, fmtCell(row.current, row.key)),
+              React.createElement('td', { style: deltaTint(row) }, deltaText(row)),
             ),
-            React.createElement('div', { className: 'iterate-obs-block-body' }, comparisonTable),
-          )
-        : null,
+          ),
+        ),
+      )
+    }
+    return React.createElement('div', { className: 'iterate-obs-block', style: { marginTop: 8 } },
+      React.createElement('div', { className: 'iterate-obs-block-head' },
+        React.createElement('span', {}, t('跨会话对比')),
+        baseline
+          ? React.createElement('span', { className: 'iterate-obs-head-meta' }, tf(`基准已保存：{a0}`, { a0: baseline.savedAt }))
+          : React.createElement('span', { className: 'iterate-obs-head-meta' }, t('先保存当前运行为基准，再跑下一次迭代后一键对比')),
+      ),
+      React.createElement('div', { className: 'iterate-obs-block-body' },
+        React.createElement('div', { className: 'iterate-obs-bar', style: { flexWrap: 'wrap' } },
+          React.createElement('button', {
+            className: 'iterate-btn', 'data-primary': '', disabled: !hasRun,
+            title: hasRun ? t('把当前运行摘要保存为对比基准（含轮次/发现/修复/验证/门禁）') : t('当前没有可保存的运行数据'),
+            onClick: saveBaseline,
+          }, baselineFlash ? t('已存为基准') : t('存为对比基准')),
+          baseline
+            ? React.createElement('button', {
+                className: 'iterate-btn', 'data-copied': showCompare ? '' : undefined,
+                disabled: !hasRun,
+                title: t('显示或隐藏与已保存基准的对比表'),
+                onClick: () => setShowCompare((v) => !v),
+              }, showCompare ? t('收起对比') : t('与基准对比'))
+            : null,
+          baseline && current && showCompare
+            ? React.createElement('button', {
+                className: 'iterate-btn', 'data-copied': copiedKey === 'rc-copy' ? '' : undefined,
+                onClick: () => copyInstruction('rc-copy', buildRunCompareMarkdown(compareRuns(baseline, current), {
+                  指标: t('指标'),
+                  基准: t('基准'),
+                  当前: t('当前'),
+                  变化: t('变化'),
+                  ...Object.fromEntries(
+                    Object.entries(RUN_COMPARE_METRIC_LABELS).map(([k, v]) => [k, v[getLang()]]),
+                  ),
+                })),
+                title: t('复制跨会话对比表为 Markdown（可粘贴进 PR / issue / CI 注释）'),
+              }, copiedKey === 'rc-copy' ? t('已复制') : t('复制对比表'))
+            : null,
+          baseline
+            ? React.createElement('button', {
+                className: 'iterate-btn', 'data-ghost': '',
+                title: t('清除已保存的对比基准'),
+                onClick: clearBaseline,
+              }, t('清除基准'))
+            : null,
+        ),
+        showCompare && baseline && !hasRun
+          ? React.createElement('div', { className: 'iterate-obs-empty', style: { marginTop: 8 } }, t('当前会话没有运行数据可对比'))
+          : null,
+        compareBody,
+      ),
     )
   }
 
@@ -3152,6 +3345,19 @@ function ObservatoryPanel(props: SlotProps) {
     // Reset a stale FAIL certificate before a fresh iteration — the tool's
     // `clear` operation existed since v3.5.1 but had no client entry point.
     const gateClearInstruction = buildQualityGateClearInstruction()
+    // v3.17: one-click recompute. The gate's `compute` payload needs a
+    // hand-shaped `findingsByRound` convergence series that a human cannot
+    // type by hand — this derives it from the session manifest the panel is
+    // already rendering, so the recompute can never disagree with the view.
+    const computeInput = deriveQualityGateComputeInput(
+      manifest as unknown as Record<string, unknown> | null | undefined,
+      qualityGate as unknown as Record<string, unknown> | null | undefined,
+    )
+    const computeInstruction = buildQualityGateComputeInstruction(computeInput)
+    const hasComputeData =
+      computeInput.dimensions.length > 0 ||
+      computeInput.findings.length > 0 ||
+      computeInput.validationResults.length > 0
     const gate = qualityGate
     const dims = gate && gate.dimensions ? gate.dimensions : []
     const hasGate = gate !== null && Boolean(gate.overallStatus || gate.overallScore != null || dims.length > 0)
@@ -3167,6 +3373,14 @@ function ObservatoryPanel(props: SlotProps) {
         onClick: () => copyInstruction('qgate', gateInstruction),
         title: t('复制 iterate_quality_gate 查询指令（含 JSON 参数）'),
       }, copiedKey === 'qgate' ? t('已复制') : t('查询门禁')),
+      React.createElement('button', {
+        className: 'iterate-btn', 'data-primary': '', 'data-copied': copiedKey === 'qgate-compute' ? '' : undefined,
+        disabled: !hasComputeData,
+        onClick: () => copyInstruction('qgate-compute', computeInstruction),
+        title: hasComputeData
+          ? t('复制 iterate_quality_gate compute 指令：从当前会话推导维度/发现/验证结果，一键重算并持久化门禁证书')
+          : t('当前会话没有可重算的门禁数据（需先有审查/验证结果）'),
+      }, copiedKey === 'qgate-compute' ? t('已复制') : t('重算门禁')),
       React.createElement('button', {
         className: 'iterate-btn', 'data-danger': '', 'data-copied': copiedKey === 'qgate-clear' ? '' : undefined,
         onClick: () => copyInstruction('qgate-clear', gateClearInstruction),