@principles/host-runtime 0.2.0 → 0.2.1

package/dist/governance-signal-admission.js

@@ -342,9 +342,9 @@ function insertCorrectionPain({ db, candidate, workspaceDir, painId, detection,
     // is NOT used here: buildEvidence already truncated it upstream, so a token
     // straddling that cut would survive sanitization the same way.
     const excerpt = sanitizeString(candidate.text, workspaceDir);
-    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(candidate.rootSessionId, 'user_correction', GOVERNANCE_STRONG_PAIN_SCORE, reason.slice(0, MAX_REASON_BOUND), 'severe', 'system_infer', null, excerpt, painId, null, nowIso);
+    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(candidate.rootSessionId, 'user_correction', GOVERNANCE_STRONG_PAIN_SCORE, reason.slice(0, MAX_REASON_BOUND), 'severe', 'system_infer', null, excerpt, painId, null, candidate.hostKind, nowIso);
     return reason;
 }
 function taskSubmissionPayload(candidate, workspaceDir, reason) {
@@ -415,6 +415,9 @@ function admitCorrection({ db, candidate, workspaceDir, now, nowIso, keywordStor
                 // Live + transcript duplicate or a crash-replay: the canonical pain
                 // already exists — no second row, no second quota consumption.
                 duplicate = true;
+                // PRI-640 §17: enrich unknown → codex from proven governance lineage;
+                // the IS NULL guard keeps any durable attribution (never overwrites).
+                db.prepare('UPDATE pain_events SET host_kind = ? WHERE canonical_pain_id = ? AND host_kind IS NULL').run(candidate.hostKind, painId);
             }
             else {
                 if (!tryConsumeRateLimit({ db, rootSessionId: candidate.rootSessionId, ruleVersion: detection.ruleVersion, now })) {
@@ -488,9 +491,12 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
             db.prepare(`INSERT INTO tool_calls (session_id, tool_name, outcome, duration_ms, exit_code, error_type, error_message, gfi_before, gfi_after, params_json, result_preview, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
                 .run(candidate.rootSessionId, candidate.toolName, outcome.failure ? 'failure' : 'success', outcome.durationMs ?? null, outcome.exitCode, outcome.error ? outcome.error.split(/[\s:]/, 1)[0] : null, outcome.error ?? null, null, null, paramsJson, resultPreview, nowIso);
             reason = `tool=${candidate.toolName}; error=${outcome.error ?? `exit=${outcome.exitCode}`}; path=${relativePath}`;
-            db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(candidate.rootSessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, null, painId, null, nowIso);
+            db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(candidate.rootSessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, null, painId, null, candidate.hostKind, nowIso);
         }
+        // PRI-640 §17: enrich unknown → codex on the already-admitted duplicate
+        // pain row; the IS NULL guard keeps any durable attribution.
+        db.prepare('UPDATE pain_events SET host_kind = ? WHERE canonical_pain_id = ? AND host_kind IS NULL').run(candidate.hostKind, painId);
         if (!duplicateWithoutPain) {
             insertAdmissionMarker({ db, candidate, workspaceDir, canonicalPainId: painId, ruleVersion: null, reason: sanitizeString(reason, workspaceDir), nowIso });
         }

package/dist/index.d.ts

@@ -3,6 +3,7 @@ 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';
 import { type PainDatabaseFactory, type PainEnrichmentProvider } from './production-pain-evidence.js';
+import type { GovernanceHostKind } from '@principles/core/runtime-v2';
 export * from './active-principle-prompt.js';
 export * from './pd-config.js';
 export * from './production-rulehost-gate.js';
@@ -53,4 +54,6 @@ export declare function createProductionHostRuntime(options?: Partial<Pick<HostR
     ruleImplementationRuntime?: RuleImplementationRuntime;
     painEnrichmentProvider?: PainEnrichmentProvider;
     painDatabaseFactory?: PainDatabaseFactory;
+    /** PRI-640: host attribution supplied by the constructing host adapter (OpenClaw / Codex). */
+    hostKind?: GovernanceHostKind;
 }): HostRuntime;

package/dist/index.js

@@ -146,6 +146,7 @@ export function createProductionHostRuntime(options = {}) {
         afterToolCall: options.afterToolCall ?? createProductionPainEvidenceHandler({
             ...(options.painEnrichmentProvider ? { painEnrichmentProvider: options.painEnrichmentProvider } : {}),
             ...(options.painDatabaseFactory ? { painDatabaseFactory: options.painDatabaseFactory } : {}),
+            ...(options.hostKind ? { hostKind: options.hostKind } : {}),
         }),
         beforeToolCall: options.beforeToolCall ?? productionGate,
         async beforePromptBuild(event) {

package/dist/internalization-consumer-cycle.js

@@ -170,6 +170,20 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
     }
     const runtimeConfigResult = resolveRuntimeConfigFromPdConfig(configResult.effective, (name) => envGetter(name));
     if (isRuntimeConfigError(runtimeConfigResult)) {
+        // PRI-638 P1-C: the shared runtime resolver reads the Diagnostician
+        // binding; an Owner-disabled agent reports reason='disabled'. That is an
+        // intentional governance pause, not a broken runtime — report it
+        // distinctly so consumers (Codex worker) never treat it as degradation.
+        if (runtimeConfigResult.reason === 'disabled') {
+            const disabledInfo = JSON.stringify({
+                reason: 'capability_disabled',
+                message: runtimeConfigResult.message,
+                nextAction: runtimeConfigResult.nextAction,
+            });
+            emitEvent('INTERNALIZATION_CONSUMER_SKIP', disabledInfo);
+            logger.warn(`[PD:${logLabel}] Cycle skipped: Diagnostician capability disabled — ${runtimeConfigResult.message}`);
+            return { ran: false, skipReason: 'capability_disabled' };
+        }
         const rtInfo = JSON.stringify({
             reason: 'runtime_config_error',
             message: runtimeConfigResult.message,

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

@@ -1,4 +1,5 @@
 import Database from 'better-sqlite3';
+import type { GovernanceHostKind } from '@principles/core/runtime-v2';
 import type { HostEvent, 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>;
@@ -75,9 +76,15 @@ export declare function deriveProductionCorrectionPainIdentity(fields: {
     painId: string;
 };
 declare function hasCanonicalSchema(db: Database.Database): boolean;
+/**
+ * PRI-640: host attribution is supplied by the host adapter that constructs
+ * this shared handler (OpenClaw / Codex adapters) — never guessed inside the
+ * writer. Omitted -> NULL (unknown).
+ */
 export declare function createProductionPainEvidenceHandler(options?: {
     painEnrichmentProvider?: PainEnrichmentProvider;
     painDatabaseFactory?: PainDatabaseFactory;
+    hostKind?: GovernanceHostKind;
 }): (event: HostEvent) => Promise<HostEventResult>;
 export declare function resetProductionPainCooldownForTest(): void;
 export declare function productionPainCooldownEntryCountForTest(): number;

package/dist/production-pain-evidence.js

@@ -173,7 +173,7 @@ export function deriveProductionCorrectionPainIdentity(fields) {
 const REQUIRED_COLUMNS = {
     sessions: { session_id: 'TEXT', started_at: 'TEXT', updated_at: 'TEXT' },
     tool_calls: { session_id: 'TEXT', tool_name: 'TEXT', outcome: 'TEXT', duration_ms: 'INTEGER', exit_code: 'INTEGER', error_type: 'TEXT', error_message: 'TEXT', gfi_before: 'REAL', gfi_after: 'REAL', params_json: 'TEXT', result_preview: 'TEXT', created_at: 'TEXT' },
-    pain_events: { session_id: 'TEXT', source: 'TEXT', score: 'REAL', reason: 'TEXT', severity: 'TEXT', origin: 'TEXT', confidence: 'REAL', text: 'TEXT', canonical_pain_id: 'TEXT', runtime_task_id: 'TEXT', created_at: 'TEXT' },
+    pain_events: { session_id: 'TEXT', source: 'TEXT', score: 'REAL', reason: 'TEXT', severity: 'TEXT', origin: 'TEXT', confidence: 'REAL', text: 'TEXT', canonical_pain_id: 'TEXT', runtime_task_id: 'TEXT', host_kind: 'TEXT', created_at: 'TEXT' },
 };
 function pragmaField(row, key) {
     return isRecord(row) && Object.hasOwn(row, key) ? Object.getOwnPropertyDescriptor(row, key)?.value : undefined;
@@ -224,9 +224,14 @@ function hasCanonicalSchema(db) {
     db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?');
     db.prepare('INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at');
     db.prepare('INSERT INTO tool_calls (session_id, tool_name, outcome, duration_ms, exit_code, error_type, error_message, gfi_before, gfi_after, params_json, result_preview, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    db.prepare('INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+    db.prepare('INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
     return true;
 }
+/**
+ * PRI-640: host attribution is supplied by the host adapter that constructs
+ * this shared handler (OpenClaw / Codex adapters) — never guessed inside the
+ * writer. Omitted -> NULL (unknown).
+ */
 export function createProductionPainEvidenceHandler(options = {}) {
     return async (event) => {
         const dbPath = path.join(event.context.workspaceDir, '.state', 'trajectory.db');
@@ -319,8 +324,8 @@ export function createProductionPainEvidenceHandler(options = {}) {
                     // declared enum (event-types.ts: who reported the pain), not an
                     // attribution claim.
                     const reason = `tool=${toolName}; error=${outcome.error ?? `exit=${outcome.exitCode}`}; path=${relativePath}`;
-                    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                        .run(event.context.sessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, enrichment.evidence?.map((entry) => `${entry.sourceRef}: ${entry.note}`).join('\n') ?? null, painId, null, createdAt);
+                    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .run(event.context.sessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, enrichment.evidence?.map((entry) => `${entry.sourceRef}: ${entry.note}`).join('\n') ?? null, painId, null, options.hostKind ?? null, createdAt);
                 }
             })();
             if (admitted && !duplicate) {

package/package.json

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