create-principles-disciple 1.133.11 → 1.133.13

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

@@ -9,9 +9,11 @@ import { EvaluatorPromptBuilder, deriveRequirementLedger } from './evaluator-pro
 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';
+import { extractIntentContract } from './intent-contract.js';
 import { evaluateFlaggedCriteria, isForcedStage2 } from './progressive-evaluator.js';
 // PRI-426: single-round adversarial sandbox replay in succeedTask.
 import { evaluateRefinerRuleHostGate } from './refiner-rulehost-gate.js';
+import { attributionFromLayer, partitionV2OutOfScopeFailures, resolveRequiresContextVersionFromArtifact } from './rule-reliability-validation.js';
 import { adversarialCasesToGoldenTrace } from './adversarial-case.js';
 import { buildGoldenTraceFromArtificer } from '../golden-trace.js';
 // PRI-485 Phase 6: auto-generate 5 v2 adversarial cases (unavailable/truncation/
@@ -595,6 +597,12 @@ export class EvaluatorRunner extends BasePeerRunner {
             sourceArtificerArtifactId: context.sourceArtificerArtifactId ?? '',
             previousEvaluation: context.previousEvaluation,
             hostToolCatalog: this.hostToolCatalog ?? undefined,
+            // PRI-703 Phase 1: the scribe artifact's Owner-intent contract is the
+            // primary intentConsistency anchor. Extracted from the FULL parsed
+            // scribe artifact (before any manifest narrowing — the contract is
+            // injected as its own block). Absent on pre-contract artifacts →
+            // undefined → prompt unchanged (backward compatible).
+            intentContract: extractIntentContract(parsedScribeArtifact) ?? undefined,
         });
         return { message, stage2Evidence: resolutionOutcome };
     }
@@ -926,13 +934,30 @@ export class EvaluatorRunner extends BasePeerRunner {
                 });
             }
         }
+        // ── Round-2 R2 (Owner 指令 2026-09-08): 出界处置先于 intent 落库派生 ──
+        // deriveGovernanceEffect 只读 durable 事实 (重放已 updateRunOutput 持久化
+        // 的 adversarialResult + durable artificer 工件 + durable repair 轮次)，
+        // 不依赖任何瞬时变量。派生结果随 intent 持久化 —— fresh 与 resume 由同
+        // 一 durable 判据得到同一处置，重启不改变已选定的治理动作 (R2 复现的
+        // 治理漂移断点)。
+        const sourceArtificerArtifactIdForGovernance = context.sourceArtificerArtifactId
+            ?? finalOutput.sourceArtificerArtifactId
+            ?? null;
+        const governanceEffect = await this.deriveGovernanceEffect(taskId, {
+            output: finalOutput,
+            sourceArtificerArtifactId: sourceArtificerArtifactIdForGovernance,
+            diagnosticReplayEvidence,
+        });
         // ── P0 (verdict drift): verdict + completion intent 原子落库 ──
         // 必须先于一切治理 side effect (validate bearer / seed repair / rule
         // assembly):side effect 已发生而 intent 未落 = crash 后重跑会重新问
         // LLM,新 verdict 与已发生副作用形成治理矛盾 (repair drift /
         // validation drift / validated-rule drift)。同 epoch crash/retry 重跑经
         // maybeResumePendingIntent resume,不重问。
-        await this.recordCompletionOrThrow(taskId, runId, finalOutput.evaluation.decision);
+        await this.recordCompletionOrThrow(taskId, runId, {
+            decision: finalOutput.evaluation.decision,
+            governanceEffect,
+        });
         const ruleAssemblyInput = {
             artificerArtifact: context.artificerArtifact ?? null,
             sourceArtificerArtifactId: context.sourceArtificerArtifactId ?? null,
@@ -1056,10 +1081,14 @@ export class EvaluatorRunner extends BasePeerRunner {
         if (decision === 'needs_revision' && this.isRepairLoopEnabled()) {
             const repairOutcome = await this.maybeSeedArtificerRepair(taskId, { runId, output: finalOutput, sourceArtificerArtifactId, diagnosticReplayEvidence });
             if (repairOutcome.kind === 'max_iterations_reached') {
-                // PRI-629: budget 耗尽(decision-capable)与 seed 失败(recovery)拆分原因码
+                // PRI-629: budget 耗尽(decision-capable)与 seed 失败(recovery)拆分原因码。
+                // PRI-703 Phase 2: test_out_of_scope 是 FAILED_TEST 归因 — v2-context
+                // case 对 v1 规则的通道设计限制,decision-capable(Owner 裁决是唯一出口)。
                 const reasonCode = repairOutcome.detail === 'budget_exhausted'
                     ? HUMAN_REVIEW_REASON.evaluatorRepairBudgetExhausted
-                    : HUMAN_REVIEW_REASON.evaluatorRepairSeedFailed;
+                    : repairOutcome.detail === 'test_out_of_scope'
+                        ? HUMAN_REVIEW_REASON.evaluatorTestOutOfScope
+                        : 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).
@@ -1096,6 +1125,70 @@ export class EvaluatorRunner extends BasePeerRunner {
         // transition decision 依据 durable runnerDecision fail-closed。
         return { kind: 'completed', ruleArtifactId: null };
     }
+    /**
+     * PRI-703 Phase 2: extract failed replay caseIds from the evaluator output.
+     * Trust-boundary (rc-1/rc-4): adversarialResult.failedCases is untrusted
+     * artifact content — validate each element's caseId shape; malformed entries
+     * are skipped (they cannot inform scoping decisions).
+     */
+    static extractFailedCases(output) {
+        // rc-1/rc-2 (ERR-001): adversarialResult.failedCases is untrusted
+        // artifact content — narrow via the class's isRecord/Array guards, no `as`.
+        // Round-2 R1: extract the sandbox-carried expectedDecision per case for
+        // the oracle-consistency check in partitionV2OutOfScopeFailures. The
+        // stored value is only ever COMPARED against the compile-time template
+        // oracle — it is never the classification source of truth.
+        if (!EvaluatorRunner.isRecord(output))
+            return [];
+        const { adversarialResult } = output;
+        if (!EvaluatorRunner.isRecord(adversarialResult))
+            return [];
+        const { failedCases } = adversarialResult;
+        if (!Array.isArray(failedCases))
+            return [];
+        const extracted = [];
+        for (const entry of failedCases) {
+            if (!EvaluatorRunner.isRecord(entry))
+                continue;
+            const { caseId } = entry;
+            if (typeof caseId !== 'string' || caseId.trim() === '')
+                continue;
+            const { expectedDecision } = entry;
+            extracted.push(typeof expectedDecision === 'string' && expectedDecision.trim() !== ''
+                ? { caseId, expectedDecision }
+                : { caseId });
+        }
+        return extracted;
+    }
+    /**
+     * PRI-703 Phase 2: resolve the rule's requiresContextVersion from the
+     * DURABLE artificer artifact (never from the LLM-forgible evaluator copy).
+     * Three-way result (see resolveRequiresContextVersionFromArtifact):
+     *   2 / undefined → resolved (v2 / v1) — the scope partition MUST run;
+     *   null → unresolvable (attribution stays inconclusive — fail-open to the
+     *          existing repair path, never blocks the loop on a read error).
+     *
+     * 评审 P1 修正：key-absent on a PARSED artifact is deterministically v1
+     * (artificer schema only ever writes literal 2) and must reach the
+     * partition — collapsing it into null made the out-of-scope routing
+     * unreachable in production for exactly its target population (v1 rules).
+     */
+    async resolveRequiresContextVersion(artificerArtifactId, taskId) {
+        try {
+            const artifact = await this.artifactStore.getArtifactById(artificerArtifactId);
+            if (!artifact)
+                return null;
+            return resolveRequiresContextVersionFromArtifact(artifact.contentJson);
+        }
+        catch (err) {
+            this.emitEvent('attribution_scope_resolve_failed', taskId, {
+                artificerArtifactId,
+                reason: err instanceof Error ? err.message : String(err),
+                nextAction: 'verify_artifact_store_read_for_failure_attribution',
+            });
+            return null;
+        }
+    }
     /**
      * PRI-509: Resolve the prior repair iteration by reading the dependency
      * artificer task's repairPayload (rc-7: written at task creation, never
@@ -1193,7 +1286,8 @@ export class EvaluatorRunner extends BasePeerRunner {
      * 证明 output 已 durable (updateRunOutput 在 succeedTask 最前)。
      * 同 epoch crash/retry 重跑经 maybeResumePendingIntent resume,不重问 LLM。
      */
-    async recordCompletionOrThrow(taskId, runId, decision) {
+    async recordCompletionOrThrow(taskId, runId, decisionAndEffect) {
+        const { decision, governanceEffect } = decisionAndEffect;
         try {
             const raw = await this.stateManager.getTask(taskId);
             if (!raw)
@@ -1210,6 +1304,12 @@ export class EvaluatorRunner extends BasePeerRunner {
                     sourceRunId: runId,
                     revisionEpoch: piTask.revisionCount ?? 0,
                     status: 'pending',
+                    ...(governanceEffect?.selectedEffect !== undefined
+                        ? { selectedEffect: governanceEffect.selectedEffect }
+                        : {}),
+                    ...(governanceEffect?.effectReasonCode !== undefined
+                        ? { effectReasonCode: governanceEffect.effectReasonCode }
+                        : {}),
                 },
             });
             await this.stateManager.updateTaskDiagnosticJson(taskId, createPITaskDiagnosticJson(merged));
@@ -1287,6 +1387,49 @@ export class EvaluatorRunner extends BasePeerRunner {
             decision: intent.decision,
             sourceRunId: intent.sourceRunId,
         });
+        // ── Round-2 R2 (Owner 指令 2026-09-08): 选定 NHR 效果的恢复直通 ──
+        // fresh 路径在 intent 落库前已把 deriveGovernanceEffect 的结论
+        // (selectedEffect='needs_human_review' + effectReasonCode) 持久化;恢复
+        // 执行读同一 durable intent,直接重放 NHR 效果 — 禁止重问 LLM、禁止
+        // 再 seed repair、禁止重新判责 (R2 复现的治理漂移断点)。照抄
+        // rollout-reviewer-runner 的 intent.effect resume 模板,零新状态源。
+        if ((intent.selectedEffect ?? intent.effect) === 'needs_human_review') {
+            const output2 = await this.recoverIntentOutput(taskId, intent.sourceRunId, intent.decision);
+            const artifactId2 = `pi-art-${taskId}-${intent.sourceRunId}`;
+            const reasonCode = intent.effectReasonCode ?? HUMAN_REVIEW_REASON.evaluatorRepairSeedFailed;
+            if (reasonCode === 'evaluator_test_out_of_scope') {
+                this.emitEvent('repair_loop_test_out_of_scope', taskId, {
+                    runId: intent.sourceRunId,
+                    attribution: attributionFromLayer('test'),
+                    source: 'resume_from_persisted_intent',
+                    nextAction: 'owner_decision_required_channel_upgrade_or_principle_revision',
+                });
+            }
+            await this.markNeedsHumanReviewOrThrow(taskId, {
+                runId: intent.sourceRunId,
+                reasonCode,
+                sourceArtifactId: artifactId2,
+            });
+            await this.markCompletionIntentAppliedOrThrow(taskId);
+            this.emitEvent('task_needs_human_review', taskId, {
+                attemptCount: leasedTask.attemptCount,
+                resultRef: `${this.config.resultRefPrefix}://${intent.sourceRunId}`,
+                evaluationDecision: output2.evaluation?.decision,
+                evaluationScore: output2.evaluation?.score,
+                ruleArtifactId: null,
+                reason: `repair_loop_${reasonCode}`,
+            });
+            return {
+                status: 'succeeded',
+                taskId,
+                runId: intent.sourceRunId,
+                artifactId: artifactId2,
+                resultRef: `${this.config.resultRefPrefix}://${intent.sourceRunId}`,
+                contextHash: `resume-${intent.sourceRunId}`,
+                output: output2,
+                attemptCount: leasedTask.attemptCount,
+            };
+        }
         const output = await this.recoverIntentOutput(taskId, intent.sourceRunId, intent.decision);
         const artifactId = `pi-art-${taskId}-${intent.sourceRunId}`;
         const contextHash = `resume-${intent.sourceRunId}`;
@@ -1549,9 +1692,164 @@ export class EvaluatorRunner extends BasePeerRunner {
      * are typed as readonly string[] on EvaluatorEvaluation, so element-level
      * re-validation is not required here (rc-4 N/A — not unknown at this point).
      */
+    /**
+     * Round-2 R2 (Owner 指令 2026-09-08): 从 durable 证据派生本 verdict 的治理
+     * 效果。fresh 与 resume 调用同一派生 —— 输入全部是 durable 事实:
+     *   - output: intent 落库前已由 executeDeterministicReplay 持久化的
+     *     adversarialResult（resume 时 recoverIntentOutput 从 run.outputPayload
+     *     恢复同一对象）;
+     *   - sourceArtificerArtifactId → durable 工件的 requiresContextVersion;
+     *   - priorRepairIteration → durable dependency repairPayload。
+     * record 只持久化本函数的结论，不做判断 (指令要求: 禁止把复杂判断逻辑
+     * 塞进 recordCompletionOrThrow)。返回 undefined = governance_transition
+     * (正常效果由 applyEvaluatorDecisionEffects 执行,无需特判)。
+     *
+     * fresh 路径的 diagnosticReplayEvidence 仅用于验证"重放确实执行过"这一
+     * 控制流事实 (P1 provenance); resume 路径不传时, 以 durable adversarialResult
+     * 的形态 (passed === false 且 failedCases 非空) 为等价判据 —— intent 存在
+     * 本身即证明 fresh 侧重放已执行并持久化。
+     */
+    /**
+     * Round-2 R2: 读取当前 durable completion intent (pending 或 applied 均可读 —
+     * applied 意味着效果已 materialize, 读侧只用于一致性核对, 不会改变路由)。
+     * 解析失败/缺 intent 返回 null — 出界判定回退到 fresh 快路径判定
+     * (fail-closed, 绝不因读不到 intent 而静默 seed)。
+     */
+    async readPendingOrAppliedCompletionIntent(taskId) {
+        try {
+            const raw = await this.stateManager.getTask(taskId);
+            if (!raw)
+                return null;
+            const piTask = hydratePITaskRecord(raw);
+            return piTask?.completionIntent ?? null;
+        }
+        catch (err) {
+            this.emitEvent('completion_intent_read_failed', taskId, {
+                errorMessage: err instanceof Error ? err.message : String(err),
+                nextAction: 'out_of_scope_disposition_falls_back_to_fresh_path_derivation',
+            });
+            return null;
+        }
+    }
+    async deriveGovernanceEffect(evaluatorTaskId, ctx) {
+        if (ctx.output.evaluation?.decision !== 'needs_revision')
+            return undefined;
+        if (!this.isRepairLoopEnabled())
+            return undefined;
+        // P1 provenance: fresh 要求 ran:true;resume 无 live 重放时等价判据为
+        // durable adversarialResult 形态 (passed:false + failedCases>0)。
+        const freshReplayFailed = ctx.diagnosticReplayEvidence?.ran === true && ctx.diagnosticReplayEvidence.passed === false;
+        let durableReplayFailed = false;
+        if (EvaluatorRunner.isRecord(ctx.output)) {
+            const { adversarialResult } = ctx.output;
+            if (EvaluatorRunner.isRecord(adversarialResult)) {
+                const { passed } = adversarialResult;
+                const { failedCases } = adversarialResult;
+                durableReplayFailed = passed === false && Array.isArray(failedCases) && failedCases.length > 0;
+            }
+        }
+        if (!freshReplayFailed && !durableReplayFailed)
+            return undefined;
+        const failedCases = EvaluatorRunner.extractFailedCases(ctx.output);
+        if (failedCases.length === 0)
+            return undefined;
+        const requiresContextVersion = ctx.sourceArtificerArtifactId
+            ? await this.resolveRequiresContextVersion(ctx.sourceArtificerArtifactId, evaluatorTaskId)
+            : null;
+        if (requiresContextVersion === null)
+            return undefined;
+        const partition = partitionV2OutOfScopeFailures({
+            requiresContextVersion: requiresContextVersion === 2 ? 2 : undefined,
+            failedCases,
+        });
+        if (partition.isPureOutOfScope) {
+            this.emitEvent('governance_effect_out_of_scope_selected', evaluatorTaskId, {
+                outOfScopeCaseIds: [...partition.outOfScope],
+                nextAction: 'selected_effect_needs_human_review_evaluator_test_out_of_scope',
+            });
+            return {
+                selectedEffect: 'needs_human_review',
+                effectReasonCode: 'evaluator_test_out_of_scope',
+            };
+        }
+        return undefined;
+    }
     async maybeSeedArtificerRepair(evaluatorTaskId, ctx) {
         const { runId: evaluatorRunId, output } = ctx;
         const priorRepairIteration = await this.resolvePriorRepairIteration(evaluatorTaskId);
+        // ── PRI-703 Phase 2 (Owner decision 2026-09-07): deterministic failure
+        // attribution BEFORE seeding a repair round. "测试失败 → 继续改 Rule" is
+        // the wrong default; a needs_revision whose replay failures are ALL
+        // v2-context template cases judging a v1 (action-only) rule is a
+        // TEST-SCOPE problem (FAILED_TEST attribution): the v1 channel
+        // structurally cannot express context semantics, so no rule repair can
+        // ever satisfy those cases (Episode 001's 18/18 death-loop). Route to
+        // owner review with the channel-limitation signal instead of seeding a
+        // doomed repair round.
+        // Provenance: adversarialResult on the output here was written by
+        // executeDeterministicReplay in THIS invocation (diagnosticReplayEvidence
+        // ran:true) or absent — never LLM-forged (the pre-replay LLM copy was
+        // replaced before the effects phase).
+        //
+        // 混合场景 (in-scope ⊕ out-of-scope 并存): 修复任务照常 seed (有真实
+        // Rule 缺陷可修),但归因上下文随 RepairPayload 流动,让修复 LLM 知道
+        // 哪些 case 是通道限制 (不得尝试满足) — "哪里失败/为什么/改哪里" 三问
+        // 在载荷层可回答 (PRI-705)。
+        let repairAttribution;
+        // Round-2 R2: 出界处置以持久化的 completion intent 为权威。fresh 路径在
+        // recordCompletionOrThrow 之前已由 deriveGovernanceEffect 写入
+        // selectedEffect='needs_human_review' —— 同一 durable 依据 (R1 oracle 校验
+        // 的 partition) 派生; resume 路径经 recoverIntentOutput 后重读本 intent,
+        // 无需重算也无需任何瞬时变量。瞬时 evidence 门只作 fresh 快路径与
+        // 派生时的 provenance 校验, 不再是出界判定的唯一载体 (R2 漂移断点)。
+        {
+            const intent = await this.readPendingOrAppliedCompletionIntent(evaluatorTaskId);
+            // Round-3: hydrate 将 selectedEffect 归一化为 effect —— 读侧必须两键
+            // 同读，否则 fresh 分支永不命中、静默回退瞬时 evidence (ERR-024 键不对称)。
+            if ((intent?.selectedEffect ?? intent?.effect) === 'needs_human_review'
+                && intent?.effectReasonCode === 'evaluator_test_out_of_scope') {
+                this.emitEvent('repair_loop_test_out_of_scope', evaluatorTaskId, {
+                    runId: evaluatorRunId,
+                    attribution: attributionFromLayer('test'),
+                    source: 'persisted_completion_intent',
+                    nextAction: 'owner_decision_required_channel_upgrade_or_principle_revision',
+                });
+                return { kind: 'max_iterations_reached', detail: 'test_out_of_scope' };
+            }
+        }
+        if (ctx.diagnosticReplayEvidence?.ran === true && ctx.diagnosticReplayEvidence.passed === false) {
+            const failedCases = EvaluatorRunner.extractFailedCases(output);
+            if (failedCases.length > 0) {
+                const sourceArtificerArtifactIdForScope = ctx.sourceArtificerArtifactId ?? output.sourceArtificerArtifactId;
+                const requiresContextVersion = sourceArtificerArtifactIdForScope
+                    ? await this.resolveRequiresContextVersion(sourceArtificerArtifactIdForScope, evaluatorTaskId)
+                    : null;
+                if (requiresContextVersion !== null) {
+                    const partition = partitionV2OutOfScopeFailures({
+                        requiresContextVersion: requiresContextVersion === 2 ? 2 : undefined,
+                        failedCases,
+                    });
+                    if (partition.isPureOutOfScope) {
+                        this.emitEvent('repair_loop_test_out_of_scope', evaluatorTaskId, {
+                            runId: evaluatorRunId,
+                            attribution: attributionFromLayer('test'),
+                            outOfScopeCaseIds: [...partition.outOfScope],
+                            failedCaseCount: ctx.diagnosticReplayEvidence.failedCaseCount,
+                            reason: 'all_replay_failures_are_v2_context_cases_judging_a_v1_rule',
+                            nextAction: 'owner_decision_required_channel_upgrade_or_principle_revision',
+                        });
+                        return { kind: 'max_iterations_reached', detail: 'test_out_of_scope' };
+                    }
+                    if (partition.outOfScope.length > 0) {
+                        repairAttribution = {
+                            attribution: attributionFromLayer('rule'),
+                            outOfScopeCaseIds: [...partition.outOfScope],
+                            reason: `replay failures mix real rule defects (in-scope cases: ${partition.inScope.join(', ')}) with test-scope v2-context cases (${partition.outOfScope.join(', ')}) that the v1 action-only channel structurally cannot express — do NOT attempt to satisfy the out-of-scope cases`,
+                        };
+                    }
+                }
+            }
+        }
         // ── Slice 5: max iterations (2) reached → fail loud ──
         if (priorRepairIteration >= 2) {
             // Task state update (→ needs_human_review) is handled by the caller
@@ -1583,6 +1881,10 @@ export class EvaluatorRunner extends BasePeerRunner {
         //（来自 succeedTask 的 executeDeterministicReplay 调用），绝不从 LLM
         // 可伪造的 output.adversarialResult 反推。缺失 = 本次未执行确定性重放
         //（skip/error/无 live 路径），repairPayload 不包含 diagnosticReplay。
+        //
+        // PRI-705 / PRI-703 Phase 2: 混合场景 (非纯 out-of-scope) 下,归因与
+        // out-of-scope case 清单随载荷流动 — 修复 LLM 明确知道哪些失败属于
+        // 通道设计限制(不得尝试满足),哪些是真实 Rule 缺陷(必须修复)。
         const repairPayload = {
             requiredChanges: [...output.evaluation.requiredChanges],
             concerns: [...output.evaluation.concerns],
@@ -1591,6 +1893,7 @@ export class EvaluatorRunner extends BasePeerRunner {
             sourceArtificerArtifactId,
             sourceEvaluatorTaskId: evaluatorTaskId,
             ...(ctx.diagnosticReplayEvidence ? { diagnosticReplay: ctx.diagnosticReplayEvidence } : {}),
+            ...(repairAttribution !== undefined ? { failureAttribution: repairAttribution } : {}),
         };
         // Resolve the dependency artificer task to inherit dependencyTaskIds
         // (so the repair task points to the same scribe task, preserving lineage).
@@ -2244,36 +2547,43 @@ export class EvaluatorRunner extends BasePeerRunner {
         const validatedAffectedTools = Array.isArray(affectedTools)
             ? affectedTools.filter((t) => typeof t === 'string')
             : [];
-        const ruleContent = {
-            implementationCode,
-            goldenTrace: traceBuild.trace,
-            goldenTraceCases,
-            affectedTools: validatedAffectedTools,
-            // adversarialResult.passed === true is the precondition for this method;
-            // the gate decision is therefore accepted_shadow.
-            ruleHostGateDecision: 'accepted_shadow',
-            sourceArtificerArtifactId: assemblyInput.sourceArtificerArtifactId ?? output.sourceArtificerArtifactId,
-            adversarialResult: output.adversarialResult,
-            ...(requiresContextVersion === 2 ? { requiresContextVersion } : {}),
-            // PRI-490: preserve evidenceRefs from Artificer artifact into rule artifact.
-            // Only include when the array is valid (non-empty strings) — v1 rules may omit.
-            ...(requiresContextVersion === 2 && Array.isArray(evidenceRefs) && evidenceRefs.every((e) => typeof e === 'string' && e.trim() !== '')
-                ? { evidenceRefs: evidenceRefs }
-                : {}),
-        };
         // P1 #7 (cross-package acceptance test discovery): resolve the scribe
         // principle artifact and carry forward its principle ID as
         // sourcePrincipleId on the rule artifact. Without this, extractPrincipleId()
         // in the activation dispatcher returns null for rule artifacts, causing
         // activateArtifact() to fail with 'invalid_artifact'/'no_principle_id'.
         // The rule artifact must carry lineage to the principle it enforces.
+        //
+        // PRI-703 Phase 1: the same resolution deterministically forwards the
+        // principle's intent contract onto the rule artifact (single author of the
+        // rule's intent anchor = the scribe principle; the rule echoes it, it
+        // never re-derives it — no second source of truth). Resolved BEFORE the
+        // ruleContent build so the contract rides in the same contentJson write.
         let resolvedSourcePrincipleId;
+        let forwardedIntentContract;
         try {
             const principleBearerId = await this.resolvePrincipleBearerArtifact(output, taskId);
             if (principleBearerId) {
                 const principleArtifact = await this.artifactStore.getArtifactById(principleBearerId);
                 if (principleArtifact) {
                     resolvedSourcePrincipleId = EvaluatorRunner.extractPrincipleIdFromArtifact(principleArtifact);
+                    let parsedPrincipleContent;
+                    try {
+                        parsedPrincipleContent = JSON.parse(principleArtifact.contentJson);
+                    }
+                    catch {
+                        parsedPrincipleContent = principleArtifact.contentJson;
+                    }
+                    const contract = extractIntentContract(parsedPrincipleContent);
+                    if (contract !== null) {
+                        forwardedIntentContract = contract;
+                    }
+                    else {
+                        this.emitEvent('intent_contract_absent_on_principle', taskId, {
+                            principleArtifactId: principleBearerId,
+                            nextAction: 'pre_contract_scribe_artifact_backward_compatible',
+                        });
+                    }
                 }
             }
         }
@@ -2294,6 +2604,27 @@ export class EvaluatorRunner extends BasePeerRunner {
             });
             return null;
         }
+        const ruleContent = {
+            implementationCode,
+            goldenTrace: traceBuild.trace,
+            goldenTraceCases,
+            affectedTools: validatedAffectedTools,
+            // adversarialResult.passed === true is the precondition for this method;
+            // the gate decision is therefore accepted_shadow.
+            ruleHostGateDecision: 'accepted_shadow',
+            sourceArtificerArtifactId: assemblyInput.sourceArtificerArtifactId ?? output.sourceArtificerArtifactId,
+            adversarialResult: output.adversarialResult,
+            ...(requiresContextVersion === 2 ? { requiresContextVersion } : {}),
+            // PRI-490: preserve evidenceRefs from Artificer artifact into rule artifact.
+            // Only include when the array is valid (non-empty strings) — v1 rules may omit.
+            ...(requiresContextVersion === 2 && Array.isArray(evidenceRefs) && evidenceRefs.every((e) => typeof e === 'string' && e.trim() !== '')
+                ? { evidenceRefs: evidenceRefs }
+                : {}),
+            // PRI-703 Phase 1: forward the principle's intent contract verbatim —
+            // the rule artifact self-carries the intent anchor it was validated
+            // against (echo of the scribe single source, never a re-derivation).
+            ...(forwardedIntentContract !== undefined ? { intentContract: forwardedIntentContract } : {}),
+        };
         const ruleArtifactId = `pi-rule-${taskId}-${runId}`;
         const ruleId = `rule-${taskId}`;
         const nowIso = new Date().toISOString();