@principles/host-runtime 0.6.0 → 0.7.1

package/dist/governance-signal-admission.d.ts

@@ -8,8 +8,10 @@ type Degradation = {
     reason: string;
     nextAction: string;
 };
-/** learned 词进入高精度 deterministic path 的权重阈值(仅 seed/owner_promoted; llm_learned 恒 ambiguous) */
+/** seed/owner_promoted 词进入高精度 deterministic path 的权重阈值 */
 export declare const HIGH_PRECISION_LEARNED_WEIGHT = 0.7;
+/** PRI-788 G3: llm 学习词 earned precision 的 TP 门槛（且要求零 FP） */
+export declare const EARNED_PRECISION_MIN_TP = 3;
 /** 高精度纠正短语 overlay(已验证的确定性 STRONG 路径,不属于 learner seed 集) */
 export declare const HIGH_PRECISION_CORRECTION_OVERLAY: readonly (readonly [string, number])[];
 /** empathy seed overlay(检测行为不变) */

package/dist/governance-signal-admission.js

@@ -63,13 +63,21 @@ function rowField(row, key) {
 }
 // ─── Shared correction keyword store (host-neutral extraction) ──────────────
 const KEYWORD_STORE_FILE = 'correction_keywords.json';
-/** learned 词进入高精度 deterministic path 的权重阈值(仅 seed/owner_promoted; llm_learned 恒 ambiguous) */
+/** seed/owner_promoted 词进入高精度 deterministic path 的权重阈值 */
 export const HIGH_PRECISION_LEARNED_WEIGHT = 0.7;
+/** PRI-788 G3: llm 学习词 earned precision 的 TP 门槛（且要求零 FP） */
+export const EARNED_PRECISION_MIN_TP = 3;
 /** 高精度纠正短语 overlay(已验证的确定性 STRONG 路径,不属于 learner seed 集) */
 export const HIGH_PRECISION_CORRECTION_OVERLAY = [
     ['这是错的', 0.9],
     ['不要自作主张', 0.9],
     ['不应该这么做', 0.9],
+    // PRI-788 G3(Owner 批准清单):中文高精度纠正句式
+    ['我说的是', 0.9],
+    ['不是让你', 0.85],
+    ['谁让你', 0.85],
+    ['又搞错', 0.8],
+    ['都说了', 0.8],
 ];
 /** empathy seed overlay(检测行为不变) */
 export const EMPATHY_SEED_OVERLAY = [
@@ -83,6 +91,14 @@ function isValidLearnedKeyword(v) {
         return false;
     if (typeof k.weight !== 'number' || !Number.isFinite(k.weight))
         return false;
+    // earned precision 的计数是安全门（tp >= 3 才升 high），必须先约束数值形状：
+    // `correction_keywords.json` 里被篡改/损坏的 `truePositiveCount: 3.1` 若放行，
+    // 会让只有 3 条样本（甚至根本没有样本）的词项挤进 high 确定性路径。
+    // 缺失按可选字段语义放行，存在则必须是【非负安全整数】。
+    const isCount = (value) => value === undefined ||
+        (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0);
+    if (!isCount(k.truePositiveCount) || !isCount(k.falsePositiveCount))
+        return false;
     return k.source === 'seed' || k.source === 'llm' || k.source === 'user';
 }
 function mapLearnedSource(source) {
@@ -92,9 +108,18 @@ function mapLearnedSource(source) {
         return 'owner_promoted';
     return 'seed';
 }
-function precisionFor(source, weight) {
-    if (source === 'llm')
-        return 'ambiguous';
+/**
+ * PRI-788 G3 earned precision：llm 学习词不再恒为 ambiguous——确认证据达标
+ * （TP ≥ 3 且零 FP）时升 high，出现任一 FP 即降回 ambiguous。安全姿态不变：
+ * LLM 单次建议无法自升 STRONG，必须积累 LLM 确认的正例。owner_promoted 仍按
+ * 权重判定（Owner 显式决策不受证据门槛约束）。
+ */
+function precisionFor(source, weight, stats) {
+    if (source === 'llm') {
+        const tp = stats?.truePositiveCount ?? 0;
+        const fp = stats?.falsePositiveCount ?? 0;
+        return tp >= EARNED_PRECISION_MIN_TP && fp === 0 ? 'high' : 'ambiguous';
+    }
     return weight >= HIGH_PRECISION_LEARNED_WEIGHT ? 'high' : 'ambiguous';
 }
 function projectLearnedStore(raw) {
@@ -116,7 +141,7 @@ function projectLearnedStore(raw) {
             term,
             category: 'correction',
             weight,
-            precision: precisionFor(kw.source, weight),
+            precision: precisionFor(kw.source, weight, kw),
             source: mapLearnedSource(kw.source),
         };
         if (kw.source === 'llm')

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { type HostEvent, type HostEventResult } from '@principles/core/host';
+import { type HostEvent, type HostEventResult, type HostEventEmitter } from '@principles/core/host';
 import { buildActivePrinciplePromptContext } from './active-principle-prompt.js';
 import { type RuleContextProvider, type RuleInputEnrichmentProvider } from './production-rulehost-gate.js';
 import type { RuleImplementationRuntime } from './rule-implementation-runtime.js';
@@ -67,4 +67,13 @@ export declare function createProductionHostRuntime(options?: Partial<Pick<HostR
     hostKind?: GovernanceHostKind;
     /** PRI-634-F: host-declared tool semantics supplied by the constructing host adapter. */
     toolSemantics?: ToolSemanticRegistry;
+    /**
+     * PRI-750: optional event emission port. When present, the shared-path
+     * handlers record injection/tool events carrying the host's natural
+     * turn/tool ids (turnId/toolCallId) in the same events_*.jsonl format as
+     * the OpenClaw path (whose events additionally bind to
+     * assistant_turns.run_id). Only the Codex host adapter wires this; the
+     * OpenClaw plugin path owns its own emission.
+     */
+    events?: HostEventEmitter;
 }): HostRuntime;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { isHostEvent, isHostEventResult, } from '@principles/core/host';
+import { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
 import { buildActivePrinciplePromptContext } from './active-principle-prompt.js';
 import { createProductionRuleHostGate } from './production-rulehost-gate.js';
 import { createProductionPainEvidenceHandler } from './production-pain-evidence.js';
@@ -171,6 +172,7 @@ export function createProductionHostRuntime(options = {}) {
             ...(options.painEnrichmentProvider ? { painEnrichmentProvider: options.painEnrichmentProvider } : {}),
             ...(options.painDatabaseFactory ? { painDatabaseFactory: options.painDatabaseFactory } : {}),
             ...(options.hostKind ? { hostKind: options.hostKind } : {}),
+            ...(options.events ? { events: options.events } : {}),
         }),
         beforeToolCall: options.beforeToolCall ?? productionGate,
         async beforePromptBuild(event) {
@@ -178,12 +180,47 @@ export function createProductionHostRuntime(options = {}) {
                 workspaceDir: event.context.workspaceDir,
                 excludePrincipleIds: options.promptExcludePrincipleIds?.(event),
             });
-            if (options.beforePromptBuild)
-                return options.beforePromptBuild(event, prompt);
+            // PRI-750: record the injection event on the shared path with the host
+            // turn id (Codex turn_id → runId) so receipt events carry a turn-level
+            // anchor in the same events_*.jsonl format as the OpenClaw path. The
+            // OpenClaw plugin additionally persists these to assistant_turns.run_id;
+            // the Codex DB-side anchor is a follow-up. Optional port — absent means
+            // no-op (the OpenClaw plugin path emits this event itself). Emission
+            // failure must not block the prompt result — it degrades to an
+            // observable warning (rc-9).
+            const emissionWarnings = [];
+            try {
+                options.events?.recordRuntimeV2ActivationsInjected({
+                    sessionId: event.context.sessionId,
+                    workspaceDir: event.context.workspaceDir,
+                    principleIds: prompt.principleIds,
+                    activationIds: prompt.activationIds,
+                    artifactIds: prompt.artifactIds,
+                    injectedCount: prompt.principleIds.length,
+                    skippedWarnings: prompt.warnings,
+                    injectedCharCount: prompt.additionalContext.length,
+                    budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+                    ...(prompt.truncated !== undefined ? { v2Truncated: prompt.truncated } : {}),
+                    ...(event.context.turnId !== undefined ? { runId: event.context.turnId } : {}),
+                });
+            }
+            catch (err) {
+                emissionWarnings.push(`receipt_event_write_failed:${err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200)}`);
+            }
+            // PRI-750 review: a custom beforePromptBuild must not swallow the
+            // receipt-emission warnings captured above (rc-9) — merge them into the
+            // handler result instead of replacing the result wholesale.
+            if (options.beforePromptBuild) {
+                const custom = await options.beforePromptBuild(event, prompt);
+                if (emissionWarnings.length === 0)
+                    return custom;
+                return { ...custom, warnings: [...(custom.warnings ?? []), ...emissionWarnings] };
+            }
             return {
                 decision: prompt.additionalContext.length > 0 ? 'modify' : 'allow',
                 source: event.source,
                 ...(prompt.additionalContext.length > 0 ? { additionalContext: prompt.additionalContext } : {}),
+                ...(emissionWarnings.length > 0 ? { warnings: emissionWarnings } : {}),
             };
         },
     });

package/dist/production-pain-evidence.d.ts

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
 import type { GovernanceHostKind } from '@principles/core/runtime-v2';
-import type { HostEvent, HostEventResult } from '@principles/core/host';
+import type { HostEvent, HostEventEmitter, HostEventResult } from '@principles/core/host';
 /** Shared with the governance admission path so both gate tool failures identically. */
 export declare const PRODUCTION_WRITE_TOOLS: ReadonlySet<string>;
 export interface PainEvidenceEntry {
@@ -85,6 +85,7 @@ export declare function createProductionPainEvidenceHandler(options?: {
     painEnrichmentProvider?: PainEnrichmentProvider;
     painDatabaseFactory?: PainDatabaseFactory;
     hostKind?: GovernanceHostKind;
+    events?: HostEventEmitter;
 }): (event: HostEvent) => Promise<HostEventResult>;
 export declare function resetProductionPainCooldownForTest(): void;
 export declare function productionPainCooldownEntryCountForTest(): number;

package/dist/production-pain-evidence.js

@@ -234,9 +234,31 @@ function hasCanonicalSchema(db) {
  */
 export function createProductionPainEvidenceHandler(options = {}) {
     return async (event) => {
+        // PRI-750: shared-path tool event with the host's natural turn/tool ids
+        // (Codex turn_id → runId, tool_use_id → toolCallId) so receipt events
+        // carry a turn-level anchor in the same events_*.jsonl format as the
+        // OpenClaw path. Emitted BEFORE the trajectory-db availability gate so
+        // the receipt chain stays observable even when the trajectory store is
+        // unavailable. Emission failure must not block the tool result — it
+        // degrades to an observable warning (rc-9). Optional port: absent means
+        // no-op (the OpenClaw plugin path emits its own tool events).
+        let emissionWarning;
+        try {
+            const earlyOutcome = normalizeOutcome(event);
+            options.events?.recordToolCall(event.context.sessionId, {
+                toolName: event.context.toolName ?? '',
+                ...(earlyOutcome.error ? { error: earlyOutcome.error } : {}),
+                ...(earlyOutcome.exitCode !== 0 ? { exitCode: earlyOutcome.exitCode } : {}),
+                ...(event.context.turnId !== undefined ? { runId: event.context.turnId } : {}),
+                ...(event.context.toolCallId !== undefined ? { toolCallId: event.context.toolCallId } : {}),
+            });
+        }
+        catch (err) {
+            emissionWarning = `receipt_event_write_failed:${err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200)}`;
+        }
         const dbPath = path.join(event.context.workspaceDir, '.state', 'trajectory.db');
         if (!fs.existsSync(dbPath)) {
-            return { decision: 'observe', source: event.source, warnings: ['trajectory_db_not_found'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'initialize the selected PD workspace before retrying the hook' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_db_not_found'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'initialize the selected PD workspace before retrying the hook' } };
         }
         let db;
         try {
@@ -245,7 +267,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             if (!hasCanonicalSchema(db)) {
                 db.close();
                 db = undefined;
-                return { decision: 'observe', source: event.source, warnings: ['trajectory_schema_invalid'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'run the supported PD workspace migration' } };
+                return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_schema_invalid'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'run the supported PD workspace migration' } };
             }
         }
         catch (error) {
@@ -253,7 +275,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
                 db?.close();
             }
             catch { /* best-effort cleanup of an unusable handle */ }
-            return { decision: 'observe', source: event.source, warnings: [`trajectory_database_unavailable:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect or repair the selected PD trajectory database' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_database_unavailable:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect or repair the selected PD trajectory database' } };
         }
         const warnings = [];
         let enrichment;
@@ -269,7 +291,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
                 db.close();
             }
             catch { /* no business write occurred */ }
-            return { decision: 'observe', source: event.source, warnings: warnings.length > 0 ? warnings : ['pain_enrichment_invalid'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect host pain enrichment input' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), ...(warnings.length > 0 ? warnings : ['pain_enrichment_invalid'])], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect host pain enrichment input' } };
         }
         const outcome = normalizeOutcome(event);
         const sanitizedParams = sanitizeToolParams(outcome.params, event.context.workspaceDir);
@@ -342,7 +364,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             }
         }
         catch (error) {
-            return { decision: 'observe', source: event.source, warnings: [`trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.failure ? 'failure' : 'success', admitted: false, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.failure ? 'failure' : 'success', admitted: false, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
         }
         finally {
             try {
@@ -351,12 +373,17 @@ export function createProductionPainEvidenceHandler(options = {}) {
             catch { /* write result already determined; cleanup is best-effort */ }
         }
         const effectiveAdmitted = admitted || duplicateAdmitted;
-        return { decision: 'observe', source: event.source, metadata: {
+        return {
+            decision: 'observe',
+            source: event.source,
+            ...(emissionWarning ? { warnings: [emissionWarning] } : {}),
+            metadata: {
                 eventId, painId: effectiveAdmitted ? painId : null, outcome: outcome.failure ? 'failure' : 'success', admitted: effectiveAdmitted, duplicate,
                 sourceKind, failureSource: sourceObservation.failureSource ?? null, triggerOutcome: trigger.outcome,
                 triggerReason: trigger.reason, painScore, isRisky, relativePath, agentId: enrichment.agentId ?? null,
                 evidence: enrichment.evidence ?? [],
-            } };
+            }
+        };
     };
 }
 export function resetProductionPainCooldownForTest() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Shared host-neutral orchestration for Principles Disciple MVP-Core hook paths.",
   "type": "module",
   "main": "./dist/index.js",