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

package/src/host/agent-tools.ts

@@ -23,11 +23,13 @@ import {
   TASK_PERMISSIONS,
   type ExecutionRecord,
   type NewTaskInput,
+  type ScheduleMode,
   type ScheduleRule,
   type TaskPermission,
   type TaskRecord,
   type TaskTag,
 } from '../core/tasks.ts'
+import type { SetSchedulePatch } from '../core/use-cases/task-schedule.ts'
 import type { TaskUpdatePatch } from '../core/use-cases/task-update.ts'
 import type { TaskBoardAction, TaskBoardSnapshot } from '../protocol.ts'
 
@@ -93,11 +95,22 @@ export function callingSessionId(exec: { agent?: unknown }): string | undefined
 function scheduleView(schedule: ScheduleRule): Record<string, unknown> {
   return {
     enabled: schedule.enabled,
-    cron: schedule.cron,
+    mode: schedule.mode,
+    // A one-shot has no cron, and carries its planned instant instead.
+    ...(schedule.cron === undefined ? {} : { cron: schedule.cron }),
+    ...(schedule.at === undefined ? {} : { at: schedule.at }),
     // Absent means the rule follows the Host zone, which the board view reports.
     ...(schedule.timeZone === undefined ? {} : { timeZone: schedule.timeZone }),
     ...(schedule.nextRunAt === undefined ? {} : { nextRunAt: schedule.nextRunAt }),
     ...(schedule.lastTriggeredAt === undefined ? {} : { lastTriggeredAt: schedule.lastTriggeredAt }),
+    // The run budget: what the scheduler has already opened, its cap (absent =
+    // unlimited), and how the rule stopped or what it last skipped.
+    runCount: schedule.runCount,
+    ...(schedule.maxRuns === undefined ? {} : { maxRuns: schedule.maxRuns }),
+    ...(schedule.endedAt === undefined ? {} : { endedAt: schedule.endedAt }),
+    ...(schedule.endedReason === undefined ? {} : { endedReason: schedule.endedReason }),
+    ...(schedule.skippedAt === undefined ? {} : { skippedAt: schedule.skippedAt }),
+    ...(schedule.skippedReason === undefined ? {} : { skippedReason: schedule.skippedReason }),
   }
 }
 
@@ -114,8 +127,11 @@ function executionView(execution: ExecutionRecord): Record<string, unknown> {
     ...(execution.result === undefined ? {} : { result: execution.result }),
     ...(execution.error === undefined ? {} : { error: execution.error }),
     // The session that asked for the run (audit only; client-asserted by the
-    // browser, the calling session here).
+    // browser, the calling session here). On an external record it names the
+    // outside agent instead, which is what distinguishes it in the history.
     ...(execution.initiatedBy === undefined ? {} : { initiatedBy: execution.initiatedBy }),
+    // Set only by record-external-outcome: the Host observed no session for it.
+    ...(execution.external === true ? { external: true } : {}),
     ...(execution.runGroupId === undefined ? {} : { cascade: true }),
     // A deferred cascade parent has settled its own turn but still waits for
     // its subtasks; that is not a stuck card and the model must not retry it.
@@ -152,8 +168,8 @@ function taskSummary(
     ...(task.model === undefined ? {} : { model: task.model }),
     ...(task.reuseSession === true ? { reuseSession: true } : {}),
     ...(task.teamRun === true ? { teamRun: true } : {}),
-    // Default-ON switch: only the opt-out is a deviation worth reporting.
-    ...(task.goalRun === false ? { goalRun: false } : {}),
+    // Default-OFF opt-in: only a card that asked for the goal run reports it.
+    ...(task.goalRun === true ? { goalRun: true } : {}),
     // Default-OFF opt-out: the deviation is what a reader must be told.
     ...(task.skipVerification === true ? { skipVerification: true } : {}),
     ...(task.schedule === undefined ? {} : { schedule: scheduleView(task.schedule) }),
@@ -341,7 +357,9 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
       'Move, archive, restore, delete, or settle one task board card.',
       'move-backlog, move-todo, move-running, move-done and move-failed are the manual column moves and cover every column; a card the runner is executing (one with an open execution) cannot be moved.',
       'A manual move writes the card column only and never fabricates an execution record, so the card reports a declaration rather than evidence of a run: done/failed declare work finished (or failed) outside a Host-run execution — human work, an external system, a decision made elsewhere — and running says the work is under way without a tracked session. Use task_board_run when the work should actually run in a session here.',
+      'record-external-outcome is the record-backed version of move-done and move-failed: use it when YOU, or another agent outside this Host, actually finished or failed the card with your own model, so the terminal column and the run history both derive from one execution record. It takes result (succeeded or failed) and initiatedBy (who completed it, for example your own agent name) plus an optional summary, and it is refused while the card still has an open execution: the Host stays the only authority over a run it is executing. It cannot record running or cancelled — those remain Host-only.',
       'settle force-closes the open execution of a card the board can no longer observe (a stuck running card) and records it cancelled with the caller as the reason, so the card returns to the todo column and can be run again.',
+      'reset-verification clears the acceptance anomalies (timeouts, authentication failures, an unresolvable judge route, or an attempt the time budget ended) recorded on a card open execution, so the next update_goal(action: complete) runs a fresh acceptance. It is refused unless that execution really carries such anomalies, it never clears a quality verdict, and a spent anomaly budget otherwise HOLDS the card open instead of failing it: tell the user the acceptance environment is unusable and that this action is how they clear it once they have fixed it.',
       'archive takes the whole subtask tree off the board and is refused while any member has an unsettled execution; restore brings the task, its ancestors and its subtree back; delete removes one card and is refused while it still has subtasks (detach or delete them first) or while it runs.',
       'It cannot confirm a permission binding: the confirmation gate is a human act performed in the board UI.',
     ].join(' '),
@@ -350,13 +368,59 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
       action: {
         type: 'string',
         required: true,
-        enum: ['move-todo', 'move-backlog', 'move-running', 'move-done', 'move-failed', 'archive', 'restore', 'delete', 'settle'],
+        enum: ['move-todo', 'move-backlog', 'move-running', 'move-done', 'move-failed', 'archive', 'restore', 'delete', 'settle', 'reset-verification', 'record-external-outcome'],
         description: 'The lifecycle operation to perform.',
       },
+      // Only record-external-outcome reads these two; every other action
+      // ignores them, so the model can pass them without a second tool call.
+      result: {
+        type: 'string',
+        enum: ['succeeded', 'failed'],
+        description: 'record-external-outcome only: the verdict the outside agent actually reached.',
+      },
+      initiatedBy: {
+        type: 'string',
+        description: 'record-external-outcome only: who finished the work outside this Host (for example your own agent name).',
+      },
+      summary: {
+        type: 'string',
+        description: 'record-external-outcome only: optional free-text note stored with the recorded outcome.',
+      },
     },
     output: { schema: { type: 'json' }, render: renderJson },
     async execute(args, exec) {
       const initiator = callingSessionId(exec)
+      if (args.action === 'record-external-outcome') {
+        const result = args.result
+        const by = typeof args.initiatedBy === 'string' ? args.initiatedBy.trim() : ''
+        if (result !== 'succeeded' && result !== 'failed') {
+          return refused('missing-result', 'record-external-outcome needs result=succeeded or result=failed')
+        }
+        if (by === '') {
+          return refused('missing-initiator', 'record-external-outcome needs initiatedBy naming who completed the work outside this Host')
+        }
+        if (!host.snapshot().tasks.some(task => task.id === args.taskId)) {
+          return refused('task-not-found', 'no task with id ' + args.taskId)
+        }
+        try {
+          const snapshot = await host.apply(crypto.randomUUID(), {
+            kind: 'record-external-outcome',
+            taskId: args.taskId,
+            result,
+            initiatedBy: by,
+            ...(typeof args.summary === 'string' && args.summary.trim() !== '' ? { summary: args.summary } : {}),
+          }, initiator)
+          const task = snapshot.tasks.find(item => item.id === args.taskId)
+          return json({
+            ok: true,
+            action: args.action,
+            ...(task === undefined ? {} : { task: taskSummary(task, snapshot.tasks, snapshot.sessionDefaultPermission) }),
+            note: 'The outcome is recorded as its own execution, so the terminal column and the run history agree. Read it back with task_board_get.',
+          })
+        } catch (error) {
+          return refused('refused', messageOf(error))
+        }
+      }
       const actions: Record<string, TaskBoardAction> = {
         'move-todo': { kind: 'move', taskId: args.taskId, status: 'todo' },
         'move-backlog': { kind: 'move', taskId: args.taskId, status: 'backlog' },
@@ -365,6 +429,7 @@ function buildManageTool(host: TaskBoardToolHost): ToolDefinition {
         'move-failed': { kind: 'move', taskId: args.taskId, status: 'failed' },
         archive: { kind: 'archive', taskId: args.taskId },
         settle: { kind: 'settle', taskId: args.taskId },
+        'reset-verification': { kind: 'reset-verification', taskId: args.taskId },
         restore: { kind: 'restore', taskId: args.taskId },
         delete: { kind: 'delete', taskId: args.taskId },
       }
@@ -390,37 +455,46 @@ function buildScheduleTool(host: TaskBoardToolHost): ToolDefinition {
   return defineTool({
     name: 'task_board_schedule',
     description: [
-      'Arm, change, or disarm a task scheduled runs (5-field cron; day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND).',
-      'The cron wall clock is read in the rule stored IANA time zone; omit timeZone to use the Host zone reported by task_board_list/task_board_get. DST gaps are skipped and an ambiguous fall-back time fires once, at the earlier instant.',
+      'Arm, change, or disarm a task scheduled runs. Two kinds of plan exist: a recurring 5-field cron rule (day-of-month and day-of-week follow Vixie semantics: both restricted means OR, otherwise AND), and a one-shot that runs once at a future instant.',
+      'For a one-shot pass mode "once" with at (the planned instant, ms since epoch UTC). For a recurring rule pass mode "cron" (or omit mode) with a cron expression, optionally capped by maxRuns (a positive whole number of scheduled executions; omit for unlimited, pass 0 to clear a cap).',
+      'The wall clock is read in the rule stored IANA time zone; omit timeZone to use the Host zone reported by task_board_list/task_board_get. DST gaps are skipped and an ambiguous fall-back time fires once, at the earlier instant.',
       'A due scheduled task runs the same cascade a manual run does, so a root task runs its whole subtask tree.',
-      'A schedule whose tree contains an unconfirmed above-default permission is refused and rolls to its next occurrence; the reason is reported in the list board summary as schedulerError.',
-      'Missed occurrences during Host downtime are skipped, never queued; a task that is already running skips its occurrence.',
+      'The scheduler counts executions it actually starts; once a rule reaches its run budget it stops itself in the ledger, and a manual run never consumes the budget. A schedule whose tree contains an unconfirmed above-default permission is refused and does not consume the budget; the reason is reported in the list board summary as schedulerError.',
+      'Missed occurrences during Host downtime are skipped, never queued (a one-shot whose instant passed while the Host was down is stopped as missed); a task that is already running skips its occurrence without consuming the budget.',
     ].join(' '),
     parameters: {
       taskId: { type: 'string', required: true, description: 'The task whose schedule changes.' },
       enabled: { type: 'boolean', description: 'Arm (true) or disarm (false) the schedule.' },
-      cron: { type: 'string', description: '5-field cron expression: minute hour day-of-month month day-of-week.' },
+      mode: { type: 'string', enum: ['cron', 'once'], description: 'The kind of plan: "cron" for a recurring rule, "once" for a single future instant. Omit to keep the stored kind.' },
+      cron: { type: 'string', description: '5-field cron expression of a recurring rule: minute hour day-of-month month day-of-week.' },
+      at: { type: 'integer', description: 'Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future.' },
       timeZone: {
         type: 'string',
-        description: 'IANA zone the cron wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone.',
+        description: 'IANA zone the wall clock is read in (for example Asia/Shanghai). Omit to keep the stored zone, or pass an empty string to clear it back to the Host zone.',
       },
+      maxRuns: { type: 'integer', description: 'Maximum scheduled executions of a recurring rule (positive whole number). Omit to keep the stored cap; pass 0 to clear it back to unlimited.' },
     },
     output: { schema: { type: 'json' }, render: renderJson },
     async execute(args, exec) {
-      if (args.enabled === undefined && args.cron === undefined && args.timeZone === undefined) {
-        return refused('nothing-to-change', 'pass enabled and/or cron and/or timeZone')
+      if (args.enabled === undefined && args.mode === undefined && args.cron === undefined && args.at === undefined
+        && args.timeZone === undefined && args.maxRuns === undefined) {
+        return refused('nothing-to-change', 'pass enabled, mode, cron, at, timeZone and/or maxRuns')
       }
       // A missing card must read as a missing card: the ledger reports an
       // unknown id through the same refusal as a malformed cron.
       if (!host.snapshot().tasks.some(task => task.id === args.taskId)) {
         return refused('task-not-found', 'no task with id ' + args.taskId)
       }
-      const patch: { enabled?: boolean; cron?: string; timeZone?: string | null } = {
+      const patch: SetSchedulePatch = {
         ...(args.enabled === undefined ? {} : { enabled: args.enabled }),
+        ...(args.mode === undefined ? {} : { mode: args.mode as ScheduleMode }),
         ...(args.cron === undefined ? {} : { cron: args.cron }),
+        ...(args.at === undefined ? {} : { at: args.at }),
         // An empty string is the documented way to clear the stored zone, so
         // the model never has to emit an explicit null through JSON args.
         ...(args.timeZone === undefined ? {} : { timeZone: args.timeZone === '' ? null : args.timeZone }),
+        // 0 is the documented way to clear a run cap back to unlimited.
+        ...(args.maxRuns === undefined ? {} : { maxRuns: args.maxRuns <= 0 ? null : args.maxRuns }),
       }
       try {
         const snapshot = await host.apply(crypto.randomUUID(), { kind: 'set-schedule', taskId: args.taskId, patch }, callingSessionId(exec))
@@ -527,7 +601,7 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
       model: { type: 'string', description: 'Pinned model as provider/model (or a model id); omit for the host default or the parent value.' },
       reuseSession: { type: 'boolean', description: 'Continue later runs in the previous execution session instead of a fresh conversation.' },
       teamRun: { type: 'boolean', description: 'Run this task as an Agent Team: running it starts one Team Lead session and the Host spawns a teammate per subtask inside it. Omit or false for one independent session per member. Refused when the deployment serves no Agent Teams service.' },
-      goalRun: { type: 'boolean', description: 'Start each run with dsh built-in /goal so the session keeps working continuation rounds until the goal completes. Default true (omit to keep it); pass false for a single plain turn.' },
+      goalRun: { type: 'boolean', description: 'Start each run with dsh built-in /goal so the session keeps working continuation rounds until the goal completes. Off by default: omit (or pass false) for a single plain turn, and pass true to opt this card in. It only takes effect while the deployment global native /goal switch is on.' },
       skipVerification: { type: 'boolean', description: 'Run this task without the board acceptance gate: update_goal may mark the goal complete without a passing acceptance, and the execution record is marked skipped. Default false (omit to inherit the board-wide acceptance switch). Only affects executions started afterwards.' },
       tags: {
         type: 'array',
@@ -544,10 +618,13 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
       schedule: {
         type: 'object',
         additionalProperties: false,
-        description: 'Arm a 5-field cron schedule at creation time (Host local time zone).',
+        description: 'Arm a schedule at creation time. Use mode "once" with at for a single future run, or mode "cron" (or omit mode) with a 5-field cron expression, optionally capped by maxRuns.',
         properties: {
           enabled: { type: 'boolean', required: true, description: 'Whether the schedule is armed.' },
-          cron: { type: 'string', required: true, description: '5-field cron: minute hour day-of-month month day-of-week.' },
+          mode: { type: 'string', enum: ['cron', 'once'], description: 'The kind of plan: "cron" for a recurring rule, "once" for a single future instant.' },
+          cron: { type: 'string', description: '5-field cron of a recurring rule: minute hour day-of-month month day-of-week.' },
+          at: { type: 'integer', description: 'Planned instant of a one-shot, in milliseconds since the Unix epoch (UTC). Must be in the future.' },
+          maxRuns: { type: 'integer', description: 'Maximum scheduled executions of a recurring rule (positive whole number); omit for unlimited.' },
         },
       },
     },
@@ -570,10 +647,18 @@ function buildCreateTool(host: TaskBoardToolHost): ToolDefinition {
         ...(args.model === undefined || args.model === '' ? {} : { model: args.model }),
         ...(args.reuseSession === true ? { reuseSession: true } : {}),
         ...(args.teamRun === true ? { teamRun: true } : {}),
-        ...(args.goalRun === false ? { goalRun: false } : {}),
+        ...(args.goalRun === true ? { goalRun: true } : {}),
     ...(args.skipVerification === true ? { skipVerification: true } : {}),
         ...(tags.length === 0 ? {} : { tags }),
-        ...(args.schedule === undefined ? {} : { schedule: { enabled: args.schedule.enabled, cron: args.schedule.cron } }),
+        ...(args.schedule === undefined ? {} : {
+          schedule: {
+            enabled: args.schedule.enabled,
+            ...(args.schedule.mode === undefined ? {} : { mode: args.schedule.mode as ScheduleMode }),
+            ...(args.schedule.cron === undefined ? {} : { cron: args.schedule.cron }),
+            ...(args.schedule.at === undefined ? {} : { at: args.schedule.at }),
+            ...(args.schedule.maxRuns === undefined ? {} : { maxRuns: args.schedule.maxRuns }),
+          },
+        }),
       }
       try {
         const snapshot = await host.apply(crypto.randomUUID(), { kind: 'create', id, input }, callingSessionId(exec))
@@ -621,7 +706,7 @@ function buildUpdateTool(host: TaskBoardToolHost): ToolDefinition {
       model: { type: 'string', description: 'New pinned model; an empty string clears it.' },
       reuseSession: { type: 'boolean', description: 'Continue later runs in the previous execution session.' },
       teamRun: { type: 'boolean', description: 'Switches this task between a plain cascade (one session per member) and an Agent Team run (Lead session plus a teammate per subtask).' },
-      goalRun: { type: 'boolean', description: 'Whether each run starts with dsh built-in /goal (default true). Pass false to run one plain turn instead.' },
+      goalRun: { type: 'boolean', description: 'Whether each run starts with dsh built-in /goal (default false, one plain turn). Pass true to opt this card in, or false to return it to the default.' },
       skipVerification: { type: 'boolean', description: 'Whether this task runs without the board acceptance gate (default false, inherit the board-wide switch). Pass true to opt out; pass false to opt back in. Only affects executions started afterwards.' },
       tags: {
         type: 'array',
@@ -651,7 +736,7 @@ function buildUpdateTool(host: TaskBoardToolHost): ToolDefinition {
       }
       if (has(args, 'reuseSession')) patch.reuseSession = args.reuseSession === true
       if (has(args, 'teamRun')) patch.teamRun = args.teamRun === true
-      if (has(args, 'goalRun')) patch.goalRun = args.goalRun === false ? false : true
+      if (has(args, 'goalRun')) patch.goalRun = args.goalRun === true ? true : false
       if (has(args, 'skipVerification')) patch.skipVerification = args.skipVerification === true ? true : false
       if (has(args, 'tags')) {
         const tags = args.tags ?? []

package/src/host/verification-gate.ts

@@ -18,17 +18,36 @@
  * - an anomaly (timeout, authentication, unparseable answer, an unusable judge
  *   route) is recorded separately from a quality verdict and is never treated
  *   as one;
+ * - exhausting the anomaly budget does NOT judge the card: an environment that
+ *   cannot answer is not the work failing, so the cycle is held open with no
+ *   judge call until a user clears the recorded anomalies (issue #1828);
+ * - an attempt the time budget ends before any verdict is recorded as its own
+ *   stage and charged to no budget at all (issue #1828);
+ * - an INVALID acceptance (a veto whose required evidence is missing,
+ *   unlocatable, or aimed at the empty-work baseline) is recorded in its own
+ *   stage, spends its OWN bounded budget, and never consumes a quality attempt
+ *   or fails the card; when that budget is spent the cycle is held for a human
+ *   exactly like a spent anomaly budget;
  * - concurrent completion calls for one execution share one acceptance.
+
+ * The validity check itself is program-level (`assessAcceptanceValidity` in
+ * `core/verification.ts`), applied after the judge answers and BEFORE any
+ * quality verdict is written: a stronger prompt alone could not enforce it.
  */
 import type { PreToolDecision } from '@deepseek-ai/dsh-tools'
 import type { LlmRuntime } from '@deepseek-ai/dsh-llm'
 import {
   MAX_EXCEPTION_ATTEMPTS,
+  MAX_INVALID_ATTEMPTS,
   MAX_QUALITY_ATTEMPTS,
   exceptionAttempts,
   hasExceptionBudget,
   finalFailureReason,
+  hasInvalidBudget,
   hasQualityBudget,
+  invalidAttempts,
+  invalidAcceptanceFeedback,
+  invalidHoldReason,
   passedAttempt,
   qualityAttempts,
   qualityFeedback,
@@ -37,6 +56,7 @@ import {
 } from '../core/verification.ts'
 import { collectEvidence, evidenceEvents, runAcceptance } from './verification-runner.ts'
 import { renderWorkspaceEvidence, type WorkspaceChangeSource } from './workspace-evidence.ts'
+import { DEFAULT_VERIFICATION_BUDGET_MS, verificationBudgetMs, verificationCallTimeoutMs } from '../core/verification-budget.ts'
 import type { HostTaskLedger } from '../host-ledger.ts'
 import type { ExecutionRecord, TaskRecord } from '../core/tasks.ts'
 
@@ -58,6 +78,16 @@ export interface GoalVerificationGateDeps {
    * that serves none) simply means the judge sees the trajectory alone.
    */
   workspaceChanges?: () => WorkspaceChangeSource | undefined
+  /**
+   * Ceiling of one judge request, read per acceptance (a row setting). Absent
+   * keeps the default, so a programmatic mount still judges.
+   */
+  callTimeoutMs?: () => number
+  /**
+   * Total ceiling of one acceptance attempt, read per acceptance (a row
+   * setting). Absent keeps the default.
+   */
+  budgetMs?: () => number
   logger: { warn(message: string, ...rest: unknown[]): void }
   now?: () => number
 }
@@ -140,6 +170,80 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
     )
   }
 
+  /**
+   * Hold the cycle open after its non-quality budget ran out.
+   *
+   * A judge route that times out, cannot authenticate or cannot be resolved is
+   * the ENVIRONMENT failing, not the work, so this records the attempt and
+   * refuses the completion claim without writing a `failedReason` and without
+   * blocking the goal (issue #1828). The execution therefore survives for a
+   * user who fixes the environment and clears the recorded anomalies, instead
+   * of carrying a verdict that only the clock produced.
+   */
+  const hold = (
+    taskId: string,
+    executionId: string,
+    verification: ExecutionVerification,
+    message: string,
+    detail: string,
+    code: string,
+  ): PreToolDecision => {
+    write(taskId, executionId, { ...verification, inFlight: undefined })
+    return deny(bounded(message), code, detail)
+  }
+
+  /** The refusal one recorded anomaly returns to the fixing agent. */
+  const anomalyRefusal = (spend: ExecutionVerification, error: string | undefined): PreToolDecision =>
+    deny(
+      bounded('[任务看板 · 验收异常] ' + (error ?? 'unknown') + '\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 ' + exceptionAttempts(spend).length + '/' + MAX_EXCEPTION_ATTEMPTS + '）。请修复环境后再次调用 update_goal(action: complete)。'),
+      'TASK_BOARD_VERIFICATION_ANOMALY',
+      error,
+    )
+
+  /**
+   * The refusal one recorded INVALID acceptance returns.
+   *
+   * The claim is still refused (no pass record exists), but the agent is told
+   * the veto itself was unusable and is explicitly NOT asked to repair anything
+   * on that basis. The reason and scores stay recorded for review; the quality
+   * budget is untouched.
+   */
+  const invalidRefusal = (spend: ExecutionVerification, attempt: VerificationAttempt): PreToolDecision =>
+    deny(
+      bounded(invalidAcceptanceFeedback(attempt, MAX_INVALID_ATTEMPTS - invalidAttempts(spend).length)),
+      'TASK_BOARD_VERIFICATION_INVALID',
+      attempt.error,
+    )
+
+  /**
+   * Hold a cycle whose invalid-acceptance budget is spent.
+   *
+   * No usable veto was ever produced, so the board neither passes nor fails the
+   * card: it stops calling the judge and leaves the execution for a human. Only
+   * an explicit user action (or a rerun) resumes it, which is what bounds the
+   * retries.
+   */
+  const invalidHeld = (taskId: string, executionId: string, spend: ExecutionVerification): PreToolDecision =>
+    hold(
+      taskId,
+      executionId,
+      spend,
+      '[任务看板 · 验收无效] ' + invalidHoldReason(invalidAttempts(spend).length),
+      'acceptance produced no usable veto; a user action must clear the recorded invalid acceptances',
+      'TASK_BOARD_VERIFICATION_INVALID',
+    )
+
+  /** The refusal a spent anomaly budget returns: no verdict, and no card failure. */
+  const anomalyHeld = (taskId: string, executionId: string, spend: ExecutionVerification): PreToolDecision =>
+    hold(
+      taskId,
+      executionId,
+      spend,
+      '[任务看板 · 验收异常] 验收异常额度已用尽（' + MAX_EXCEPTION_ATTEMPTS + '/' + MAX_EXCEPTION_ATTEMPTS + '）：本执行周期不再调用裁判模型，也不把这次执行判为失败。\n这是环境异常而非质量判定：请如实告诉用户验收环境当前不可用，由用户修复环境后用 task_board_manage(action=reset-verification) 清除已记录的异常，再重新完成目标。',
+      'acceptance anomaly budget exhausted; a user action must clear the recorded anomalies',
+      'TASK_BOARD_VERIFICATION_ANOMALY',
+    )
+
   /** Record one attempt and decide whether the completion claim may proceed. */
   const settle = async (input: {
     task: TaskRecord
@@ -171,14 +275,10 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
       const attempts = [...verification.attempts, attempt]
       const spend = { ...verification, attempts, inFlight: undefined }
       if (exceptionAttempts(spend).length >= MAX_EXCEPTION_ATTEMPTS) {
-        return finalize(task.id, execution.id, spend, '验收异常达到上限：' + attempt.error, agent)
+        return anomalyHeld(task.id, execution.id, spend)
       }
       write(task.id, execution.id, spend)
-      return deny(
-        bounded('[任务看板 · 验收异常] ' + attempt.error + '\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 ' + exceptionAttempts(spend).length + '/' + MAX_EXCEPTION_ATTEMPTS + '）。请修复环境后再次调用 update_goal(action: complete)。'),
-        'TASK_BOARD_VERIFICATION_ANOMALY',
-        attempt.error,
-      )
+      return anomalyRefusal(spend, attempt.error)
     }
     write(task.id, execution.id, baselines)
     const llm = deps.llm?.()
@@ -201,14 +301,19 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
       }
       const spend = { ...verification, attempts: [...verification.attempts, attempt], inFlight: undefined }
       if (exceptionAttempts(spend).length >= MAX_EXCEPTION_ATTEMPTS) {
-        return finalize(task.id, execution.id, spend, '验收异常达到上限：' + attempt.error, agent)
+        return anomalyHeld(task.id, execution.id, spend)
       }
       write(task.id, execution.id, spend)
       return deny(bounded('[任务看板 · 验收异常] ' + attempt.error), 'TASK_BOARD_VERIFICATION_ANOMALY', attempt.error)
     }
     const session = (agent as { session?: unknown }).session
     const evidence = collectEvidence(session, objective, execution.startedAt)
-    const acceptance = AbortSignal.timeout(600_000)
+    // Both ceilings are row settings read live: raising one unblocks a card
+    // whose acceptance is stuck on a slow route without a plugin reload.
+    const callTimeout = deps.callTimeoutMs?.() ?? verificationCallTimeoutMs(undefined)
+    const budget = deps.budgetMs?.() ?? DEFAULT_VERIFICATION_BUDGET_MS
+    const deadline = now() + budget
+    const acceptance = AbortSignal.timeout(budget)
     // The host's own record of what changed on disk is offered next to the
     // trajectory; an unavailable service or a failed read degrades to the
     // trajectory alone instead of failing an acceptance already under way.
@@ -230,21 +335,42 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
       context: workspace.text === '' ? undefined : workspace.text,
       workspaceFiles: workspace.files,
       signal: acceptance,
+      deadline,
+      callTimeoutMs: callTimeout,
       now,
     })
     const attempt = result.attempt
     const attempts = [...verification.attempts, attempt]
     const spend: ExecutionVerification = { ...verification, attempts, inFlight: undefined }
+    // A budget stop is charged to no budget at all (issue #1828): the judge route
+    // may be healthy and the machine simply out of time, so it is neither an
+    // anomaly nor a verdict, and it must never close the card.
+    if (attempt.stage === 'budget') {
+      return hold(
+        task.id,
+        execution.id,
+        spend,
+        '[任务看板 · 验收未完成] ' + (attempt.error ?? '时间预算耗尽') + '\n本次没有产生任何质量判定，也不消耗质量或异常额度。请稍后重试；若裁判路由确实很慢，可调大验收的单次调用上限或总时间预算。',
+        attempt.error ?? 'the acceptance time budget ran out before a verdict',
+        'TASK_BOARD_VERIFICATION_BUDGET',
+      )
+    }
     if (attempt.stage === 'exception') {
       if (exceptionAttempts(spend).length >= MAX_EXCEPTION_ATTEMPTS) {
-        return finalize(task.id, execution.id, spend, '验收异常达到上限：' + (attempt.error ?? 'unknown'), agent)
+        return anomalyHeld(task.id, execution.id, spend)
       }
       write(task.id, execution.id, spend)
-      return deny(
-        bounded('[任务看板 · 验收异常] ' + (attempt.error ?? 'unknown') + '\n这是验收异常而非质量判定，本次未消耗质量验收额度（已用 ' + exceptionAttempts(spend).length + '/' + MAX_EXCEPTION_ATTEMPTS + '）。请修复环境后再次调用 update_goal(action: complete)。'),
-        'TASK_BOARD_VERIFICATION_ANOMALY',
-        attempt.error,
-      )
+      return anomalyRefusal(spend, attempt.error)
+    }
+    // An invalid acceptance is recorded and returned to the agent, but it is
+    // NOT a quality verdict: it spends its own bounded budget, never the
+    // quality one, and it never fails the card.
+    if (attempt.stage === 'invalid') {
+      if (invalidAttempts(spend).length >= MAX_INVALID_ATTEMPTS) {
+        return invalidHeld(task.id, execution.id, spend)
+      }
+      write(task.id, execution.id, spend)
+      return invalidRefusal(spend, attempt)
     }
     if (attempt.passed) {
       write(task.id, execution.id, spend)
@@ -255,7 +381,11 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
       return finalize(task.id, execution.id, spend, finalFailureReason(attempt, used, verification.contract.threshold), agent)
     }
     write(task.id, execution.id, spend)
-    return deny(bounded(qualityFeedback(attempt, MAX_QUALITY_ATTEMPTS - used)), 'TASK_BOARD_VERIFICATION_FAILED', attempt.findings.join('\n'))
+    return deny(
+      bounded(qualityFeedback(attempt, MAX_QUALITY_ATTEMPTS - used)),
+      'TASK_BOARD_VERIFICATION_FAILED',
+      locatedFindingDetail(attempt),
+    )
   }
 
   /** Evaluate one tool call; undefined means "not this gate's business". */
@@ -279,9 +409,21 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
         verification.failedReason,
       )
     }
-    if (!hasQualityBudget(verification) && !hasExceptionBudget(verification)) {
+    // A spent INVALID budget comes first: the judge produced no usable veto, so
+    // calling it again would only burn quota against a budget that determines
+    // nothing, and the card must stay open for a human rather than be failed.
+    if (!hasInvalidBudget(verification)) {
+      return invalidHeld(binding.task.id, binding.execution.id, verification)
+    }
+    if (!hasQualityBudget(verification)) {
       return finalize(binding.task.id, binding.execution.id, verification, 'goal 验收额度已耗尽，本次 execution 判失败。', exec.agent)
     }
+    // A spent anomaly budget is an environment that could not answer, not a
+    // judged work: the claim is refused and NO judge call is spent until a user
+    // clears the recorded anomalies (issue #1828).
+    if (!hasExceptionBudget(verification)) {
+      return anomalyHeld(binding.task.id, binding.execution.id, verification)
+    }
     const key = binding.execution.id
     const running = inFlight.get(key)
     if (running !== undefined) return await running
@@ -325,6 +467,20 @@ export function createGoalVerificationGate(deps: GoalVerificationGateDeps): (exe
   }
 }
 
+/**
+ * The structured detail of one quality refusal: the judge's own findings, in
+ * the order the acceptance recorded them, so the denial carries exactly the
+ * located evidence the report shows.
+ */
+function locatedFindingDetail(attempt: VerificationAttempt): string {
+  const lines: string[] = []
+  for (const finding of attempt.criterionFindings ?? []) {
+    lines.push('[' + finding.criterionId + ' ' + finding.location + '] "' + finding.quote + '"')
+  }
+  if (lines.length === 0) lines.push(...attempt.findings)
+  return lines.join('\n')
+}
+
 /** The bare execution prompt, used when the goal service carries no objective. */
 function taskPrompt(task: TaskRecord): string {
   return task.prompt.trim() !== '' ? task.prompt : task.title