@principles/codex-adapter 0.2.9 → 0.4.0

package/dist/codec/input-decoder.js

@@ -77,9 +77,11 @@ export function decodeCodexInput(raw) {
     if (kind === 'before_tool_call' || kind === 'after_tool_call') {
         const toolName = requiredString(raw, 'tool_name');
         const toolInput = requiredUnknown(raw, 'tool_input');
-        requiredString(raw, 'tool_use_id');
+        // PRI-750: Codex `tool_use_id` is required and host-authoritative — keep it
+        // on the shared context so the receipt chain can bind tools to turns.
+        const toolCallId = requiredString(raw, 'tool_use_id');
         const toolOutput = kind === 'after_tool_call' ? requiredUnknown(raw, 'tool_response') : undefined;
-        context = { ...common, toolName, toolInput, ...(kind === 'after_tool_call' ? { toolOutput } : {}) };
+        context = { ...common, toolName, toolCallId, toolInput, ...(kind === 'after_tool_call' ? { toolOutput } : {}) };
         rawPayload = { toolInput: { toolName, params: toolInput } };
     }
     else if (kind === 'before_prompt_build') {

package/dist/pd-hook.d.ts

@@ -5,5 +5,6 @@ export interface PdHookResult {
     exitCode: number;
     stderr: string[];
 }
+export declare function annotateContextWarnings(warnings: readonly string[]): string[];
 export declare function processHookInvocation(rawStdin: string, _env?: EnvMap, cwd?: string): Promise<PdHookResult>;
 export {};

package/dist/pd-hook.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 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 { createProductionHostRuntime, loadPdConfigForPlugin, resolveNearestPdWorkspace } from '@principles/host-runtime';
 import { CODEX_TOOL_SEMANTICS } from './tool-semantics.js';
 import { computeFeatureFlagsFromConfig } from '@principles/core/runtime-v2';
@@ -9,6 +11,40 @@ 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';
+/**
+ * PRI-750: event emitter for the Codex subprocess model. Writes the same
+ * `events_<date>.jsonl` line shape as the OpenClaw EventLog via the core
+ * writer, so the Codex host path stays independent of the OpenClaw plugin
+ * (codex-adapter must not depend on principles-disciple — bundle guard).
+ */
+function codexEventEmitter(stateDir) {
+    return {
+        recordRuntimeV2ActivationsInjected(data) {
+            appendEventLogLine(stateDir, {
+                ts: new Date().toISOString(),
+                type: 'runtime_v2_prompt_activations_injected',
+                category: 'injected',
+                sessionId: data.sessionId,
+                data,
+            });
+        },
+        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,
+            });
+        },
+    };
+}
 const MAX_DIAGNOSTIC = 500;
 function diagnostic(reason, nextAction) {
     const boundedReason = reason.replace(/\s+/g, ' ').trim().slice(0, MAX_DIAGNOSTIC);
@@ -18,6 +54,26 @@ function diagnostic(reason, nextAction) {
 function errorMessage(error) {
     return error instanceof Error ? error.message.slice(0, MAX_DIAGNOSTIC) : 'unknown_error';
 }
+/**
+ * PRI-780 Codex capability declaration (structured UNSUPPORTED — suspension
+ * semantics, revised after Codex review round 2 P1): the Codex host has no
+ * runtime context provider, and the "unavailable → allow" contract is
+ * generation-time prompt discipline, NOT a runtime-enforced invariant. Handing
+ * v2 rules a truthy unavailable-posture context would let a persisted rule
+ * evaluate context-blind and DENY tool calls that were previously suspended —
+ * a silent governance behavior change. Codex therefore passes NO context
+ * provider: the shared gate skips v2 rules with its structured
+ * `rule_context_v2_unavailable` warning, and this hook annotates that warning
+ * with the explicit host-unsupported reason before it reaches Codex stderr
+ * (see annotateContextWarnings — ticket option B: 明确 unsupported + 结构化
+ * warning, never a silent skip).
+ */
+const CODEX_CONTEXT_UNSUPPORTED_NOTE = 'codex_runtime_context_unsupported: the Codex host provides no runtime context provider; v2 rules stay suspended on this host';
+export function annotateContextWarnings(warnings) {
+    return warnings.map((warning) => warning.startsWith('rule_context_v2_unavailable')
+        ? `${warning}; ${CODEX_CONTEXT_UNSUPPORTED_NOTE}`
+        : warning);
+}
 // Bounded governance-observation ingestion (Codex Governance Closure Slice
 // A) followed by the Slice B signal-admission pass (SPEC §12/§13): detection
 // → canonical pain → evidence promotion → one pending Diagnostician task.
@@ -118,8 +174,20 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
         const ingestionDiagnostics = ingestionEnabled
             ? await runConversationIngestion({ rawPayload: parsed, kind: event.kind, workspaceDir: resolution.workspaceDir, env: _env })
             : [];
-        const result = await createProductionHostRuntime({ hostKind: 'codex', toolSemantics: CODEX_TOOL_SEMANTICS }).dispatch(event);
-        const stderr = [...(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...ingestionDiagnostics];
+        // PRI-750: emit shared-path injection/tool events with the host's natural
+        // turn/tool ids (turn_id → runId, tool_use_id → toolCallId) through the core
+        // event-JSONL writer (same events_*.jsonl format as the OpenClaw EventLog;
+        // the Codex adapter stays independent of the OpenClaw plugin). The line
+        // writer appends synchronously — no flush/dispose needed for the subprocess.
+        const result = await createProductionHostRuntime({
+            hostKind: 'codex',
+            toolSemantics: CODEX_TOOL_SEMANTICS,
+            events: codexEventEmitter(path.join(resolution.workspaceDir, '.state')),
+            // PRI-780 (revised after Codex review round 2 P1): NO context provider —
+            // 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];
         return { stdout: adapter.encodeOutput(result, event.kind), exitCode: 0, stderr };
     }
     catch (error) {

package/dist/worker/workspace-worker.js

@@ -213,6 +213,9 @@ export async function runCodexWorkspaceWorkerCycle(options) {
         logger,
         emitEvent,
         toolSemantics: CODEX_TOOL_SEMANTICS,
+        // PRI-741: artificer generation gets the Codex host projection
+        // (Bash/apply_patch — evidence-bound, intentionally sparse).
+        hostKinds: ['codex'],
         // No hostToolCatalog: PD has not declared a Codex tool catalog; a wrong
         // (OpenClaw) catalog would be worse than none (PRI-630 follow-up).
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.2.9",
+  "version": "0.4.0",
   "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",