@principles/codex-adapter 0.4.2 → 0.4.4

package/dist/pd-hook.js

@@ -3,7 +3,7 @@ import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { pathToFileURL } from 'node:url';
-import { appendEventLogLine, redactTelemetryString } from '@principles/core/runtime-v2';
+import { appendEventLogLine, redactTelemetryString, isRuleHostEvaluatedEventData } from '@principles/core/runtime-v2';
 import { createProductionHostRuntime, loadPdConfigForPlugin, resolveNearestPdWorkspace } from '@principles/host-runtime';
 import { CODEX_TOOL_SEMANTICS } from './tool-semantics.js';
 import { computeFeatureFlagsFromConfig } from '@principles/core/runtime-v2';
@@ -11,6 +11,15 @@ import { CodexHooksHostAdapter } from './host-adapter.js';
 import { CodexDecoderError, CodexEncoderError } from './codec/index.js';
 import { ingestCodexConversation } from './ingestion/ingestion.js';
 import { runGovernanceAdmission } from './ingestion/admission.js';
+function redactStringFields(data) {
+    // rc-8: telemetry is redacted string-field by string field (same policy as
+    // the OpenClaw EventLog redactEventData) — shared by every emitter here.
+    const redacted = {};
+    for (const [key, value] of Object.entries(data)) {
+        redacted[key] = typeof value === 'string' ? redactTelemetryString(value) : value;
+    }
+    return redacted;
+}
 /**
  * PRI-750: event emitter for the Codex subprocess model. Writes the same
  * `events_<date>.jsonl` line shape as the OpenClaw EventLog via the core
@@ -29,18 +38,12 @@ function codexEventEmitter(stateDir) {
             });
         },
         recordToolCall(sessionId, data) {
-            // rc-8: tool events are telemetry — redact every string field before
-            // persisting (same policy as the OpenClaw EventLog redactEventData).
-            const redacted = {};
-            for (const [key, value] of Object.entries(data)) {
-                redacted[key] = typeof value === 'string' ? redactTelemetryString(value) : value;
-            }
             appendEventLogLine(stateDir, {
                 ts: new Date().toISOString(),
                 type: 'tool_call',
                 category: data.error || (data.exitCode !== undefined && data.exitCode !== 0) ? 'failure' : 'success',
                 sessionId,
-                data: redacted,
+                data: redactStringFields(data),
             });
         },
     };
@@ -54,6 +57,65 @@ function diagnostic(reason, nextAction) {
 function errorMessage(error) {
     return error instanceof Error ? error.message.slice(0, MAX_DIAGNOSTIC) : 'unknown_error';
 }
+/**
+ * PRI-813: admissible evaluation entry = the CANONICAL core schema guard
+ * (rc-1/rc-2, P4: no hand-rolled field copy that could drift from the
+ * contract) plus one caller policy: a shadow observation without a non-blank
+ * activationId is dead evidence — the shadow summary keys on the exact id —
+ * so it is rejected here (CodeRabbit CR-6).
+ */
+function isAdmissibleRuleHostEvaluationEntry(value) {
+    return isRuleHostEvaluatedEventData(value)
+        && (value.activationMode !== 'shadow' || (typeof value.activationId === 'string' && value.activationId.trim().length > 0));
+}
+/**
+ * PRI-813: persist the shared gate's per-activation evaluation facts
+ * (metadata.evaluations — shadow observations plus the live aggregate) as
+ * canonical `rulehost_evaluated` events through the same core JSONL writer
+ * and the same telemetry-redaction policy the Codex emitter already uses.
+ * This is the Codex side of the shadow-evidence reconnection: exact
+ * activationId per event, `activationMode: 'shadow'` rows feed the existing
+ * rulecode-shadow-summary and promotion evidence unchanged.
+ */
+function recordRuleHostEvaluations(stateDir, sessionId, evaluations) {
+    if (!Array.isArray(evaluations))
+        return [];
+    // One bounded diagnostic per failure CLASS — an early entry-invalid must
+    // not swallow a later persist-failure (review S4).
+    const diagnostics = [];
+    let sawInvalidEntry = false;
+    let sawPersistFailure = false;
+    for (const entry of evaluations) {
+        if (!isAdmissibleRuleHostEvaluationEntry(entry)) {
+            // rc-9: a skipped evidence row must be observable, never silent.
+            if (!sawInvalidEntry) {
+                sawInvalidEntry = true;
+                diagnostics.push(diagnostic('rulehost_evaluation_entry_invalid', 'Inspect host-runtime gate metadata contract; the evaluation event was not persisted.'));
+            }
+            continue;
+        }
+        // CodeRabbit CR-1: evidence persistence is telemetry — an fs failure here
+        // must never propagate into processHookInvocation's fail-open catch,
+        // which would drop an already-computed deny from stdout and let the tool
+        // call proceed. Degrade observably instead (rc-9).
+        try {
+            appendEventLogLine(stateDir, {
+                ts: new Date().toISOString(),
+                type: 'rulehost_evaluated',
+                category: 'evaluated',
+                sessionId,
+                data: redactStringFields(entry),
+            });
+        }
+        catch (error) {
+            if (!sawPersistFailure) {
+                sawPersistFailure = true;
+                diagnostics.push(diagnostic(`rulehost_evaluation_persist_failed:${errorMessage(error)}`, 'Inspect workspace .state/logs writability; the evaluation event was not persisted, the tool decision is unaffected.'));
+            }
+        }
+    }
+    return diagnostics;
+}
 /**
  * PRI-780 Codex capability declaration (structured UNSUPPORTED — suspension
  * semantics, revised after Codex review round 2 P1): the Codex host has no
@@ -187,7 +249,13 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
             // v2 rules stay SUSPENDED on Codex (never loaded context-blind). See
             // annotateContextWarnings for the structured unsupported declaration.
         }).dispatch(event);
-        const stderr = [...annotateContextWarnings(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...ingestionDiagnostics];
+        // PRI-813: the shared gate's evaluation facts leave through metadata —
+        // persist them here (telemetry persistence is host-side business; the
+        // gate itself never writes). Codex previously recorded NO
+        // rulehost_evaluated rows, so shadow evidence never reached the
+        // promotion pipeline.
+        const evaluationDiagnostics = recordRuleHostEvaluations(path.join(resolution.workspaceDir, '.state'), event.context.sessionId, result.metadata?.evaluations);
+        const stderr = [...annotateContextWarnings(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...evaluationDiagnostics, ...ingestionDiagnostics];
         return { stdout: adapter.encodeOutput(result, event.kind), exitCode: 0, stderr };
     }
     catch (error) {

package/dist/worker/workspace-worker.js

@@ -206,6 +206,18 @@ export async function runCodexWorkspaceWorkerCycle(options) {
     });
     if (!declared.ok) {
         logger.warn?.(`[PD:CodexWorker] Failed to persist Codex tool declaration: ${declared.reason} — host-neutral consumers will not find it (rc-9)`);
+        // CodeRabbit CR-2 (PRI-813): creating activations while the Codex
+        // declaration is absent would let promotion fall back to the OpenClaw
+        // liveness contract (host_tool_declaration_missing → OpenClaw default)
+        // and falsely pass host-liveness checks for a Codex activation. Degrade
+        // this cycle instead; the next cycle retries the declaration first.
+        return {
+            ...base,
+            mode: 'degraded',
+            reason: `host_tool_declaration_persist_failed:${declared.reason}`,
+            nextAction: 'Repair Codex host declaration persistence (.pd/host-tool-semantics/codex.json) before running the downstream internalization cycle; the worker retries automatically on the next cycle.',
+            report: { catchUp, reconcile, diagnostician, downstream: null },
+        };
     }
     const downstream = await runInternalizationConsumerCycle(workspaceDir, {
         owner: WORKER_OWNER,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Codex CLI host adapter for Principles Disciple — implements HostAdapter interface for OpenAI Codex CLI's stdin/stdout JSON hook model (ADR-0020).",
   "type": "module",
   "main": "./dist/index.js",