@principles/codex-adapter 0.2.9 → 0.3.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.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);
@@ -118,7 +154,16 @@ 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);
+        // 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')),
+        }).dispatch(event);
         const stderr = [...(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 };
     }

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.3.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",