@principles/core 1.293.4 → 1.294.0

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

@@ -31,6 +31,14 @@ function commonPrefixLength(a, b) {
         i += 1;
     return i;
 }
+/** Drop any model-shaped replay claim when this run did not execute the gate. */
+function withoutAdversarialResult(output) {
+    if (!isEvaluatorOutputV2(output))
+        return output;
+    const { adversarialResult, ...sanitized } = output;
+    void adversarialResult;
+    return sanitized;
+}
 function isRecordValue(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -704,6 +712,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         // explicitly through applyEvaluatorDecisionEffects → maybeSeedArtificerRepair
         // keeps provenance structural rather than inferred.
         let diagnosticReplayEvidence;
+        let ownerStampRecoveryRequired = false;
         const gateAssessment = assessArtificerCodeBearing(context.artificerArtifact);
         const outputWantsGate = isEvaluatorOutputV2(output);
         const evaluatorDecision = output.evaluation.decision;
@@ -803,12 +812,50 @@ export class EvaluatorRunner extends BasePeerRunner {
             }
         }
         else if (!this.gateDeps) {
+            const taskChannel = hydratePITaskRecord(task)?.channel;
+            const sourceArtificer = context.artificerArtifact
+                ? this.parseArtificerArtifact(context.artificerArtifact)
+                : null;
+            const promptHasUnstampedV2Code = taskChannel === 'prompt'
+                && sourceArtificer?.requiresContextVersion === 2
+                && !Array.isArray(sourceArtificer.ownerGoldenTraceCases);
             this.emitEvent('adversarial_replay_skipped', taskId, {
                 runId,
                 reason: 'gate_deps_not_injected',
                 nextAction: 'wire_gateDeps_createProductionGateDeps_into_evaluator_runner_assembly',
             });
-            if (gateAssessment.codeBearing) {
+            if (promptHasUnstampedV2Code) {
+                // An accidental prompt-channel V2 artifact is not a RuleCode request.
+                // Keep the ordinary prompt verdict, but drop any model-shaped replay
+                // claim so it cannot be mistaken for executed gate evidence.
+                finalOutput = withoutAdversarialResult(finalOutput);
+                await this.stateManager.updateRunOutput(runId, JSON.stringify(finalOutput));
+                try {
+                    await this.artifactStore.upsertArtifact({
+                        artifactId,
+                        artifactKind: 'principle',
+                        sourceTaskId: taskId,
+                        lineageArtifactIds,
+                        validationStatus: 'pending',
+                        contentJson: JSON.stringify(finalOutput),
+                        createdAt: now,
+                        updatedAt: new Date().toISOString(),
+                    });
+                }
+                catch (persistErr) {
+                    this.emitEvent('adversarial_result_persist_failed', taskId, {
+                        runId,
+                        errorMessage: persistErr instanceof Error ? persistErr.message : String(persistErr),
+                    });
+                }
+                this.emitEvent('prompt_code_artifact_ignored', taskId, {
+                    runId,
+                    sourceArtificerArtifactId: context.sourceArtificerArtifactId,
+                    reason: 'owner_golden_trace_stamp_missing',
+                    nextAction: 'prompt_channel_does_not_create_rulecode_without_an_explicit_code_tool_hook_request',
+                });
+            }
+            else 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
@@ -864,31 +911,96 @@ 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.
-                const recoveryAction = replayOutcome.skipReason?.startsWith('template_derivation_failed:')
-                    ? 'have the Artificer emit a complete positive write-kind golden-trace case with a string path or file_path; required templates cannot be replaced by LLM adversarialCases.'
-                    : 'have the Artificer emit affectedTools plus at least one positive golden-trace case carrying a path, or supply LLM adversarialCases.';
-                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: ${recoveryAction}`,
-                });
+                const missingOwnerStamp = replayOutcome.skipReason === 'owner_golden_trace_stamp_missing_or_invalid';
+                const taskChannel = hydratePITaskRecord(task)?.channel;
+                if (missingOwnerStamp && taskChannel === 'prompt') {
+                    // Prompt-channel artifacts are not eligible to create RuleCode.
+                    // Preserve the ordinary prompt result, but discard any model-shaped
+                    // replay claim so it cannot masquerade as executed gate evidence.
+                    finalOutput = withoutAdversarialResult(finalOutput);
+                    await this.stateManager.updateRunOutput(runId, JSON.stringify(finalOutput));
+                    try {
+                        await this.artifactStore.upsertArtifact({
+                            artifactId,
+                            artifactKind: 'principle',
+                            sourceTaskId: taskId,
+                            lineageArtifactIds,
+                            validationStatus: 'pending',
+                            contentJson: JSON.stringify(finalOutput),
+                            createdAt: now,
+                            updatedAt: new Date().toISOString(),
+                        });
+                    }
+                    catch (persistErr) {
+                        this.emitEvent('adversarial_result_persist_failed', taskId, {
+                            runId,
+                            errorMessage: persistErr instanceof Error ? persistErr.message : String(persistErr),
+                        });
+                    }
+                    this.emitEvent('adversarial_replay_skipped', taskId, {
+                        runId,
+                        reason: replayOutcome.skipReason,
+                        channel: 'prompt',
+                        nextAction: 'prompt_channel_result_kept_without_rulecode_eligibility',
+                    });
+                }
+                else if (missingOwnerStamp && this.isRepairLoopEnabled()) {
+                    // Missing system-owned provenance is recoverable through the existing
+                    // bounded Artificer repair loop. Do not fabricate a gate result.
+                    ownerStampRecoveryRequired = true;
+                    finalOutput = withoutAdversarialResult(finalOutput);
+                    await this.stateManager.updateRunOutput(runId, JSON.stringify(finalOutput));
+                    try {
+                        await this.artifactStore.upsertArtifact({
+                            artifactId,
+                            artifactKind: 'principle',
+                            sourceTaskId: taskId,
+                            lineageArtifactIds,
+                            validationStatus: 'pending',
+                            contentJson: JSON.stringify(finalOutput),
+                            createdAt: now,
+                            updatedAt: new Date().toISOString(),
+                        });
+                    }
+                    catch (persistErr) {
+                        this.emitEvent('adversarial_result_persist_failed', taskId, {
+                            runId,
+                            errorMessage: persistErr instanceof Error ? persistErr.message : String(persistErr),
+                        });
+                    }
+                    this.emitEvent('artificer_owner_stamp_repair_required', taskId, {
+                        runId,
+                        sourceArtificerArtifactId: context.sourceArtificerArtifactId,
+                        nextAction: 'regenerate_artificer_from_current_validated_owner_behavior_example_pack',
+                    });
+                }
+                else {
+                    // ── 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.
+                    const recoveryAction = replayOutcome.skipReason?.startsWith('template_derivation_failed:')
+                        ? 'have the Artificer emit a complete positive write-kind golden-trace case with a string path or file_path; required templates cannot be replaced by LLM adversarialCases.'
+                        : 'have the Artificer emit affectedTools plus at least one positive golden-trace case carrying a path, or supply LLM adversarialCases.';
+                    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: ${recoveryAction}`,
+                    });
+                }
             }
         }
         // ── Round-2 R2 (Owner 指令 2026-09-08): 出界处置先于 intent 落库派生 ──
@@ -926,9 +1038,14 @@ export class EvaluatorRunner extends BasePeerRunner {
             && finalOutput.evaluation.decision === 'approved'
             && finalOutput.adversarialResult?.passed === false
             && this.isRepairLoopEnabled();
+        const approvedOwnerStampRecovery = ownerStampRecoveryRequired
+            && finalOutput.evaluation.decision === 'approved';
         await this.recordCompletionOrThrow(taskId, runId, {
             decision: finalOutput.evaluation.decision,
             governanceEffect,
+            ...(approvedOwnerStampRecovery
+                ? { transitionOverrideReason: 'owner_golden_trace_provenance_missing' }
+                : {}),
         });
         const ruleAssemblyInput = {
             artificerArtifact: context.artificerArtifact ?? null,
@@ -943,7 +1060,9 @@ export class EvaluatorRunner extends BasePeerRunner {
             diagnosticReplayEvidence,
             // PRI-843: mismatch 处置在效果层先于一切 decision 分支执行
             ...(governanceEffect !== undefined ? { governanceEffect } : {}),
-            ...(approvedReplayFailed ? { transitionDecisionOverride: 'needs_revision' } : {}),
+            ...(approvedReplayFailed || approvedOwnerStampRecovery
+                ? { transitionDecisionOverride: 'needs_revision' }
+                : {}),
         });
         if (effectResult.kind === 'human_review') {
             return effectResult.result;
@@ -1324,7 +1443,7 @@ export class EvaluatorRunner extends BasePeerRunner {
      * 同 epoch crash/retry 重跑经 maybeResumePendingIntent resume,不重问 LLM。
      */
     async recordCompletionOrThrow(taskId, runId, decisionAndEffect) {
-        const { decision, governanceEffect } = decisionAndEffect;
+        const { decision, governanceEffect, transitionOverrideReason } = decisionAndEffect;
         try {
             const raw = await this.stateManager.getTask(taskId);
             if (!raw)
@@ -1347,6 +1466,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                     ...(governanceEffect?.effectReasonCode !== undefined
                         ? { effectReasonCode: governanceEffect.effectReasonCode }
                         : {}),
+                    ...(transitionOverrideReason !== undefined ? { transitionOverrideReason } : {}),
                 },
             });
             await this.stateManager.updateTaskDiagnosticJson(taskId, createPITaskDiagnosticJson(merged));
@@ -1493,6 +1613,9 @@ export class EvaluatorRunner extends BasePeerRunner {
             contextHash,
             sourceArtificerArtifactId: assemblySourceId,
             ruleAssemblyInput: { artificerArtifact: artificerContent, sourceArtificerArtifactId: assemblySourceId },
+            ...(intent.transitionOverrideReason === 'owner_golden_trace_provenance_missing'
+                ? { transitionDecisionOverride: 'needs_revision' }
+                : {}),
         });
         if (effectResult.kind === 'human_review') {
             return effectResult.result;
@@ -1857,8 +1980,9 @@ export class EvaluatorRunner extends BasePeerRunner {
         // 的 partition) 派生; resume 路径经 recoverIntentOutput 后重读本 intent,
         // 无需重算也无需任何瞬时变量。瞬时 evidence 门只作 fresh 快路径与
         // 派生时的 provenance 校验, 不再是出界判定的唯一载体 (R2 漂移断点)。
+        const completionIntent = await this.readPendingOrAppliedCompletionIntent(evaluatorTaskId);
         {
-            const intent = await this.readPendingOrAppliedCompletionIntent(evaluatorTaskId);
+            const intent = completionIntent;
             // Round-3: hydrate 将 selectedEffect 归一化为 effect —— 读侧必须两键
             // 同读，否则 fresh 分支永不命中、静默回退瞬时 evidence (ERR-024 键不对称)。
             if ((intent?.selectedEffect ?? intent?.effect) === 'needs_human_review'
@@ -1963,7 +2087,12 @@ export class EvaluatorRunner extends BasePeerRunner {
         // out-of-scope case 清单随载荷流动 — 修复 LLM 明确知道哪些失败属于
         // 通道设计限制(不得尝试满足),哪些是真实 Rule 缺陷(必须修复)。
         const repairPayload = {
-            requiredChanges: [...output.evaluation.requiredChanges],
+            requiredChanges: completionIntent?.transitionOverrideReason === 'owner_golden_trace_provenance_missing'
+                ? [
+                    ...output.evaluation.requiredChanges,
+                    'Regenerate this RuleCode from the current validated Owner BehaviorExamplePack so the persisted artifact carries the system-owned ownerGoldenTraceCases; preserve the approved principle semantics.',
+                ]
+                : [...output.evaluation.requiredChanges],
             concerns: [...output.evaluation.concerns],
             previousScore: output.evaluation.score,
             repairIteration: priorRepairIteration + 1,
@@ -1986,6 +2115,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         let inheritedPipelineMode;
         let inheritedTimeoutMs = 300_000;
         let inheritedInputArtifactRefs = [];
+        let ownerEvidenceSelection;
         for (const depId of evaluatorDeps) {
             const depTask = await this.stateManager.getTask(depId);
             if (!depTask)
@@ -2000,6 +2130,7 @@ export class EvaluatorRunner extends BasePeerRunner {
             inheritedPipelineMode = piArtificer.pipelineMode;
             inheritedTimeoutMs = piArtificer.timeoutMs;
             inheritedInputArtifactRefs = piArtificer.inputArtifactRefs;
+            ({ ownerEvidenceSelection } = piArtificer);
             break;
         }
         // Delegate to the injected seeder — core peer runners do NOT call
@@ -2023,6 +2154,7 @@ export class EvaluatorRunner extends BasePeerRunner {
                 inheritedPipelineMode,
                 inheritedTimeoutMs,
                 inheritedInputArtifactRefs,
+                ownerEvidenceSelection,
             });
             this.emitEvent('repair_task_seeded', evaluatorTaskId, {
                 repairTaskId,
@@ -2175,7 +2307,7 @@ export class EvaluatorRunner extends BasePeerRunner {
             });
             return { updatedOutput: null, skipReason: 'artificer_artifact_unparseable' };
         }
-        const { implementationCode, goldenTraceCases, affectedTools } = artificerParsed;
+        const { implementationCode, goldenTraceCases, ownerGoldenTraceCases, affectedTools, requiresContextVersion } = artificerParsed;
         if (typeof implementationCode !== 'string' || implementationCode.trim() === '') {
             // Artificer output is V1 (no code) but the evaluator emitted V2. This is
             // a mismatch — degrade rather than replay against missing code.
@@ -2189,7 +2321,38 @@ export class EvaluatorRunner extends BasePeerRunner {
         // Merge positive cases from the Artificer golden trace into the adversarial
         // trace. buildGoldenTraceFromArtificer validates each case structurally
         // (Runtime Contract Rule 4) and returns ok=false on any malformed entry.
-        const positiveCases = this.extractPositiveCases(goldenTraceCases);
+        let positiveCases;
+        let ownerNegativeCases = [];
+        if (requiresContextVersion === 2) {
+            if (!Array.isArray(ownerGoldenTraceCases)) {
+                this.emitEvent('adversarial_replay_skipped', taskId, {
+                    runId,
+                    reason: 'owner_golden_trace_stamp_missing_or_invalid',
+                    nextAction: 'regenerate_artificer_artifact_from_the_current_validated_owner_behavior_example_pack',
+                });
+                return { updatedOutput: null, skipReason: 'owner_golden_trace_stamp_missing_or_invalid' };
+            }
+            const ownerBuild = buildGoldenTraceFromArtificer({ cases: ownerGoldenTraceCases });
+            const ownerPositives = ownerBuild.ok ? ownerBuild.trace.cases.filter((c) => c.kind === 'positive') : [];
+            ownerNegativeCases = ownerBuild.ok ? ownerBuild.trace.cases.filter((c) => c.kind === 'negative') : [];
+            if (!ownerBuild.ok || ownerPositives.length === 0 || ownerNegativeCases.length === 0
+                || ownerBuild.trace.cases.some((c) => c.expectedDecision === 'propose_correction')
+                || ownerNegativeCases.some((c) => c.expectedDecision !== 'block')) {
+                this.emitEvent('adversarial_replay_skipped', taskId, {
+                    runId,
+                    reason: 'owner_golden_trace_stamp_invalid_or_missing_positive_negative_pair',
+                    nextAction: 'restore_a_validated_owner_pack_with_at_least_one_allow_positive_and_one_block_negative_case',
+                });
+                return { updatedOutput: null, skipReason: 'owner_golden_trace_stamp_invalid_or_missing_positive_negative_pair' };
+            }
+            positiveCases = ownerPositives;
+        }
+        else {
+            // Legacy v1 artifacts predate the system-owned pack stamp and remain
+            // readable. New context-v2 RuleCode never falls back to model-authored
+            // examples as its independent Owner acceptance baseline.
+            positiveCases = this.extractPositiveCases(goldenTraceCases);
+        }
         if (positiveCases.length === 0) {
             this.emitEvent('adversarial_replay_skipped', taskId, {
                 runId,
@@ -2198,10 +2361,9 @@ export class EvaluatorRunner extends BasePeerRunner {
             });
             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 target kind and one complete positive write case. These defend
-        // against the most common false-positive patterns (unavailable/truncation/
-        // alias/path/combination). Degrade with telemetry (rc-9) if the spec
+        // Derive context availability cases from one complete positive write case.
+        // Business decisions come from the Owner pack, not generic path policies.
+        // Degrade with telemetry (rc-9) if the spec
         // cannot be derived for a write target — auxiliary cases cannot replace them.
         // PRI-634 R1: V1-shaped outputs carry no adversarialCases — the merged
         // set below then relies entirely on the auto-generated v2 cases.
@@ -2214,8 +2376,18 @@ export class EvaluatorRunner extends BasePeerRunner {
         }
         // PRI-741: host-name parity case — the rule must reach the same decision
         // under the REAL host tool name as under the author's vocabulary.
-        const hostAliasCase = this.generateHostAliasCase(goldenTraceCases, taskId, runId);
+        const hostAliasCase = this.generateHostAliasCase(requiresContextVersion === 2 ? ownerGoldenTraceCases : goldenTraceCases, taskId, runId);
+        const ownerNegativeAdversarial = ownerNegativeCases.map((ownerCase) => ({
+            caseId: `owner:${ownerCase.caseId}`,
+            attackType: 'boundary',
+            toolName: ownerCase.toolName,
+            params: ownerCase.params,
+            expectedDecision: 'block',
+            rationale: 'System-restored Owner-labelled negative behavior example; expected decision comes from the validated BehaviorExamplePack.',
+            ...(ownerCase.ruleContext !== undefined ? { ruleContext: ownerCase.ruleContext } : {}),
+        }));
         const mergedAdversarialCases = [
+            ...ownerNegativeAdversarial,
             ...v2Cases,
             ...(hostAliasCase !== null ? [hostAliasCase] : []),
             ...llmCases,
@@ -2381,6 +2553,7 @@ export class EvaluatorRunner extends BasePeerRunner {
         return {
             implementationCode: parsed.implementationCode,
             goldenTraceCases: parsed.goldenTraceCases,
+            ownerGoldenTraceCases: parsed.ownerGoldenTraceCases,
             affectedTools: parsed.affectedTools,
             requiresContextVersion: parsed.requiresContextVersion,
             evidenceRefs: parsed.evidenceRefs,
@@ -2965,6 +3138,24 @@ export class EvaluatorRunner extends BasePeerRunner {
                 nextAction: 'approval_card_keeps_generic_trigger_reason',
             });
         }
+        const hostContext = this.hostSemanticContext;
+        const hostKinds = hostContext?.hostKinds;
+        const hasHostInputContract = requiresContextVersion === 2
+            && hostContext !== null
+            && Array.isArray(hostKinds)
+            && hostKinds.length > 0
+            && hostKinds.every((kind) => typeof kind === 'string' && kind.trim() !== '')
+            && Array.isArray(hostContext.tools)
+            && hostContext.tools.length > 0
+            && hostContext.tools.every((tool) => typeof tool.rawToolName === 'string' && tool.rawToolName.trim() !== ''
+                && typeof tool.canonicalKind === 'string' && tool.canonicalKind.trim() !== '');
+        if (requiresContextVersion === 2 && !hasHostInputContract) {
+            this.emitEvent('rule_host_input_contract_skipped', taskId, {
+                runId,
+                reason: hostContext === null ? 'host_semantic_context_missing' : 'host_semantic_context_invalid_or_empty',
+                nextAction: 'provide_the_nonempty_host_semantic_projection_used_by_the_deterministic_gate',
+            });
+        }
         const ruleContent = {
             implementationCode,
             goldenTrace: traceBuild.trace,
@@ -2976,6 +3167,9 @@ export class EvaluatorRunner extends BasePeerRunner {
             sourceArtificerArtifactId: assemblyInput.sourceArtificerArtifactId ?? output.sourceArtificerArtifactId,
             adversarialResult: output.adversarialResult,
             ...(requiresContextVersion === 2 ? { requiresContextVersion } : {}),
+            ...(hasHostInputContract ? {
+                ruleHostInputContract: { version: 1, contextVersion: 2, hostKinds: [...hostKinds] },
+            } : {}),
             // 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() !== '')