@linxin666/dsh-client-ui-task-board 0.4.5 → 0.4.6

package/src/core/verification.ts

@@ -42,11 +42,73 @@ export const MAX_QUALITY_ATTEMPTS = 2
 /**
  * Anomaly budget of one cycle. A timeout, an authentication failure or an
  * unparseable judge answer is not a quality verdict, so it never consumes a
- * quality attempt; it is still bounded, so an unusable judge route can never
- * turn the completion gate into an unbounded retry loop.
+ * quality attempt.
+ *
+ * Reaching it does NOT judge the card: an unusable judge route is a property of
+ * the environment, not of the work, so a card must never be failed for it. The
+ * gate instead HOLDS the cycle open and runs no further judge call until the
+ * recorded anomalies are cleared by an explicit user action (see
+ * {@link withoutAcceptanceAnomalies}), which is what keeps the bound: one cycle
+ * spends at most this many judge rounds, and clearing them is a human decision.
  */
 export const MAX_EXCEPTION_ATTEMPTS = 2
 
+/**
+ * Retries of an INVALID acceptance: a quality veto whose required evidence is
+ * missing, unlocatable, or aimed at the empty-work baseline is not a judgement
+ * of the work, so it is recorded in its own stage and spent against this
+ * bound instead of the quality budget. Reaching it stops the judge calls and
+ * HOLDS the cycle for a human, exactly like a spent anomaly budget: an
+ * evidence-free veto must never fail a card, and it must never re-run forever.
+ */
+export const MAX_INVALID_ATTEMPTS = 2
+
+/**
+ * Capacity bound of the per-attempt acceptance detail — the repair/review
+ * material the acceptance mechanism itself creates. It is deliberately the
+ * ONLY large acceptance-only material this mechanism persists: findings are
+ * capped in count and rendered size, so nothing here needs an extra full
+ * evidence copy. It is removed by the automatic cleanup once the execution
+ * passed and settled (see {@link withAcceptanceDetailCleared}).
+ */
+export const VERIFICATION_DETAIL_MAX_FINDINGS = 12
+/** Longest verbatim citation kept from one judge finding. */
+export const VERIFICATION_DETAIL_MAX_QUOTE_CHARS = 600
+/** Longest rendered detail kept for one attempt, across every finding. */
+export const VERIFICATION_DETAIL_MAX_CHARS = 16_000
+
+/**
+ * Shortest citation a veto may rest on. A one- or two-character quote matches
+ * almost any trace, so it cannot locate anything.
+ */
+export const VERIFICATION_MIN_QUOTE_CHARS = 12
+/** Shortest requirement/observation/gap text that states a real difference. */
+export const VERIFICATION_MIN_PROBLEM_CHARS = 4
+
+/**
+ * Longest criterion identifier one persisted finding may name. An identifier,
+ * not prose: the reader rejects anything longer instead of clipping it, because
+ * a mangled id would silently detach the finding from the criterion it judges.
+ */
+export const VERIFICATION_DETAIL_MAX_CRITERION_ID_CHARS = 64
+
+/**
+ * Longest requirement / observation / gap / suggested-action text one finding
+ * keeps. Shared by the WRITER (which clips the judge's attributes to it) and the
+ * READER (which clips a hand-edited document back to it), so the acceptance
+ * detail has one capacity bound rather than two that can drift.
+ */
+export const VERIFICATION_DETAIL_MAX_PROBLEM_CHARS = 400
+
+/**
+ * Attempts one execution's acceptance cleanup may spend. Cleanup is started
+ * only after the pass record and the settlement are durable, is idempotent,
+ * and a failure never revokes the pass; the bound keeps a permanently failing
+ * filesystem from retrying forever, and the Host retries the remainder on its
+ * next start.
+ */
+export const MAX_CLEANUP_ATTEMPTS = 3
+
 /** The fixed baseline a session acceptance measures itself against. */
 export const EMPTY_WORK_BASELINE = '(No useful work or verification was performed.)'
 
@@ -105,6 +167,21 @@ export const SCALE_DESCRIPTION = [
   '  T = clearly and completely failed (worst)',
 ].join('\n')
 
+/**
+ * Which trajectory slot holds the WORK during one round.
+ *
+ * The even round (0) puts the work in slot A and the empty-work baseline in
+ * slot B; the odd round (1) swaps them, which is how the acceptance cancels
+ * position bias. The judge prompt ALWAYS introduces the work as
+ * `location="TRAJECTORY_B"`, because that is the slot the work occupies in the
+ * prompt's own framing; the parser maps the cited slot back through this table.
+ * @param round - the round index (0-based).
+ * @returns the slot letter the work occupies in that round.
+ */
+export function workSlotOfRound(round: number): 'A' | 'B' {
+  return round % 2 === 1 ? 'B' : 'A'
+}
+
 /** A-T letters in scale order (A = best). */
 export const LETTERS: readonly string[] = Array.from({ length: GRANULARITY }, (_, index) => String.fromCharCode(65 + index))
 
@@ -201,8 +278,15 @@ export function buildAcceptancePrompt(
   criterion: VerificationCriterion,
   groundTruthNote: string = DEFAULT_GROUND_TRUTH_NOTE,
   context?: string,
+  /**
+   * The trajectory slot that holds the WORK this round. The judge is told the
+   * slot explicitly, so the citation it returns names the work whichever way
+   * the A/B slots were arranged. Defaults to A (round 0's arrangement).
+   */
+  workSlot: 'A' | 'B' = 'A',
 ): string {
   const reference = context?.trim() ?? ''
+  const workSlotTag = workSlot === 'A' ? 'Trajectory A' : 'Trajectory B'
   const token = reference === ''
     ? evidenceNonce(problem, traceA, traceB)
     : evidenceNonce(problem, reference, traceA, traceB)
@@ -217,6 +301,10 @@ export function buildAcceptancePrompt(
     '**Rating Scale:**\n' + SCALE_DESCRIPTION,
     '**Evaluation Guideline — ' + criterion.name + ':**\n' + criterion.description,
     'Score each trajectory ONLY on this specific criterion ("' + criterion.name + '"). Ignore other aspects that are not relevant to it.',
+    'If and only if the score you give the WORK under this criterion makes it fail the criterion, you MUST justify it with one finding element per failing observation, in exactly this form (replace the placeholders, keep the attribute names and the quoting):',
+    '<finding criterion="' + criterion.name + '" location="' + workSlot + '" requirement="the task requirement this criterion demands" observation="what you actually observed" gap="why the observation does not satisfy the requirement" quote="a verbatim passage copied exactly from the block named by location">optional suggested action</finding>',
+    'Before citing the task you MUST name the failing criterion, restate the requirement it imposes, describe the observation that falls short, explain the difference, and cite a verbatim passage that occurs in the evidence. ' + workSlotTag + ' is the WORK under review and is the only trajectory a veto may cite: a passage quoted from the other trajectory, which is the empty-work baseline ' + EMPTY_WORK_BASELINE + ', is not evidence about the work and must never be used.',
+    'A failure with no such citation is not a usable verdict: if the evidence you were given is truncated, incomplete, or simply does not contain the output needed to judge this criterion, say so in your prose and cite nothing rather than inventing a basis to veto.',
     'Reason it through first, then END your reply with exactly these two lines and nothing after them. Replace each placeholder with a single letter A-T, keeping the spaces around the letter exactly as shown:\n<score_A> LETTER_A_TO_T </score_A>\n<score_B> LETTER_A_TO_T </score_B>',
     'Begin your analysis now.',
   ].join('\n\n')
@@ -329,13 +417,72 @@ export interface VerificationEvidenceSummary {
   workspaceFiles?: number
 }
 
-/** One recorded acceptance attempt: a quality verdict or an anomaly. */
+/**
+ * One judge finding, structured against the requirement it vetoes.
+ *
+ * The acceptance only counts a criterion as vetoed when the judge names that
+ * criterion, states the requirement, the observation and the difference, and
+ * cites a passage that really occurs in THIS acceptance's evidence (the task
+ * text, the candidate's own trajectory, or the host's workspace record). A
+ * finding that names the empty-work baseline, another criterion, or a passage
+ * that is not in the reviewed evidence is dropped here, so it can never become
+ * the evidence for a veto.
+ */
+export interface VerificationCriterionFinding {
+  /** Criterion id this finding vetoes. */
+  criterionId: string
+  /** The requirement the criterion demands of the work. */
+  requirement: string
+  /** What was actually observed in the evidence. */
+  observation: string
+  /** The difference: why that observation does not satisfy the requirement. */
+  gap: string
+  /** Verbatim citation from the evidence; verified to occur in it. */
+  quote: string
+  /**
+   * Which part of the reviewed evidence the citation was located in.
+   * `baseline` means the judge cited the empty-work baseline, which is never
+   * the work's own evidence and can never veto a criterion.
+   */
+  location: 'task' | 'trajectory' | 'workspace' | 'baseline' | 'unknown'
+  /** Optional suggested action from the judge. */
+  action?: string
+}
+
+/** Why an acceptance produced no valid quality verdict. */
+export type VerificationInvalidReason =
+  /** The failing criteria have no structured finding of their own. */
+  | 'missing-finding'
+  /** A finding's citation does not occur in the evidence the judge saw. */
+  | 'unlocatable-quote'
+  /** A finding vetoes the empty-work baseline instead of the work. */
+  | 'baseline-finding'
+  /** A finding's text is empty or a generic evaluation. */
+  | 'vacuous-finding'
+  /** The judged evidence was truncated and cannot substantiate the veto. */
+  | 'insufficient-evidence'
+
+/** One recorded acceptance attempt: a quality verdict, an anomaly, a budget stop, or an invalid veto. */
 export interface VerificationAttempt {
   /** 1-based ordinal within its own stage. */
   index: number
   /** When the attempt ran (ms epoch). */
   at: number
-  stage: 'quality' | 'exception'
+  /**
+   * `budget` records an acceptance the time budget ended before it could
+   * reach a verdict. It is neither a quality verdict nor an environment
+   * anomaly: the judge route may be perfectly healthy, the machine simply had
+   * no time left, so it is charged to no budget at all and cleared by the same
+   * explicit user action that clears anomalies.
+   *
+   * `invalid` records an acceptance that produced no usable quality verdict
+   * because the veto's required evidence was missing, unlocatable, or aimed at
+   * the empty-work baseline. It is neither a judgement of the work nor an
+   * environment anomaly: it consumes its own bounded retry budget, fails
+   * nothing, and is cleared by the same explicit user action that clears
+   * anomalies.
+   */
+  stage: 'quality' | 'exception' | 'budget' | 'invalid'
   /** Quality: whether the work passed. A recorded anomaly is never a pass. */
   passed: boolean
   /** Total score of the task's own work (0 for an anomaly). */
@@ -353,6 +500,14 @@ export interface VerificationAttempt {
   rounds: number
   /** Anomaly reason; absent on a quality verdict. */
   error?: string
+  /**
+   * Structured, locatable findings of a QUALITY attempt, keyed by criterion.
+   * A veto is only counted when the failing criterion appears here with a
+   * verified citation; otherwise the attempt is recorded as invalid instead.
+   */
+  criterionFindings?: VerificationCriterionFinding[]
+  /** Why an invalid attempt carried no usable verdict; absent on other stages. */
+  invalidReason?: VerificationInvalidReason
 }
 
 /** Persisted acceptance state of one execution. */
@@ -367,16 +522,84 @@ export interface ExecutionVerification {
    * out of the gate (`TaskRecord.skipVerification`), `goal-unavailable` when
    * the run never became a goal run (so no completion gate could ever fire),
    * and `team-member` for a teammate execution (the Lead's acceptance covers
-   * the team's aggregated evidence).
+   * the team's aggregated evidence), and `goal-disabled` when the GLOBAL
+   * native /goal switch was off at start, so this execution never became a
+   * goal run and its completion gate can never fire.
    */
-  applicability: 'enforced' | 'disabled' | 'skipped' | 'goal-unavailable' | 'team-member'
+  applicability: 'enforced' | 'disabled' | 'skipped' | 'goal-unavailable' | 'team-member' | 'goal-disabled'
   /** Set when the cycle is spent and the execution must fail. */
   failedReason?: string
   failedAt?: number
+  /**
+   * Retention record of the acceptance-only detail this execution created.
+   *
+   * An execution that PASSED and settled has its bulky acceptance-only material
+   * (attempt findings, invalid diagnostics, judge metadata beyond the audit
+   * summary) removed automatically; this record is the lightweight audit trail
+   * that proves the cleanup happened and preserves the minimal credential
+   * (verdict, scores, time, model, evidence hash) the completion gate needs.
+   * Absent means nothing has been cleaned for this execution.
+   */
+  cleanup?: AcceptanceCleanupRecord
+}
+
+/** Permanent, lightweight acceptance credential kept after a passed execution settles. */
+export interface AcceptanceAuditRecord {
+  /** Stage of the attempt the credential describes. */
+  stage: VerificationAttempt['stage']
+  /** Whether the attempt passed. */
+  passed: boolean
+  /** When the attempt ran (ms epoch). */
+  at: number
+  /** Total score of the task's own work. */
+  score: number
+  /** Empty-work baseline score. */
+  baseline: number
+  /** Per-criterion scores and thresholds. */
+  criteria: VerificationCriterionScore[]
+  /** Digest of the judged evidence; binds the pass record to what was reviewed. */
+  evidenceHash: string
+  /** Judge route of the attempt. */
+  route: VerificationRoute
+  /** Anomaly or invalid reason, when the attempt carried one. */
+  error?: string
+  /** One-line problem summary kept for the audit trail. */
+  findingSummary?: string
+  /** Token accounting of the attempt. */
+  usage: VerificationUsage
 }
 
-/** UI/board phase of one execution's acceptance. */
-export type VerificationPhase = 'off' | 'executing' | 'verifying' | 'repairing' | 'passed' | 'failed'
+/**
+ * State of the automatic acceptance-detail cleanup of one execution.
+ *
+ * `state` is `pending` until the cleanup actually removed the detail (or found
+ * nothing left to remove); `failed` records the last failure so a Host restart
+ * can retry it. The pass record and the settlement are durable before a cleanup
+ * starts, so a failure here never revokes a valid pass.
+ */
+export interface AcceptanceCleanupRecord {
+  state: 'pending' | 'cleaned' | 'failed'
+  /** Attempts spent; bounded by {@link MAX_CLEANUP_ATTEMPTS}. */
+  attempts: number
+  /** When the cleanup first ran (ms epoch). */
+  startedAt: number
+  /** When the detail was actually removed (ms epoch); absent while pending. */
+  cleanedAt?: number
+  /** Why the last attempt failed; absent when none did. */
+  lastError?: string
+  /** Minimal credential kept for every attempt this execution recorded. */
+  audit: AcceptanceAuditRecord[]
+}
+
+/**
+ * UI/board phase of one execution's acceptance.
+ *
+ * `invalid` is its own phase, not a variant of `failed`: the cycle spent its
+ * invalid-acceptance budget without a usable veto, so the judge is no longer
+ * called and a human decision is required. A reader must never read it as a
+ * quality rejection.
+ */
+export type VerificationPhase = 'off' | 'executing' | 'verifying' | 'repairing' | 'passed' | 'failed' | 'invalid'
 
 /** Quality attempts spent by this cycle. */
 export function qualityAttempts(verification: ExecutionVerification | undefined): VerificationAttempt[] {
@@ -388,6 +611,133 @@ export function exceptionAttempts(verification: ExecutionVerification | undefine
   return verification === undefined ? [] : verification.attempts.filter(attempt => attempt.stage === 'exception')
 }
 
+/**
+ * Attempts the time budget ended before a verdict, charged to no budget. They
+ * are kept so the report can say WHY an acceptance produced nothing, and they
+ * are cleared by the same explicit user action that clears anomalies.
+ */
+export function budgetAttempts(verification: ExecutionVerification | undefined): VerificationAttempt[] {
+  return verification === undefined ? [] : verification.attempts.filter(attempt => attempt.stage === 'budget')
+}
+
+/**
+ * Invalid acceptances spent by this cycle: a veto whose required evidence was
+ * missing, unlocatable, or aimed at the empty-work baseline. They are NOT
+ * quality verdicts, so they never close the cycle and never fail the card; the
+ * bound is what keeps an evidence-free judge from re-running forever.
+ */
+export function invalidAttempts(verification: ExecutionVerification | undefined): VerificationAttempt[] {
+  return verification === undefined ? [] : verification.attempts.filter(attempt => attempt.stage === 'invalid')
+}
+
+/** Whether this cycle still has invalid-acceptance budget left. */
+export function hasInvalidBudget(verification: ExecutionVerification | undefined): boolean {
+  return invalidAttempts(verification).length < MAX_INVALID_ATTEMPTS
+}
+
+/**
+ * The acceptance block with every non-quality attempt dropped: the explicit
+ * reset a user performs after fixing the environment (issue #1828).
+ *
+ * Only attempts that are not a quality verdict are dropped. A quality verdict
+ * is the board's own judgement of the work and survives every reset, so this
+ * can never buy an extra acceptance or re-open a judged failure; it only lets
+ * the environment be judged again.
+ * @param verification - the persisted acceptance state.
+ * @returns the cleared block, or undefined when there is nothing to clear.
+ */
+export function withoutAcceptanceAnomalies(verification: ExecutionVerification): ExecutionVerification | undefined {
+  const kept = verification.attempts.filter(attempt => attempt.stage === 'quality')
+  if (kept.length === verification.attempts.length) return undefined
+  const cleared: ExecutionVerification = { ...verification, attempts: kept }
+  delete cleared.inFlight
+  delete cleared.failedReason
+  delete cleared.failedAt
+  delete cleared.cleanup
+  return cleared
+}
+
+/**
+ * The one-line problem summary a cleaned execution keeps: the failing criteria
+ * with their scores, plus how many locatable findings were removed. This is the
+ * lightweight audit material that survives the detail cleanup.
+ * @param attempt - the attempt whose detail is being removed.
+ * @returns the bounded summary line.
+ */
+export function findingSummaryOf(attempt: VerificationAttempt): string | undefined {
+  const failed = attempt.criteria.filter(criterion => !criterion.passed)
+  const parts: string[] = []
+  if (failed.length > 0) {
+    parts.push('未达标判据：' + failed.map(criterion => criterion.name + ' ' + percent(criterion.score)).join('、'))
+  }
+  const located = (attempt.criterionFindings ?? []).length
+  if (located > 0) parts.push('已移除的可定位问题 ' + located + ' 条')
+  if (attempt.error !== undefined && attempt.error !== '') parts.push(attempt.error)
+  if (parts.length === 0) return undefined
+  return parts.join('；')
+}
+
+/**
+ * The audit credential of one attempt: everything the completion gate, the
+ * report and a later review need, and nothing that makes the ledger heavy.
+ * @param attempt - the attempt being condensed.
+ * @returns the lightweight audit record.
+ */
+export function auditOf(attempt: VerificationAttempt): AcceptanceAuditRecord {
+  const summary = findingSummaryOf(attempt)
+  return {
+    stage: attempt.stage,
+    passed: attempt.passed,
+    at: attempt.at,
+    score: attempt.score,
+    baseline: attempt.baseline,
+    criteria: attempt.criteria.map(criterion => ({ ...criterion })),
+    evidenceHash: attempt.evidence.hash,
+    route: { ...attempt.route },
+    ...(attempt.error === undefined ? {} : { error: attempt.error }),
+    ...(summary === undefined ? {} : { findingSummary: summary }),
+    usage: { ...attempt.usage },
+  }
+}
+
+/**
+ * Remove this execution's OWN acceptance-only detail while keeping the light
+ * audit record — the acceptance mechanism's side of requirement 2.
+ *
+ * Only material the acceptance mechanism itself created is removed: the
+ * per-attempt findings, the invalid diagnostics and the token/evidence detail
+ * beyond the summary. Everything a human needs to see the verdict survives
+ * (stage, pass flag, time, scores, evidence hash, judge route, usage totals),
+ * so the completion gate's pass record and a later review are unaffected, and
+ * NO user file, task artifact, raw session history or other execution's record
+ * is ever touched by this function.
+ * @param verification - the execution's acceptance block.
+ * @param now - cleanup instant (ms epoch).
+ * @returns the cleaned block, or undefined when there is nothing to remove.
+ */
+export function withAcceptanceDetailCleared(verification: ExecutionVerification, now: number): ExecutionVerification | undefined {
+  if (verification.cleanup?.state === 'cleaned') return undefined
+  const audit = verification.attempts.map(auditOf)
+  const cleaned: ExecutionVerification = {
+    ...verification,
+    // The findings are the acceptance's own large material; the verdict, the
+    // scores and the audit credential stay.
+    attempts: verification.attempts.map(attempt => ({
+      ...attempt,
+      findings: [],
+      criterionFindings: [],
+    })),
+    cleanup: {
+      state: 'cleaned',
+      attempts: (verification.cleanup?.attempts ?? 0) + 1,
+      startedAt: verification.cleanup?.startedAt ?? now,
+      cleanedAt: now,
+      audit,
+    },
+  }
+  return cleaned
+}
+
 /** The quality attempt that passed, when one did. */
 export function passedAttempt(verification: ExecutionVerification | undefined): VerificationAttempt | undefined {
   return qualityAttempts(verification).find(attempt => attempt.passed)
@@ -406,6 +756,43 @@ export function verificationRequired(verification: ExecutionVerification | undef
   return verification !== undefined && verification.applicability === 'enforced'
 }
 
+/**
+ * Whether this execution's acceptance gate was never opened: acceptance was
+ * enforced, the judge recorded nothing at all, and no cycle ever closed. Zero
+ * attempts is therefore a fact about the RUN, not a verdict about the work — a
+ * session that narrated completion instead of calling
+ * `update_goal(action: complete)` produces exactly this shape, and its failure
+ * reason must stay distinguishable from a quality verdict (issue #1837).
+ * @param verification - the execution's persisted acceptance state.
+ * @returns true when no acceptance attempt ever ran.
+ */
+export function verificationNeverInvoked(verification: ExecutionVerification | undefined): boolean {
+  return verification !== undefined
+    && verification.applicability === 'enforced'
+    && verification.attempts.length === 0
+    && verification.failedReason === undefined
+}
+
+/**
+ * Whether this execution's acceptance produced no usable veto at all: it was
+ * enforced, the judge recorded attempts, and every one of them is INVALID.
+ *
+ * Such a run must never be described as an evidence-backed quality veto (issue
+ * #1837's sibling): the judge could not locate its own rejection, so the run
+ * ended for lack of a matching pass rather than because the work was judged
+ * and rejected. The settlement reason names that difference.
+ * @param verification - the execution's persisted acceptance state.
+ * @returns true when nothing but invalid acceptances were recorded.
+ */
+export function verificationOnlyInvalid(verification: ExecutionVerification | undefined): boolean {
+  return verification !== undefined
+    && verification.applicability === 'enforced'
+    && verification.failedReason === undefined
+    && passedAttempt(verification) === undefined
+    && verification.attempts.length > 0
+    && invalidAttempts(verification).length === verification.attempts.length
+}
+
 /** Whether this cycle still has quality budget left. */
 export function hasQualityBudget(verification: ExecutionVerification | undefined): boolean {
   return qualityAttempts(verification).length < MAX_QUALITY_ATTEMPTS
@@ -424,10 +811,136 @@ export function verificationPhase(verification: ExecutionVerification | undefine
   if (passedAttempt(verification) !== undefined) return 'passed'
   if (verification.inFlight === true) return 'verifying'
   const quality = qualityAttempts(verification)
-  if (quality.length === 0) return 'executing'
+  if (quality.length === 0) {
+    // A cycle whose only recorded attempts are invalid is HELD, not failed: the
+    // judge produced no usable veto, so no quality verdict exists and a human
+    // must look at it instead of the board failing the card.
+    return hasInvalidBudget(verification) ? 'executing' : 'invalid'
+  }
   return hasQualityBudget(verification) ? 'repairing' : 'failed'
 }
 
+/** The text of each evidence part one acceptance handed to the judge. */
+export interface AcceptanceEvidenceText {
+  /** The task statement block. */
+  task: string
+  /** The candidate's own trajectory block (the WORK). */
+  trajectory: string
+  /** The host's rendered workspace-change block; empty when none was served. */
+  workspace: string
+}
+
+/** The input the program-level validity check reads from one finished attempt. */
+export interface AcceptanceValidityInput {
+  /** Per-criterion scores the attempt recorded. */
+  criteria: readonly VerificationCriterionScore[]
+  /** Structured findings the judge's answer produced. */
+  findings: readonly VerificationCriterionFinding[]
+  /** The exact evidence texts the judge was shown. */
+  evidence: AcceptanceEvidenceText
+  /** Characters the evidence cap dropped from the trajectory. */
+  omittedCharacters: number
+}
+
+/** The verdict of the program-level validity check. */
+export type AcceptanceValidity =
+  | { valid: true }
+  | { valid: false; reason: VerificationInvalidReason; detail: string }
+
+/** Whether a text carries a real statement rather than filler. */
+function substantive(text: string): boolean {
+  return text.trim().length >= VERIFICATION_MIN_PROBLEM_CHARS
+}
+
+/**
+ * Program-level validity of a REJECTING acceptance, decided before any quality
+ * verdict is booked (requirement 1: the rule cannot live in a prompt alone).
+ *
+ * A veto is only usable when every criterion that failed has its own structured
+ * finding carrying the requirement, the observation, the difference and a
+ * citation that really occurs in the evidence the judge saw. A citation aimed at
+ * the empty-work baseline, a citation that is not in the reviewed evidence, an
+ * empty or generic statement, and a truncated review that cannot substantiate
+ * the veto are all invalid acceptances: no quality verdict, no quality budget,
+ * and no card failure.
+ * @param input - the attempt's scores, findings and the evidence it judged.
+ * @returns valid, or the reason and detail of the invalidity.
+ */
+export function assessAcceptanceValidity(input: AcceptanceValidityInput): AcceptanceValidity {
+  const failed = input.criteria.filter(criterion => !criterion.passed)
+  const truncated = input.omittedCharacters > 0
+  if (failed.length === 0) {
+    // Every criterion passed yet the total rule still rejected the work (it did
+    // not beat the baseline). That is still a veto and still owes locatable
+    // evidence, but there is no specific criterion to attach it to.
+    const locating = input.findings.filter(finding => validFinding(finding, input.evidence) === undefined)
+    if (locating.length > 0) return { valid: true }
+    return truncated
+      ? { valid: false, reason: 'insufficient-evidence', detail: 'the review was truncated and no verifiable citation supports the total-score veto' }
+      : { valid: false, reason: 'missing-finding', detail: 'the total score was rejected without any locatable finding' }
+  }
+  for (const criterion of failed) {
+    const own = input.findings.filter(finding => finding.criterionId === criterion.id)
+    if (own.length === 0) {
+      return truncated
+        ? {
+            valid: false,
+            reason: 'insufficient-evidence',
+            detail: criterion.name + ': the evidence was truncated and the judge reported no citation of its own, so this criterion cannot be judged',
+          }
+        : {
+            valid: false,
+            reason: 'missing-finding',
+            detail: criterion.name + ': the criterion failed with no structured finding of its own',
+          }
+    }
+    let usable = false
+    let lastReason: { reason: VerificationInvalidReason; detail: string } | undefined
+    for (const finding of own) {
+      const problem = validFinding(finding, input.evidence)
+      if (problem === undefined) {
+        usable = true
+        break
+      }
+      lastReason = problem
+    }
+    if (!usable) {
+      const detail = (lastReason?.detail ?? criterion.name) + ' (' + criterion.name + ')'
+      return { valid: false, reason: lastReason?.reason ?? 'vacuous-finding', detail }
+    }
+  }
+  return { valid: true }
+}
+
+/**
+ * Why one finding cannot support a veto, or undefined when it can.
+ *
+ * The citation is checked against the evidence text of the LOCATION the finding
+ * names, so a quote invented by the judge, a quote taken from an A/B slot that
+ * held the empty-work baseline, and a quote the reviewed window never contained
+ * are all rejected.
+ */
+function validFinding(finding: VerificationCriterionFinding, evidence: AcceptanceEvidenceText): { reason: VerificationInvalidReason; detail: string } | undefined {
+  if (!substantive(finding.requirement) || !substantive(finding.observation) || !substantive(finding.gap)) {
+    return { reason: 'vacuous-finding', detail: 'the finding states no requirement, observation or difference' }
+  }
+  if (finding.location === 'baseline') {
+    return { reason: 'baseline-finding', detail: 'the citation is taken from the empty-work baseline, which is not the work under review' }
+  }
+  const quote = finding.quote.trim()
+  if (quote.length < VERIFICATION_MIN_QUOTE_CHARS) {
+    return { reason: 'unlocatable-quote', detail: 'the citation is too short to locate anything in the evidence' }
+  }
+  const haystack = finding.location === 'task' ? evidence.task
+    : finding.location === 'workspace' ? evidence.workspace
+      : finding.location === 'trajectory' ? evidence.trajectory
+        : ''
+  if (haystack === '' || !haystack.includes(quote)) {
+    return { reason: 'unlocatable-quote', detail: 'the citation does not occur in the evidence the judge reviewed' }
+  }
+  return undefined
+}
+
 /**
  * The acceptance rule, mirrored from the verifier's `sessionAccepted`:
  * the work must BEAT the empty-work baseline, reach the total threshold, and
@@ -455,7 +968,7 @@ function readAttempt(value: unknown): VerificationAttempt | undefined {
   if (typeof value !== 'object' || value === null) return undefined
   const row = value as Record<string, unknown>
   if (typeof row.index !== 'number' || typeof row.at !== 'number') return undefined
-  if (row.stage !== 'quality' && row.stage !== 'exception') return undefined
+  if (row.stage !== 'quality' && row.stage !== 'exception' && row.stage !== 'budget' && row.stage !== 'invalid') return undefined
   if (typeof row.passed !== 'boolean') return undefined
   if (typeof row.score !== 'number' || !Number.isFinite(row.score)) return undefined
   if (typeof row.baseline !== 'number' || !Number.isFinite(row.baseline)) return undefined
@@ -490,7 +1003,26 @@ function readAttempt(value: unknown): VerificationAttempt | undefined {
   const routeRow = route as Record<string, unknown>
   if (typeof routeRow.provider !== 'string' || typeof routeRow.model !== 'string') return undefined
   if (routeRow.reasoningEffort !== undefined && typeof routeRow.reasoningEffort !== 'string') return undefined
-  const findings = Array.isArray(row.findings) ? row.findings.filter((item): item is string => typeof item === 'string') : []
+  // Bounded on READ as well as write: a hand-edited document must not be able to
+  // persist unbounded prose in the one legacy field the renderer prints.
+  const findings = (Array.isArray(row.findings) ? row.findings : [])
+    .filter((item): item is string => typeof item === 'string')
+    .slice(0, VERIFICATION_DETAIL_MAX_FINDINGS)
+    .map(item => clipRead(item, VERIFICATION_DETAIL_MAX_PROBLEM_CHARS))
+  const criterionFindings: VerificationCriterionFinding[] = []
+  if (Array.isArray(row.criterionFindings)) {
+    if (row.criterionFindings.length > VERIFICATION_DETAIL_MAX_FINDINGS) return undefined
+    for (const entry of row.criterionFindings) {
+      const finding = readCriterionFinding(entry)
+      if (finding === undefined) return undefined
+      criterionFindings.push(finding)
+    }
+  }
+  const invalidReason = row.invalidReason
+  if (invalidReason !== undefined
+    && invalidReason !== 'missing-finding' && invalidReason !== 'unlocatable-quote'
+    && invalidReason !== 'baseline-finding' && invalidReason !== 'vacuous-finding'
+    && invalidReason !== 'insufficient-evidence') return undefined
   return {
     index: row.index,
     at: row.at,
@@ -524,6 +1056,52 @@ function readAttempt(value: unknown): VerificationAttempt | undefined {
     channel: 'explicit-tag',
     rounds: typeof row.rounds === 'number' ? row.rounds : VERIFICATION_ROUNDS,
     ...(typeof row.error === 'string' ? { error: row.error } : {}),
+    ...(criterionFindings.length === 0 ? {} : { criterionFindings }),
+    ...(typeof invalidReason === 'string' ? { invalidReason } : {}),
+  }
+}
+
+/**
+ * Bound one persisted finding's text to what the acceptance itself would have
+ * written.
+ *
+ * The reader is the only other door into the ledger: a hand-edited or
+ * corrupted document could otherwise carry a megabyte of prose in a field the
+ * writer caps at a few hundred characters, and every later render, audit
+ * summary and cleanup pass would pay for it. Clipping on READ (never rejecting)
+ * keeps the block usable and its capacity bounded: the acceptance-only material
+ * the cleanup removes is bounded by construction on both sides.
+ * @param value - the raw persisted text.
+ * @param max - the cap the writer applies to that field.
+ * @returns the bounded text.
+ */
+function clipRead(value: string, max: number): string {
+  return value.length <= max ? value : value.slice(0, max)
+}
+
+/**
+ * Repair one persisted structured finding, or undefined when it is unusable.
+ * A malformed finding drops the WHOLE acceptance block (fail closed): a
+ * persisted veto that cannot be read back could otherwise be counted as
+ * evidence it no longer holds.
+ */
+function readCriterionFinding(value: unknown): VerificationCriterionFinding | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const row = value as Record<string, unknown>
+  if (typeof row.criterionId !== 'string' || row.criterionId === '') return undefined
+  if (typeof row.requirement !== 'string' || typeof row.observation !== 'string' || typeof row.gap !== 'string') return undefined
+  if (typeof row.quote !== 'string') return undefined
+  if (row.criterionId.length > VERIFICATION_DETAIL_MAX_CRITERION_ID_CHARS) return undefined
+  const location = row.location
+  if (location !== 'task' && location !== 'trajectory' && location !== 'workspace' && location !== 'baseline' && location !== 'unknown') return undefined
+  return {
+    criterionId: row.criterionId,
+    requirement: clipRead(row.requirement, VERIFICATION_DETAIL_MAX_PROBLEM_CHARS),
+    observation: clipRead(row.observation, VERIFICATION_DETAIL_MAX_PROBLEM_CHARS),
+    gap: clipRead(row.gap, VERIFICATION_DETAIL_MAX_PROBLEM_CHARS),
+    quote: clipRead(row.quote, VERIFICATION_DETAIL_MAX_QUOTE_CHARS),
+    location,
+    ...(typeof row.action === 'string' ? { action: clipRead(row.action, VERIFICATION_DETAIL_MAX_PROBLEM_CHARS) } : {}),
   }
 }
 
@@ -569,7 +1147,8 @@ export function normalizeVerification(value: unknown): ExecutionVerification | u
     effortFallback = { requested: fallback.requested, ...(fallback.resolved === undefined ? {} : { resolved: fallback.resolved }) }
   }
   const applicability = row.applicability
-  if (applicability !== 'enforced' && applicability !== 'disabled' && applicability !== 'skipped' && applicability !== 'goal-unavailable' && applicability !== 'team-member') return undefined
+  if (applicability !== 'enforced' && applicability !== 'disabled' && applicability !== 'skipped'
+    && applicability !== 'goal-unavailable' && applicability !== 'team-member' && applicability !== 'goal-disabled') return undefined
   const attempts: VerificationAttempt[] = []
   if (!Array.isArray(row.attempts)) return undefined
   for (const entry of row.attempts) {
@@ -578,6 +1157,8 @@ export function normalizeVerification(value: unknown): ExecutionVerification | u
     attempts.push(attempt)
   }
   if (typeof row.failedReason === 'string' && row.failedReason === '') return undefined
+  const cleanup = readCleanupRecord(row.cleanup)
+  if (row.cleanup !== undefined && cleanup === undefined) return undefined
   return {
     contract: {
       enabled: contractRow.enabled,
@@ -593,6 +1174,100 @@ export function normalizeVerification(value: unknown): ExecutionVerification | u
     applicability,
     ...(typeof row.failedReason === 'string' ? { failedReason: row.failedReason } : {}),
     ...(typeof row.failedAt === 'number' && Number.isFinite(row.failedAt) ? { failedAt: row.failedAt } : {}),
+    ...(cleanup === undefined ? {} : { cleanup }),
+  }
+}
+
+/**
+ * Repair the persisted cleanup record, or undefined when it is unusable. The
+ * record is the audit trail the UI reads to tell "the judge gave its evidence
+ * and it was cleaned up" apart from "the judge produced no evidence at all",
+ * so a malformed one drops the whole block (fail closed).
+ */
+function readCleanupRecord(value: unknown): AcceptanceCleanupRecord | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const row = value as Record<string, unknown>
+  if (row.state !== 'pending' && row.state !== 'cleaned' && row.state !== 'failed') return undefined
+  if (typeof row.attempts !== 'number' || !Number.isInteger(row.attempts) || row.attempts < 0) return undefined
+  if (typeof row.startedAt !== 'number' || !Number.isFinite(row.startedAt)) return undefined
+  if (row.cleanedAt !== undefined && (typeof row.cleanedAt !== 'number' || !Number.isFinite(row.cleanedAt))) return undefined
+  if (row.lastError !== undefined && typeof row.lastError !== 'string') return undefined
+  if (!Array.isArray(row.audit)) return undefined
+  const audit: AcceptanceAuditRecord[] = []
+  for (const entry of row.audit) {
+    const parsed = readAuditRecord(entry)
+    if (parsed === undefined) return undefined
+    audit.push(parsed)
+  }
+  return {
+    state: row.state,
+    attempts: row.attempts,
+    startedAt: row.startedAt,
+    ...(typeof row.cleanedAt === 'number' ? { cleanedAt: row.cleanedAt } : {}),
+    ...(typeof row.lastError === 'string' ? { lastError: row.lastError } : {}),
+    audit,
+  }
+}
+
+/** Repair one persisted audit credential, or undefined when it is unusable. */
+function readAuditRecord(value: unknown): AcceptanceAuditRecord | undefined {
+  if (typeof value !== 'object' || value === null) return undefined
+  const row = value as Record<string, unknown>
+  if (row.stage !== 'quality' && row.stage !== 'exception' && row.stage !== 'budget' && row.stage !== 'invalid') return undefined
+  if (typeof row.passed !== 'boolean') return undefined
+  if (typeof row.at !== 'number' || !Number.isFinite(row.at)) return undefined
+  if (typeof row.score !== 'number' || !Number.isFinite(row.score)) return undefined
+  if (typeof row.baseline !== 'number' || !Number.isFinite(row.baseline)) return undefined
+  if (!Array.isArray(row.criteria)) return undefined
+  const criteria: VerificationCriterionScore[] = []
+  for (const entry of row.criteria) {
+    if (typeof entry !== 'object' || entry === null) return undefined
+    const criterion = entry as Record<string, unknown>
+    if (typeof criterion.id !== 'string' || typeof criterion.name !== 'string') return undefined
+    if (typeof criterion.score !== 'number' || !Number.isFinite(criterion.score)) return undefined
+    if (typeof criterion.baseline !== 'number' || !Number.isFinite(criterion.baseline)) return undefined
+    if (typeof criterion.threshold !== 'number' || !Number.isFinite(criterion.threshold)) return undefined
+    criteria.push({
+      id: criterion.id,
+      name: criterion.name,
+      score: criterion.score,
+      baseline: criterion.baseline,
+      threshold: criterion.threshold,
+      passed: criterion.passed === true,
+    })
+  }
+  if (typeof row.evidenceHash !== 'string') return undefined
+  const route = row.route
+  if (typeof route !== 'object' || route === null) return undefined
+  const routeRow = route as Record<string, unknown>
+  if (typeof routeRow.provider !== 'string' || typeof routeRow.model !== 'string') return undefined
+  const usage = row.usage
+  if (typeof usage !== 'object' || usage === null) return undefined
+  const usageRow = usage as Record<string, unknown>
+  if (typeof usageRow.calls !== 'number' || typeof usageRow.inputTokens !== 'number'
+    || typeof usageRow.outputTokens !== 'number' || typeof usageRow.reasoningTokens !== 'number') return undefined
+  return {
+    stage: row.stage,
+    passed: row.passed,
+    at: row.at,
+    score: row.score,
+    baseline: row.baseline,
+    criteria,
+    evidenceHash: row.evidenceHash,
+    route: {
+      provider: routeRow.provider,
+      model: routeRow.model,
+      ...(typeof routeRow.reasoningEffort === 'string' ? { reasoningEffort: routeRow.reasoningEffort } : {}),
+    },
+    ...(typeof row.error === 'string' ? { error: row.error } : {}),
+    ...(typeof row.findingSummary === 'string' ? { findingSummary: row.findingSummary } : {}),
+    usage: {
+      calls: usageRow.calls,
+      inputTokens: usageRow.inputTokens,
+      outputTokens: usageRow.outputTokens,
+      reasoningTokens: usageRow.reasoningTokens,
+      ...(usageRow.usageIncomplete === true ? { usageIncomplete: true } : {}),
+    },
   }
 }
 
@@ -600,6 +1275,8 @@ export function normalizeVerification(value: unknown): ExecutionVerification | u
 export interface VerificationTotals {
   quality: number
   exceptions: number
+  /** Invalid acceptances: no usable veto, so no quality verdict and no card failure. */
+  invalid: number
   calls: number
   inputTokens: number
   outputTokens: number
@@ -609,10 +1286,11 @@ export interface VerificationTotals {
 
 /** Sum the attempts of one execution. */
 export function verificationTotals(verification: ExecutionVerification | undefined): VerificationTotals {
-  const totals: VerificationTotals = { quality: 0, exceptions: 0, calls: 0, inputTokens: 0, outputTokens: 0, reasoningTokens: 0, usageIncomplete: false }
+  const totals: VerificationTotals = { quality: 0, exceptions: 0, invalid: 0, calls: 0, inputTokens: 0, outputTokens: 0, reasoningTokens: 0, usageIncomplete: false }
   if (verification === undefined) return totals
   for (const attempt of verification.attempts) {
     if (attempt.stage === 'quality') totals.quality += 1
+    else if (attempt.stage === 'invalid') totals.invalid += 1
     else totals.exceptions += 1
     totals.calls += attempt.usage.calls
     totals.inputTokens += attempt.usage.inputTokens
@@ -639,9 +1317,10 @@ export function qualityFeedback(attempt: VerificationAttempt, remaining: number)
     '总分 ' + percent(attempt.score) + '（阈值 ' + percent(attempt.criteria[0]?.threshold ?? VERIFICATION_THRESHOLD) + '），空工作基线 ' + percent(attempt.baseline) + '。',
     '未达标判据：' + (failed.length === 0 ? '无（总分或基线比较未通过）' : failed.map(criterion => criterion.name + ' ' + percent(criterion.score)).join('、')),
   ]
-  if (attempt.findings.length > 0) {
+  const located = locatedFindingLines(attempt)
+  if (located.length > 0) {
     lines.push('可定位问题：')
-    for (const finding of attempt.findings) lines.push('- ' + finding)
+    for (const line of located) lines.push('- ' + line)
   } else {
     lines.push('本次裁判没有报告可定位的问题；请直接对照任务要求核对证据中的真实输出。')
   }
@@ -649,6 +1328,67 @@ export function qualityFeedback(attempt: VerificationAttempt, remaining: number)
   return lines.join('\n')
 }
 
+/**
+ * The feedback one INVALID acceptance returns.
+ *
+ * The claim is refused (the board still has no pass record, so completion may
+ * not take effect) but the agent is NOT handed a repair instruction: there is
+ * no located problem to repair, and telling it to "fix" an evidence-free veto
+ * would be exactly the blind repair the requirement forbids. The text says what
+ * was missing, what happens next, and what the agent should do instead (make
+ * the missing output itself observable, or let a human look).
+ * @param attempt - the invalid attempt.
+ * @param remaining - invalid-acceptance attempts left after this one.
+ * @returns the model-facing text.
+ */
+export function invalidAcceptanceFeedback(attempt: VerificationAttempt, remaining: number): string {
+  const lines = [
+    '[任务看板 · 验收无效] 第 ' + attempt.index + ' 次验收没有产生可用的质量判定。',
+    '原因：' + invalidReasonText(attempt.invalidReason) + (attempt.error === undefined || attempt.error === '' ? '' : '（' + attempt.error + '）'),
+    '本次未消耗质量验收额度，也不把本次执行判为失败。',
+  ]
+  if (attempt.invalidReason === 'insufficient-evidence') {
+    lines.push('裁判看到的证据不完整（本次轨迹被截断 ' + attempt.evidence.omittedCharacters + ' 字符），无法据此否决；这属于验收无效，不代表执行者没有完成工作。')
+    lines.push('请把关键结论的证据直接放进你能控制的输出里（例如把最终验证命令的输出贴出来），或说明还需要哪些证据；再次调用 update_goal(action: complete) 会重新验收。')
+  } else {
+    lines.push('验收没有拿到任务要求、实际观测、差异与可定位引用俱全的证据，因此本次否决无效。')
+    lines.push('请不要据此盲目修改：先确认你的交付是否真的满足了任务要求，并确保关键产物/输出可见；再次调用 update_goal(action: complete) 会重新验收。')
+  }
+  if (remaining > 0) {
+    lines.push('无效验收重试额度还剩 ' + remaining + ' 次；用尽后看板会停止调用裁判并等待人工处理。')
+  } else {
+    lines.push('无效验收重试额度已用尽：看板将停止调用裁判并把本次执行留在等待人工处理的状态。')
+  }
+  return lines.join('\n')
+}
+
+/**
+ * The reason one execution records when its invalid-acceptance budget is spent.
+ *
+ * Deliberately NOT a quality failure: no veto was ever substantiated, so the
+ * card stays open for a human and the reason says the acceptance is INVALID
+ * rather than rejected.
+ * @param used - invalid attempts spent.
+ * @returns the user- and model-facing text.
+ */
+export function invalidHoldReason(used: number): string {
+  return 'goal 验收无效（连续 ' + used + ' 次未产生可用判定）：验收没有给出与任务要求对应、且可定位到本次证据的否决依据，'
+    + '本次执行未判失败、未消耗质量验收额度。看板已停止调用裁判，等待人工处理：修复验收环境或证据可见性后，'
+    + '用 task_board_manage(action=reset-verification) 清除记录的无效验收，再重新完成目标；也可以直接重跑该卡片。'
+}
+
+/** Human-readable text of one invalid reason. */
+export function invalidReasonText(reason: VerificationInvalidReason | undefined): string {
+  switch (reason) {
+    case 'missing-finding': return '未达标的判据没有对应的结构化问题反馈'
+    case 'unlocatable-quote': return '问题反馈引用的位置不存在于本次裁判所见的证据中'
+    case 'baseline-finding': return '问题反馈指向空工作基线，而不是本次执行的工作'
+    case 'vacuous-finding': return '问题反馈为空或空泛评价，没有说明实际观测与差异'
+    case 'insufficient-evidence': return '裁判看到的证据不足（例如轨迹被截断），无法支撑否决'
+    default: return '未产生可用的质量判定'
+  }
+}
+
 /**
  * The reason one exhausted acceptance cycle records as the execution's final
  * failure. Unlike {@link qualityFeedback} — which the fixing agent reads while
@@ -669,15 +1409,43 @@ export function finalFailureReason(attempt: VerificationAttempt, used: number, t
       '；未达标判据：' + (failed.length === 0 ? '总分或基线比较未通过' : failed.map(criterion => criterion.name + ' ' + percent(criterion.score)).join('、')) +
       '），本次 execution 判失败。',
   ]
-  if (attempt.findings.length > 0) {
+  const located = locatedFindingLines(attempt)
+  if (located.length > 0) {
     lines.push('验收报告记录的可定位问题：')
-    for (const finding of attempt.findings) lines.push('- ' + finding)
+    for (const line of located) lines.push('- ' + line)
   } else {
     lines.push('本次验收没有记录可定位的问题；请对照任务要求与验收面板中的判据得分核对证据中的真实输出。')
   }
   return lines.join('\n')
 }
 
+/**
+ * The locatable problem lines of one attempt, structured findings first.
+ *
+ * A structured finding renders the requirement, the observed fact, the gap and
+ * the citation in a fixed order, so the fixing agent reads WHAT was required,
+ * WHAT was seen, WHY it falls short and WHERE to look — never a bare complaint.
+ * @param attempt - the attempt whose findings are rendered.
+ * @returns one line per finding, bounded.
+ */
+export function locatedFindingLines(attempt: VerificationAttempt): string[] {
+  const structured = attempt.criterionFindings ?? []
+  if (structured.length > 0) {
+    return structured.map(finding => {
+      const locator = '[' + finding.criterionId + ' ' + finding.location + '] "' + clip(finding.quote, 200) + '"'
+      const action = finding.action === undefined || finding.action === '' ? '' : ' → 建议核实：' + finding.action
+      return locator + ' 要求：' + finding.requirement + ' 观测：' + finding.observation + ' 差异：' + finding.gap + action
+    })
+  }
+  return [...attempt.findings]
+}
+
+/** Bound one text for a single-line rendering. */
+function clip(text: string, max: number): string {
+  const value = text.replace(/s+/g, ' ').trim()
+  return value.length <= max ? value : value.slice(0, max) + '…'
+}
+
 /** `0.42` style percentage. */
 export function percent(value: number): string {
   return (value * 100).toFixed(1) + '%'