@principles/core 1.270.5 → 1.272.0

package/dist/runtime-v2/internalization/evaluator-runner.js

@@ -1,7 +1,11 @@
 import { isEvaluatorOutputV2 } from './evaluator-output.js';
+// PRI-634 A2 (authority migration): gate necessity derives from the durable
+// Artificer artifact, not from optional LLM output shape.
+import { assessArtificerCodeBearing } from './artificer-code-bearing.js';
 import { PDRuntimeError, isPDErrorCategory } from '../error-categories.js';
 import { hydratePITaskRecord, createPITaskDiagnosticJson, mergePITaskMetadata } from './pitask-metadata.js';
-import { EvaluatorPromptBuilder } from './evaluator-prompt-builder.js';
+import { HUMAN_REVIEW_REASON, planOwnerVerdictOverrideResume, markOwnerResolutionApplied, computeArtifactContentHash, } from './owner-review.js';
+import { EvaluatorPromptBuilder, deriveRequirementLedger } from './evaluator-prompt-builder.js';
 import { reconcileLineageEcho } from './peer-runner-contracts.js';
 import { BasePeerRunner } from '../runner/base-peer-runner.js';
 import { EVALUATOR_STAGE1_MANIFEST, EVALUATOR_STAGE2_MANIFEST } from './context-manifests.js';
@@ -17,6 +21,31 @@ import { canonicalizeToolKind } from './rule-context-v2.js';
 function isRecordValue(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
+/**
+ * PRI-634: resolve a golden-trace case's target path across the host tool
+ * schemas actually observed on real chains.
+ *
+ * Golden-trace params are echoed verbatim from the host trajectory
+ * (behavior-example-pack-assembler `params: parsedParams`), so the field name
+ * follows whatever the host tool used — the dominant write-tool schema spells
+ * it `file_path` (OpenClaw / Claude Code), while PRI-485's v2 generator only
+ * read `path`. Reading a single spelling made v2 auto-generation structurally
+ * unreachable: the merged adversarial set stayed empty, the deterministic gate
+ * never ran, and an LLM-declared `adversarialResult.passed = true` silently
+ * stood in for a real replay (chain 48371236).
+ *
+ * Returns null when neither spelling yields a non-empty string.
+ */
+function resolveCasePathParam(params) {
+    if (!isRecordValue(params))
+        return null;
+    for (const key of ['path', 'file_path']) {
+        const raw = params[key];
+        if (typeof raw === 'string' && raw.trim() !== '')
+            return raw;
+    }
+    return null;
+}
 /**
  * Extract scribeArtifactId from an artificer artifact's contentJson (PRD Decision 12).
  * The contentJson is untrusted — parsed defensively with type guards, never as-cast
@@ -132,6 +161,8 @@ export class EvaluatorRunner extends BasePeerRunner {
      * Null when the deps did not inject the seeder (= repair seeding unavailable).
      */
     repairTaskSeeder;
+    /** PRI-630: runtime-authoritative tool facts; null = catalog unavailable (degraded rule in prompt) */
+    hostToolCatalog;
     constructor(deps, options) {
         super(deps, options, {
             runnerName: 'evaluator',
@@ -143,6 +174,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         this.gateDeps = options.gateDeps ?? null;
         this.repairLoopEnabledResolver = deps.isRepairLoopEnabled ?? null;
         this.repairTaskSeeder = deps.seedArtificerRepairTask ?? null;
+        this.hostToolCatalog = options.hostToolCatalog ?? null;
     }
     /**
      * Returns true iff the evaluator→artificer repair loop feature flag is on.
@@ -179,6 +211,8 @@ export class EvaluatorRunner extends BasePeerRunner {
                 });
                 continue;
             }
+            const depPi = hydratePITaskRecord(depTask);
+            const dependencyRepairPayload = depPi?.repairPayload;
             const artifacts = await this.artifactStore.listBySourceTaskId(depId);
             if (artifacts.length > 0) {
                 const [firstArtifact] = artifacts;
@@ -211,12 +245,19 @@ export class EvaluatorRunner extends BasePeerRunner {
                 const contextRefs = scribeContent && scribeRef
                     ? [artifactRef, scribeRef]
                     : [artifactRef];
+                // PRI-630: 修复轮 (repairPayload 存在) 时解析上轮评估上下文
+                let previousEvaluation;
+                if (dependencyRepairPayload) {
+                    previousEvaluation = await this.resolvePreviousEvaluation(taskId, dependencyRepairPayload, firstArtifact.contentJson);
+                }
                 return {
                     contextHash: BasePeerRunner.hashContextRefs(contextRefs),
                     artificerArtifact: firstArtifact.contentJson,
                     sourceArtificerArtifactId: firstArtifact.artifactId,
                     scribeArtifact: scribeContent,
                     sourceScribeArtifactId: scribeRef,
+                    ...(dependencyRepairPayload !== undefined ? { dependencyRepairPayload } : {}),
+                    ...(previousEvaluation !== undefined ? { previousEvaluation } : {}),
                 };
             }
         }
@@ -312,6 +353,116 @@ export class EvaluatorRunner extends BasePeerRunner {
      * Build the evaluator prompt with the given manifest's resolved context.
      * Shared by single-stage and two-stage paths.
      */
+    /**
+     * PRI-630 收敛契约 (SPEC §18.1): 解析上轮评估上下文 — 从 dependency
+     * artificer 的 repairPayload.sourceEvaluatorTaskId 找到上轮 evaluator,
+     * 读取其最近 principle artifact,按 rc-1/rc-2 守卫解析 evaluation 字段。
+     * requirements 用稳定 id (req-1..N, 上轮 requiredChanges 顺序)。
+     * 解析失败 → 结构化降级事件 + undefined (保持既有行为,可观测)。
+     */
+    async resolvePreviousEvaluation(taskId, repairPayload, repairArtifactContentJson) {
+        const priorTaskId = repairPayload.sourceEvaluatorTaskId;
+        const priorArtifactJson = await this.artifactStore
+            .listBySourceTaskId(priorTaskId)
+            .then((artifacts) => {
+            let latest = null;
+            for (const a of artifacts) {
+                if (a.artifactKind !== 'principle')
+                    continue;
+                if (!latest || a.updatedAt > latest.updatedAt)
+                    latest = a;
+            }
+            return latest?.contentJson ?? null;
+        })
+            .catch(() => null);
+        if (priorArtifactJson === null) {
+            this.emitEvent('previous_evaluation_context_degraded', taskId, {
+                priorEvaluatorTaskId: priorTaskId,
+                reason: 'prior_evaluation_artifact_unavailable',
+                repairIteration: repairPayload.repairIteration,
+            });
+            return undefined;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(priorArtifactJson);
+        }
+        catch {
+            this.emitEvent('previous_evaluation_context_degraded', taskId, {
+                priorEvaluatorTaskId: priorTaskId,
+                reason: 'prior_evaluation_artifact_unparseable',
+            });
+            return undefined;
+        }
+        if (typeof parsed !== 'object' || parsed === null)
+            return undefined;
+        // runtime-contract-exempt: ERR-001 object-guarded unknown property extraction; typeof guard follows immediately
+        const { evaluation } = parsed;
+        if (typeof evaluation !== 'object' || evaluation === null) {
+            this.emitEvent('previous_evaluation_context_degraded', taskId, {
+                priorEvaluatorTaskId: priorTaskId,
+                reason: 'prior_evaluation_shape_invalid',
+            });
+            return undefined;
+        }
+        const ev = evaluation;
+        const decision = typeof ev.decision === 'string' ? ev.decision : 'needs_revision';
+        const score = typeof ev.score === 'number' && Number.isFinite(ev.score) ? Math.min(1, Math.max(0, ev.score)) : 0;
+        const toStringArray = (v, cap) => {
+            if (!Array.isArray(v))
+                return [];
+            const out = [];
+            for (const item of v.slice(0, cap)) {
+                if (typeof item === 'string' && item.trim() !== '')
+                    out.push(item.slice(0, 500));
+            }
+            return out;
+        };
+        const concerns = toStringArray(ev.concerns, 10);
+        const requiredChanges = toStringArray(ev.requiredChanges, 10);
+        // PRI-630 P1 评审修复: 需求身份跨轮稳定 — 上轮 echo 的 requirementLedger
+        // (若有) 中 still_open/regressed 条目保留原 id 与原 statement;本轮
+        // requiredChanges 的非重述项作为新需求从最大序号递增。无 ledger 时
+        // (首个修复轮) 退回顺序编号。
+        let prevLedger;
+        if (Array.isArray(ev.requirementLedger)) {
+            prevLedger = [];
+            for (const entry of ev.requirementLedger) {
+                if (entry === null || typeof entry !== 'object')
+                    continue;
+                const rec = entry;
+                if (typeof rec.id !== 'string' || typeof rec.statement !== 'string')
+                    continue;
+                if (rec.status !== 'resolved' && rec.status !== 'still_open' && rec.status !== 'regressed')
+                    continue;
+                prevLedger.push({ id: rec.id, statement: rec.statement, status: rec.status });
+            }
+        }
+        const requirements = deriveRequirementLedger(prevLedger, requiredChanges);
+        // 修复说明: 当前 (被修复) artificer artifact 的声明性摘要 — 有界提取
+        let repairSummary;
+        try {
+            const art = JSON.parse(repairArtifactContentJson);
+            if (typeof art === 'object' && art !== null) {
+                // runtime-contract-exempt: ERR-001 object-guarded unknown property extraction; typeof guard follows immediately
+                const { implementationSummary } = art;
+                if (typeof implementationSummary === 'string' && implementationSummary.trim() !== '') {
+                    repairSummary = implementationSummary.slice(0, 800);
+                }
+            }
+        }
+        catch {
+            repairSummary = undefined;
+        }
+        return {
+            decision,
+            score,
+            concerns,
+            requirements,
+            repairIteration: repairPayload.repairIteration,
+            ...(repairSummary !== undefined ? { repairSummary } : {}),
+        };
+    }
     buildEvaluatorPrompt(taskId, context, manifest) {
         let parsedArtificerArtifact = null;
         if (context.artificerArtifact) {
@@ -346,6 +497,8 @@ export class EvaluatorRunner extends BasePeerRunner {
             artificerArtifact: parsedArtificerArtifact,
             scribeArtifact: parsedScribeArtifact,
             sourceArtificerArtifactId: context.sourceArtificerArtifactId ?? '',
+            previousEvaluation: context.previousEvaluation,
+            hostToolCatalog: this.hostToolCatalog ?? undefined,
         });
         return message;
     }
@@ -362,7 +515,12 @@ export class EvaluatorRunner extends BasePeerRunner {
         });
     }
     async validateOutput(output, taskId, context) {
-        const result = await this.validator.validate(output, taskId, context.sourceArtificerArtifactId ?? undefined);
+        // PRI-630 P1 评审修复: 修复轮把上轮 requirement ids 传入做完整覆盖校验
+        // (缺 priorRequirementStatuses 或漏 id → output_invalid),不再仅靠 prompt。
+        const convergence = context.previousEvaluation
+            ? { expectedRequirements: context.previousEvaluation.requirements.map((r) => ({ id: r.id, statement: r.statement })) }
+            : undefined;
+        const result = await this.validator.validate(output, taskId, context.sourceArtificerArtifactId ?? undefined, convergence);
         // Trust-boundary: validator is an injected dependency returning `string | undefined`
         // for errorCategory. We must not `as`-cast; validate at runtime (ERR-001, ERR-005).
         const rawCategory = result.errorCategory;
@@ -457,21 +615,64 @@ export class EvaluatorRunner extends BasePeerRunner {
             });
         }
         // ── PRI-426: single-round adversarial sandbox replay ──
-        // Runs only when (a) the output is V2 (code-bearing), (b) gateDeps is
-        // injected, and (c) passive review passed (LLM short-circuits to
-        // needs_revision when any of the 3 dimensions fail, so by the time we get
-        // here with decision='approved' the passive review already passed).
+        // PRI-634 A2 (authority migration): gate necessity is decided by the
+        // DURABLE Artificer artifact — assessArtificerCodeBearing() mirrors
+        // assembleRuleArtifact()'s static preconditions exactly — never by
+        // whether the LLM happened to emit optional V2 fields
+        // (isEvaluatorOutputV2). A V2-shaped output over a non-code-bearing
+        // Artificer keeps the legacy behavior (attempt replay, degrade with
+        // telemetry) so the old path stays observable.
         //
         // PRI-423 contract: adversarialCasesToGoldenTrace yields an all-negative
         // trace. We MUST merge ≥1 positive case from the Artificer golden trace
         // before replaying, otherwise the merged trace fails validateGoldenTrace.
         //
-        // This block never throws into the caller — a sandbox/gate failure degrades
-        // to adversarialResult.passed=false with a structured reason (ERR-018).
-        // The principle artifact is already persisted, so prompt-channel fallback
-        // remains available regardless of replay outcome (PRD Decision 11d §h).
+        // The replay itself never throws into the caller — a sandbox/gate failure
+        // degrades to adversarialResult.passed=false with a structured reason
+        // (ERR-018). The principle artifact is already persisted, so
+        // prompt-channel fallback remains available regardless of replay outcome
+        // (PRD Decision 11d §h). The ONE deliberate exception is the R2 wiring
+        // guard below: a code-bearing artifact without gateDeps fails loud
+        // (capability_missing, permanent) instead of succeeding un-gated.
         let finalOutput = output;
-        if (isEvaluatorOutputV2(output) && this.gateDeps) {
+        const gateAssessment = assessArtificerCodeBearing(context.artificerArtifact);
+        const outputWantsGate = isEvaluatorOutputV2(output);
+        const evaluatorDecision = output.evaluation.decision;
+        if (evaluatorDecision !== 'approved') {
+            // Passive review short-circuit: the LLM emits needs_revision/rejected
+            // when its review fails — no gate needed. Previously silent inside
+            // runAdversarialReplay; now observable at the gate decision point
+            // (Runtime Contract Rule 9).
+            if (gateAssessment.codeBearing || outputWantsGate) {
+                this.emitEvent('adversarial_replay_skipped', taskId, {
+                    runId,
+                    reason: 'evaluation_not_approved',
+                    nextAction: 'repair_loop_or_next_review_round',
+                });
+            }
+        }
+        else if (!this.gateDeps) {
+            this.emitEvent('adversarial_replay_skipped', taskId, {
+                runId,
+                reason: 'gate_deps_not_injected',
+                nextAction: 'wire_gateDeps_createProductionGateDeps_into_evaluator_runner_assembly',
+            });
+            if (gateAssessment.codeBearing) {
+                // PRI-634 R2 (wiring regression guard): a code-bearing Artificer
+                // artifact REQUIRES the deterministic gate. Proceeding would yield
+                // succeeded + adversarialResult=null — the exact state that broke
+                // chain 48371236. capability_missing is a permanent error: the task
+                // fails loud (markTaskFailed) instead of retry-burning LLM budget —
+                // a missing gateDeps is an assembly defect, not a transient fault.
+                return this.retryOrFail({
+                    taskId,
+                    task,
+                    errorCategory: 'capability_missing',
+                    failureReason: `PRI-634 R2: Artificer artifact ${context.sourceArtificerArtifactId ?? '(unknown)'} is code-bearing but EvaluatorRunner was assembled without gateDeps — deterministic adversarial replay cannot run. Fix: inject gateDeps: createProductionGateDeps() into the EvaluatorRunner assembly.`,
+                });
+            }
+        }
+        else if (gateAssessment.codeBearing || outputWantsGate) {
             const replayOutcome = await this.runAdversarialReplay(output, taskId, runId, context);
             if (replayOutcome.updatedOutput) {
                 finalOutput = replayOutcome.updatedOutput;
@@ -503,6 +704,30 @@ export class EvaluatorRunner extends BasePeerRunner {
                     });
                 }
             }
+            else if (gateAssessment.codeBearing) {
+                // ── PRI-634 R3 (terminal-state invariant) ──
+                // A code-bearing Artificer artifact that reached `approved` MUST leave
+                // this block carrying an adversarialResult. Anything else reproduces
+                // the chain-48371236 terminal state — approved with the deterministic
+                // gate never executed, adversarialResult=null, and therefore no
+                // pi-rule-* downstream — regardless of WHICH cause prevented the
+                // replay (zero adversarial cases, no positive case, unparseable
+                // artifact, conversion drift…). Telemetry is not recovery: a task that
+                // ends `succeeded` here is indistinguishable from the original defect.
+                //
+                // errorCategory is `input_invalid` (already listed in
+                // permanentErrorCategories) rather than `capability_missing`: the gate
+                // IS wired correctly (R2 owns the wiring case) — the upstream
+                // Artificer content simply cannot be turned into gate input. Permanent
+                // because retrying the LLM cannot make the Artificer emit the missing
+                // affectedTools / positive-case path.
+                return this.retryOrFail({
+                    taskId,
+                    task,
+                    errorCategory: 'input_invalid',
+                    failureReason: `PRI-634 R3: Artificer artifact ${context.sourceArtificerArtifactId ?? '(unknown)'} is code-bearing and the evaluator approved it, but the deterministic adversarial replay did not run (reason: ${replayOutcome.skipReason ?? 'unknown'}). Refusing to report succeeded with adversarialResult=null — that is the chain-48371236 terminal state. Fix: have the Artificer emit affectedTools plus at least one positive golden-trace case carrying a path, or supply LLM adversarialCases.`,
+                });
+            }
         }
         // ── P0 (verdict drift): verdict + completion intent 原子落库 ──
         // 必须先于一切治理 side effect (validate bearer / seed repair / rule
@@ -568,7 +793,7 @@ export class EvaluatorRunner extends BasePeerRunner {
      */
     async applyEvaluatorDecisionEffects(args) {
         const { taskId, runId, finalOutput, task, artifactId, contextHash, sourceArtificerArtifactId } = args;
-        const { decision } = finalOutput.evaluation;
+        const decision = args.decisionOverride ?? finalOutput.evaluation.decision;
         // ── Evaluator-specific: validate principle-bearing Scribe artifact ──
         // This is the critical business logic: approved evaluator must validate
         // the Scribe principle artifact, NOT the Artificer plan artifact.
@@ -632,6 +857,10 @@ export class EvaluatorRunner extends BasePeerRunner {
         if (decision === 'needs_revision' && this.isRepairLoopEnabled()) {
             const repairOutcome = await this.maybeSeedArtificerRepair(taskId, { runId, output: finalOutput, sourceArtificerArtifactId });
             if (repairOutcome.kind === 'max_iterations_reached') {
+                // PRI-629: budget 耗尽(decision-capable)与 seed 失败(recovery)拆分原因码
+                const reasonCode = repairOutcome.detail === 'budget_exhausted'
+                    ? HUMAN_REVIEW_REASON.evaluatorRepairBudgetExhausted
+                    : HUMAN_REVIEW_REASON.evaluatorRepairSeedFailed;
                 // Fail loud (rc-9, EP-03, ERR-002): mark the task needs_human_review
                 // so it does NOT stay in 'leased' state (which would cause the lease
                 // to expire and the evaluator to re-run the same verdict infinitely).
@@ -639,14 +868,14 @@ export class EvaluatorRunner extends BasePeerRunner {
                 // fail-closed: 写失败 throw → retry_wait → 入口门 resume 同一效果,
                 // 不问 LLM;禁止吞错后继续 (intent applied ⇔ effect 已 durable)。
                 const resultRef = `${this.config.resultRefPrefix}://${runId}`;
-                await this.markNeedsHumanReviewOrThrow(taskId, runId, 'repair_loop_max_iterations_or_seed_failure');
+                await this.markNeedsHumanReviewOrThrow(taskId, { runId, reasonCode, sourceArtifactId: artifactId });
                 this.emitEvent('task_needs_human_review', taskId, {
                     attemptCount: task.attemptCount,
                     resultRef,
                     evaluationDecision: finalOutput.evaluation.decision,
                     evaluationScore: finalOutput.evaluation.score,
                     ruleArtifactId: null,
-                    reason: 'repair_loop_max_iterations_or_seed_failure',
+                    reason: `repair_loop_${reasonCode}`,
                 });
                 return {
                     kind: 'human_review',
@@ -711,9 +940,39 @@ export class EvaluatorRunner extends BasePeerRunner {
      * effect,不问 LLM;禁止吞错后让 caller 标 intent applied
      * (intent applied ⇔ 其 durable effect 已 materialize)。
      */
-    async markNeedsHumanReviewOrThrow(taskId, runId, reason) {
+    async markNeedsHumanReviewOrThrow(taskId, review) {
+        const { runId, reasonCode, sourceArtifactId } = review;
         try {
-            await this.stateManager.updateTask(taskId, { status: 'needs_human_review' });
+            // PRI-629: status + humanReviewContext 同一次 task-row mutation 原子落库
+            // (SPEC §4 — context 缺失的 NHR 是 legacy,只能靠推断)。
+            const raw = await this.stateManager.getTask(taskId);
+            if (!raw)
+                throw new Error(`task ${taskId} not found`);
+            const piTask = hydratePITaskRecord(raw);
+            if (!piTask)
+                throw new Error(`task ${taskId} not hydratable`);
+            let sourceArtifactHash;
+            try {
+                const artifact = await this.artifactStore.getArtifactById(sourceArtifactId);
+                if (artifact)
+                    sourceArtifactHash = computeArtifactContentHash(artifact.contentJson);
+            }
+            catch {
+                sourceArtifactHash = undefined; // hash 可选 — capability 侧要求 artifact 存在,届时重算
+            }
+            const context = {
+                reasonCode,
+                sourceRunId: runId,
+                sourceArtifactId,
+                ...(sourceArtifactHash !== undefined ? { sourceArtifactHash } : {}),
+                revisionEpoch: piTask.revisionCount ?? 0,
+                createdAt: new Date().toISOString(),
+            };
+            const merged = mergePITaskMetadata(piTask, { humanReviewContext: context });
+            await this.stateManager.updateTask(taskId, {
+                status: 'needs_human_review',
+                diagnosticJson: createPITaskDiagnosticJson(merged),
+            });
             // read-back invariant (INV-2): 只有 effect durable 才允许 caller 标 applied
             const current = await this.stateManager.getTask(taskId);
             if (!current || current.status !== 'needs_human_review') {
@@ -723,7 +982,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         catch (err) {
             this.emitEvent('repair_loop_mark_review_failed', taskId, {
                 runId,
-                reason,
+                reason: reasonCode,
                 errorMessage: err instanceof Error ? err.message : String(err),
                 nextAction: 'task_will_retry_then_resume_completion_intent_without_llm',
             });
@@ -797,6 +1056,14 @@ export class EvaluatorRunner extends BasePeerRunner {
      */
     async maybeResumePendingIntent(taskId, leasedTask) {
         const piTask = hydratePITaskRecord(leasedTask);
+        // ── PRI-629: pending Owner Resolution 优先于一切 (SPEC §10) ──
+        // Owner accept_current / reject_current 已 durable 记录且任务被翻回
+        // pending — 本次 run 应用 override,绝不重新调用 LLM。applied 但未
+        // terminal 的 crash 窗口同样由此收敛 (SPEC §30)。
+        const ownerOverride = piTask ? planOwnerVerdictOverrideResume(piTask) : null;
+        if (ownerOverride) {
+            return await this.applyOwnerVerdictOverrideAndFinalize(taskId, leasedTask, ownerOverride);
+        }
         const intent = piTask?.completionIntent;
         if (!piTask || !intent || intent.status !== 'pending') {
             // P0 (INV-1/INV-5): applied 但任务未 terminal (标 applied 后、
@@ -925,6 +1192,117 @@ export class EvaluatorRunner extends BasePeerRunner {
             attemptCount: leasedTask.attemptCount,
         };
     }
+    /**
+     * PRI-629: 应用 Owner verdict override 并收敛 terminal。
+     *
+     * 顺序 (SPEC §10/§30): 恢复 durable output → 幂等效果 (override decision)
+     * → completion intent 标 applied → resolution 标 applied → markTaskSucceeded。
+     * 任何 crash 窗口重放同一 resolution,不重新调用 LLM。机器 verdict
+     * (runnerDecision) 永不改写。
+     */
+    async applyOwnerVerdictOverrideAndFinalize(taskId, leasedTask, plan) {
+        const { resolution, overrideDecision } = plan;
+        this.emitEvent('owner_resolution_applying', taskId, {
+            resolutionId: resolution.resolutionId,
+            action: resolution.action,
+            machineDecision: resolution.machineDecision,
+            effectiveDecision: overrideDecision,
+            sourceRunId: resolution.sourceRunId,
+        });
+        // 恢复裁决时的 durable output — decision 必须与 resolution 记录的机器判定一致
+        const output = await this.recoverIntentOutput(taskId, resolution.sourceRunId, resolution.machineDecision);
+        // SPEC §20 纵深防御: 确定性对抗门失败不允许 approved override (capability
+        // 层已挡一道;此处防事实漂移窗口)。
+        if (overrideDecision === 'approved'
+            && isEvaluatorOutputV2(output)
+            && output.adversarialResult
+            && output.adversarialResult.passed === false) {
+            this.emitEvent('owner_resolution_rejected_by_policy', taskId, {
+                resolutionId: resolution.resolutionId,
+                reason: 'deterministic_hard_gate_failed',
+                nextAction: 'owner_may_choose_revise_once_or_reject_current',
+            });
+            throw new PDRuntimeError('input_invalid', `Owner accept_current refused for task ${taskId}: deterministic adversarial gate failed (owner cannot override hard safety)`);
+        }
+        const artifactId = resolution.sourceArtifactId;
+        const contextHash = `owner-override-${resolution.resolutionId}`;
+        // rule assembly 输入由 durable lineage 重建 (与 intent resume 相同)
+        const assemblySourceId = output.sourceArtificerArtifactId ?? null;
+        let artificerContent = null;
+        if (assemblySourceId) {
+            try {
+                const rec = await this.artifactStore.getArtifactById(assemblySourceId);
+                artificerContent = rec?.contentJson ?? null;
+            }
+            catch {
+                artificerContent = null;
+            }
+        }
+        const effectResult = await this.applyEvaluatorDecisionEffects({
+            taskId,
+            runId: resolution.sourceRunId,
+            finalOutput: output,
+            task: leasedTask,
+            artifactId,
+            contextHash,
+            sourceArtificerArtifactId: assemblySourceId,
+            ruleAssemblyInput: { artificerArtifact: artificerContent, sourceArtificerArtifactId: assemblySourceId },
+            decisionOverride: overrideDecision === 'approved' ? 'approved' : 'rejected',
+        });
+        if (effectResult.kind === 'human_review') {
+            // P0 评审修复: 与 rollout 对称——override 驱动的 effects 落入 recovery
+            // NHR 时,Owner 裁决已被执行,resolution 标 applied (否则 pending 残留
+            // + Recover guard 拒绝 = 死胡同)。applied 后 Recover 放行,resume 门
+            // 确定性重放。
+            await markOwnerResolutionApplied({
+                updateDiagnosticJson: (tid, json) => this.stateManager.updateTaskDiagnosticJson(tid, json),
+                getTask: (tid) => this.stateManager.getTask(tid),
+                taskId,
+                resolutionId: resolution.resolutionId,
+                appliedAt: new Date().toISOString(),
+            });
+            return effectResult.result;
+        }
+        await this.markCompletionIntentAppliedOrThrow(taskId);
+        await markOwnerResolutionApplied({
+            updateDiagnosticJson: (tid, json) => this.stateManager.updateTaskDiagnosticJson(tid, json),
+            getTask: (tid) => this.stateManager.getTask(tid),
+            taskId,
+            resolutionId: resolution.resolutionId,
+            appliedAt: new Date().toISOString(),
+        });
+        const resultRef = `${this.config.resultRefPrefix}://${resolution.sourceRunId}`;
+        try {
+            await this.stateManager.markTaskSucceeded(taskId, resultRef);
+        }
+        catch (stateErr) {
+            this.emitEvent('mark_succeeded_failed', taskId, {
+                taskId,
+                runId: resolution.sourceRunId,
+                errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
+            });
+            throw stateErr;
+        }
+        this.emitEvent('task_succeeded', taskId, {
+            attemptCount: leasedTask.attemptCount,
+            resultRef,
+            evaluationDecision: output.evaluation.decision,
+            evaluationScore: output.evaluation.score,
+            ruleArtifactId: effectResult.ruleArtifactId,
+            ownerResolutionApplied: resolution.resolutionId,
+            effectiveDecision: overrideDecision,
+        });
+        return {
+            status: 'succeeded',
+            taskId,
+            runId: resolution.sourceRunId,
+            artifactId,
+            resultRef,
+            contextHash,
+            output,
+            attemptCount: leasedTask.attemptCount,
+        };
+    }
     /**
      * 从 runs 表恢复 intent 落库前已持久化的 validated output,并交叉核对
      * decision 与 intent 一致 (authority 记录一致性)。intent 的存在保证
@@ -985,7 +1363,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 nextAction: 'owner_manual_review_required',
                 priorRepairIteration,
             });
-            return { kind: 'max_iterations_reached' };
+            return { kind: 'max_iterations_reached', detail: 'budget_exhausted' };
         }
         // ── Slice 4: seed artificer repair task ──
         // sourceArtificerArtifactId 由 caller 解析 (fresh: context ?? output;
@@ -997,7 +1375,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 runId: evaluatorRunId,
                 reason: 'source_artificer_artifact_id_unresolved',
             });
-            return { kind: 'max_iterations_reached' };
+            return { kind: 'max_iterations_reached', detail: 'seed_failed' };
         }
         // Construct the new repairPayload (repairIteration = prior + 1).
         // The 6 fields are sourced from the current evaluator output (rc-7:
@@ -1048,7 +1426,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 runId: evaluatorRunId,
                 reason: 'seed_artificer_repair_task_not_injected',
             });
-            return { kind: 'max_iterations_reached' };
+            return { kind: 'max_iterations_reached', detail: 'seed_failed' };
         }
         try {
             const repairTaskId = await this.repairTaskSeeder({
@@ -1074,7 +1452,7 @@ export class EvaluatorRunner extends BasePeerRunner {
             // Treat as max iterations reached so the caller skips markTaskSucceeded
             // and returns succeeded — the evaluator verdict stands; only the repair
             // seeding failed, which is logged.
-            return { kind: 'max_iterations_reached' };
+            return { kind: 'max_iterations_reached', detail: 'seed_failed' };
         }
     }
     // ── Optional hooks ──────────────────────────────────────────────────────────
@@ -1129,17 +1507,20 @@ export class EvaluatorRunner extends BasePeerRunner {
     }
     // ── PRI-426: adversarial sandbox replay ─────────────────────────────────────
     /**
-     * Run a single-round adversarial sandbox replay on the evaluator's V2 output
-     * (PRD Decision 11d). Pure orchestration of pure functions:
+     * Run a single-round adversarial sandbox replay (PRD Decision 11d).
+     * PRI-634 A2/R1: the `output` is accepted in V1 shape too — a code-bearing
+     * Artificer artifact requires the gate regardless of whether the evaluator
+     * LLM emitted optional V2 fields. Only V2-shaped outputs can contribute
+     * LLM-supplied adversarialCases (checked via isEvaluatorOutputV2 below).
+     * Pure orchestration of pure functions:
      *   1. Skip if passive review failed (decision !== 'approved' is the LLM's
-     *      short-circuit signal — no code to defend).
-     *   2. Skip if no adversarialCases present (V2 with codeReview only).
-     *   3. Convert adversarialCases → GoldenTrace (all negative, PRI-423).
-     *   4. Merge ≥1 positive case from the Artificer golden trace. If the
+     *      short-circuit signal — no code to defend). Now observable (R9).
+     *   2. Convert adversarialCases → GoldenTrace (all negative, PRI-423).
+     *   3. Merge ≥1 positive case from the Artificer golden trace. If the
      *      artificer artifact has no goldenTraceCases (V1 mismatch), degrade:
      *      skip replay with telemetry — do NOT crash.
-     *   5. Invoke evaluateRefinerRuleHostGate via injected gateDeps.
-     *   6. Populate adversarialResult from the gate result.
+     *   4. Invoke evaluateRefinerRuleHostGate via injected gateDeps.
+     *   5. Populate adversarialResult from the gate result.
      *
      * Never throws — all failure modes degrade to a returned result with a
      * structured reason (ERR-018). The caller persists the updated output.
@@ -1151,15 +1532,29 @@ export class EvaluatorRunner extends BasePeerRunner {
         // eslint-disable-next-line @typescript-eslint/prefer-destructuring
         const gateDeps = this.gateDeps;
         if (!gateDeps) {
-            return { updatedOutput: null };
+            // Defensive — unreachable via the current caller (R2 fails loud before
+            // this point). Kept observable so a future caller cannot silently
+            // reintroduce the un-gated path (PRI-634 A3).
+            this.emitEvent('adversarial_replay_skipped', taskId, {
+                runId,
+                reason: 'gate_deps_not_injected',
+                nextAction: 'wire_gateDeps_createProductionGateDeps_into_evaluator_runner_assembly',
+            });
+            return { updatedOutput: null, skipReason: 'gate_deps_not_injected' };
         }
         // (1) Passive review short-circuit: the LLM emits decision='needs_revision'
         // when any of intentConsistency/scopePrecision/traceCoverage fails. Only
         // replay when the LLM judged the code worth defending. This check is
-        // defensive — by PRD contract the prompt instructs the LLM to short-circuit,
-        // but we don't trust the LLM to be the sole gate (Runtime Contract Rule 3).
+        // defensive — the caller already gated on decision='approved' (PRI-634 A2
+        // moved the check to the gate decision point); kept here so a future
+        // caller cannot silently bypass it (Runtime Contract Rule 3).
         if (output.evaluation.decision !== 'approved') {
-            return { updatedOutput: null };
+            this.emitEvent('adversarial_replay_skipped', taskId, {
+                runId,
+                reason: 'evaluation_not_approved',
+                nextAction: 'repair_loop_or_next_review_round',
+            });
+            return { updatedOutput: null, skipReason: 'evaluation_not_approved' };
         }
         // (2) Resolve the Artificer artifact early — we need it both to derive
         // the v2 adversarial spec (PRI-485) and to merge positive cases (PRI-423).
@@ -1169,7 +1564,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 reason: 'no_artificer_artifact_in_context',
                 nextAction: 'verify_buildContext_resolves_artificer_artifact',
             });
-            return { updatedOutput: null };
+            return { updatedOutput: null, skipReason: 'no_artificer_artifact_in_context' };
         }
         const artificerParsed = this.parseArtificerArtifact(context.artificerArtifact);
         if (!artificerParsed) {
@@ -1178,7 +1573,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 reason: 'artificer_artifact_unparseable',
                 nextAction: 'verify_artificer_artifact_contentJson',
             });
-            return { updatedOutput: null };
+            return { updatedOutput: null, skipReason: 'artificer_artifact_unparseable' };
         }
         const { implementationCode, goldenTraceCases, affectedTools } = artificerParsed;
         if (typeof implementationCode !== 'string' || implementationCode.trim() === '') {
@@ -1189,7 +1584,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 reason: 'artificer_artifact_has_no_implementation_code',
                 nextAction: 'verify_artificer_l2_adapter_emitted_v2',
             });
-            return { updatedOutput: null };
+            return { updatedOutput: null, skipReason: 'artificer_artifact_has_no_implementation_code' };
         }
         // Merge positive cases from the Artificer golden trace into the adversarial
         // trace. buildGoldenTraceFromArtificer validates each case structurally
@@ -1201,20 +1596,36 @@ export class EvaluatorRunner extends BasePeerRunner {
                 reason: 'no_positive_case_in_artificer_golden_trace',
                 nextAction: 'verify_artificer_emitted_at_least_one_positive_case',
             });
-            return { updatedOutput: null };
+            return { updatedOutput: null, skipReason: 'no_positive_case_in_artificer_golden_trace' };
         }
         // (3) PRI-485 Phase 6: auto-generate 5 v2 adversarial cases from the
         // Artificer's affectedTools + first positive case's path. These defend
         // against the most common false-positive patterns (unavailable/truncation/
         // alias/path/combination). Degrade with telemetry (rc-9) if the spec
         // cannot be derived — LLM-supplied adversarialCases still replay.
-        const llmCases = output.adversarialCases ?? [];
+        // PRI-634 R1: V1-shaped outputs carry no adversarialCases — the merged
+        // set below then relies entirely on the auto-generated v2 cases.
+        const llmCases = isEvaluatorOutputV2(output) ? (output.adversarialCases ?? []) : [];
         const v2Cases = this.generateV2CasesFromArtificer(affectedTools, positiveCases, taskId, runId);
         const mergedAdversarialCases = [...v2Cases, ...llmCases];
         // (4) No adversarial cases (neither v2-generated nor LLM-supplied) →
         // nothing to replay. codeReview may still be present (passive review only).
+        // Previously a silent return (PRI-634 A3 hole #3); now observable (R9).
+        //
+        // PRI-634 R3: for a code-bearing Artificer artifact this is NOT a benign
+        // degradation — it reproduces the chain-48371236 terminal state (approved
+        // with no gate executed, adversarialResult=null, no pi-rule-* ever
+        // emitted). The caller fails loud on this skipReason instead of reporting
+        // succeeded. Non-code-bearing artifacts keep the legacy degrade (R1's
+        // authority is the durable Artificer content, and only code-bearing
+        // content can reach rule assembly).
         if (mergedAdversarialCases.length === 0) {
-            return { updatedOutput: null };
+            this.emitEvent('adversarial_replay_skipped', taskId, {
+                runId,
+                reason: 'no_adversarial_cases_after_merge',
+                nextAction: 'verify_artificer_affectedTools_or_positive_case_path_derivable',
+            });
+            return { updatedOutput: null, skipReason: 'no_adversarial_cases_after_merge' };
         }
         // (5) Convert the merged adversarial cases to an all-negative GoldenTrace.
         const conversion = adversarialCasesToGoldenTrace(mergedAdversarialCases);
@@ -1226,7 +1637,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 reason: `adversarial_conversion_failed: ${conversion.reason}`,
                 nextAction: 'verify_adversarial_case_validator_alignment',
             });
-            return { updatedOutput: null };
+            return { updatedOutput: null, skipReason: `adversarial_conversion_failed: ${conversion.reason}` };
         }
         const mergedTrace = {
             traceId: `golden-trace-evaluator-replay-${taskId}-${Date.now().toString(36)}`,
@@ -1255,6 +1666,7 @@ export class EvaluatorRunner extends BasePeerRunner {
             };
             return {
                 updatedOutput: { ...output, adversarialResult: failedResult },
+                skipReason: null,
             };
         }
         this.emitEvent('adversarial_replay', taskId, {
@@ -1274,6 +1686,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         };
         return {
             updatedOutput: { ...output, adversarialResult },
+            skipReason: null,
         };
     }
     /**
@@ -1408,12 +1821,21 @@ export class EvaluatorRunner extends BasePeerRunner {
             });
             return [];
         }
-        const pathParam = firstPositive.params?.path;
-        if (typeof pathParam !== 'string' || pathParam.trim() === '') {
+        // PRI-634: golden-trace params are echoed verbatim from the host
+        // trajectory, and the dominant write-tool schema names its target
+        // `file_path` (OpenClaw / Claude Code), not `path`. Reading only `path`
+        // made v2 auto-generation structurally unreachable on real chains: the
+        // merged case set stayed empty, so the gate never ran and an
+        // LLM-declared adversarialResult.passed=true could stand in for a real
+        // replay (chain 48371236). Accept both spellings — this is the input that
+        // makes the deterministic gate reachable at all.
+        const { params } = firstPositive;
+        const pathParam = resolveCasePathParam(params);
+        if (pathParam === null) {
             this.emitEvent('v2_adversarial_cases_skipped', taskId, {
                 runId,
                 reason: 'no_path_param_for_v2_adversarial_cases',
-                nextAction: 'verify_positive_case_has_string_path_param',
+                nextAction: 'verify_positive_case_has_string_path_or_file_path_param',
             });
             return [];
         }