@principles/codex-adapter 0.2.0 → 0.2.1

package/dist/pd-hook.js

@@ -109,7 +109,7 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
     }
     try {
         if (event.kind === 'session_start') {
-            const health = await createProductionHostRuntime().health(resolution.workspaceDir);
+            const health = await createProductionHostRuntime({ hostKind: 'codex' }).health(resolution.workspaceDir);
             if (!health.ok)
                 return { stdout: {}, exitCode: 0, stderr: [diagnostic(health.reason ?? 'runtime_unhealthy', health.nextAction ?? 'Inspect the Workspace runtime.')] };
             return { stdout: adapter.encodeOutput({ decision: 'allow', source: event.source }, 'session_start'), exitCode: 0, stderr: [] };
@@ -117,7 +117,7 @@ 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().dispatch(event);
+        const result = await createProductionHostRuntime({ hostKind: 'codex' }).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.d.ts

@@ -11,6 +11,8 @@ export interface CodexWorkerCycleStepReport {
         readonly status: 'succeeded' | 'failed' | 'retried' | 'skipped' | 'degraded';
         readonly message?: string;
         readonly errorCategory?: string;
+        /** PRI-638 P1-C: recovery action for capability-disabled pauses. */
+        readonly nextAction?: string;
     } | null;
     readonly downstream: InternalizationConsumerCycleOutcome | null;
 }

package/dist/worker/workspace-worker.js

@@ -23,7 +23,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import { computeFeatureFlagsFromConfig, createRuntimeStateHandle, createPainSignalBridge, isRetryWaitBackoffElapsed, PrincipleTreeLedgerAdapter, } from '@principles/core/runtime-v2';
+import { computeFeatureFlagsFromConfig, createRuntimeStateHandle, createPainSignalBridge, isRetryWaitBackoffElapsed, PrincipleTreeLedgerAdapter, resolveDiagnosticianCapability, } from '@principles/core/runtime-v2';
 import { loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, } from '@principles/host-runtime';
 import { catchUpCodexIngestion } from '../ingestion/catch-up.js';
 const WORKER_OWNER = 'companion-worker';
@@ -86,6 +86,15 @@ export async function runCodexWorkspaceWorkerCycle(options) {
         return { ...base, mode: 'paused', reason: 'host.codex_disabled', nextAction: 'Set features.host.codex.enabled=true in the Workspace .pd/config.yaml to enable Codex PD behavior.' };
     }
     const consumerFlag = loadFeatureFlagFromConfig(workspaceDir, 'internalization_auto_consumer', { info: (m) => logger.info(m), warn: (m) => logger.warn(m) });
+    // PRI-638 P1-C: the Diagnostician capability gate is resolved from the same
+    // canonical authority the runtime factory uses. An Owner-disabled agent is
+    // an intentional governance state: the worker must NOT pick pending tasks,
+    // must NOT invoke any runner (provider calls = 0), must NOT report the
+    // workspace degraded, and must keep catch-up / reconciliation / downstream
+    // running. Pending tasks stay untouched and resume on a later cycle after
+    // the Owner re-enables the agent.
+    const capability = resolveDiagnosticianCapability(config.effective);
+    const diagnosticianDisabled = !capability.available;
     // Step 2 — Catch-up transcript lag (SPEC §13: gated by the ingestion flag,
     // NOT by the consumer flag; catchUpCodexIngestion re-checks and returns a
     // zero-I/O skip when ingestion is off).
@@ -99,7 +108,18 @@ export async function runCodexWorkspaceWorkerCycle(options) {
     const reconcile = await reconcileGovernanceContinuation({ workspaceDir });
     // Steps 4–6 — execution authority: internalization_auto_consumer.
     let diagnostician = null;
-    if (!consumerFlag.enabled) {
+    if (diagnosticianDisabled) {
+        // PRI-638 P1-C: intentional governance pause. No candidate picking, no
+        // provider call, no degraded mode. The rest of the cycle (downstream)
+        // continues below; pending tasks resume once the Owner re-enables.
+        diagnostician = {
+            taskId: '',
+            status: 'skipped',
+            message: 'capability_disabled',
+            nextAction: capability.available ? undefined : capability.nextAction,
+        };
+    }
+    else if (!consumerFlag.enabled) {
         // paused: execution pause, NOT evidence freeze. Catch-up + reconcile
         // already ran above; manual CLI remains allowed (SPEC §13).
         return {
@@ -110,63 +130,68 @@ export async function runCodexWorkspaceWorkerCycle(options) {
             report: { catchUp, reconcile, diagnostician: null, downstream: null },
         };
     }
-    // Step 4 — expired-lease recovery sweep, then Step 5/6: at most one
-    // Diagnostician task via the existing bridge lease/runner contract.
-    try {
-        const handle = await createRuntimeStateHandle({ workspaceDir, readonly: false });
+    else {
+        // Step 4 — expired-lease recovery sweep, then Step 5/6: at most one
+        // Diagnostician task via the existing bridge lease/runner contract.
+        // (Reached only when the Diagnostician capability is enabled AND the
+        // consumer flag is on — an intentional capability pause never reaches
+        // candidate picking or any provider call.)
         try {
-            const sweep = await handle.stateManager.runRecoverySweep();
-            if (sweep.recovered > 0 || sweep.errors.length > 0) {
-                emitEvent('CODEX_WORKER_RECOVERY_SWEEP', JSON.stringify({ recovered: sweep.recovered, failed: sweep.errors.length }));
-            }
-            const candidate = await pickDiagnosticianCandidate(handle.stateManager, options.diagnosticianCandidateLimit ?? DEFAULT_DIAG_CANDIDATE_LIMIT);
-            if (candidate !== null) {
-                const stateDir = path.join(workspaceDir, '.state');
-                const bridge = await createPainSignalBridge({
-                    workspaceDir,
-                    stateDir,
-                    ledgerAdapter: new PrincipleTreeLedgerAdapter({ stateDir }),
-                    owner: WORKER_OWNER,
-                    effectiveConfig: config.effective,
-                    getEnvVar: (name) => process.env[name],
-                });
-                const executed = await bridge.executePendingDiagnosis({ taskId: candidate.taskId });
-                diagnostician = {
-                    taskId: candidate.taskId,
-                    status: executed.status,
-                    ...(executed.message !== undefined ? { message: executed.message.slice(0, 200) } : {}),
-                    ...(executed.errorCategory !== undefined ? { errorCategory: executed.errorCategory } : {}),
-                };
-                // The bridge stays cached per workspace (bounded: one per workspace
-                // per worker process, exactly like the OpenClaw plugin host) — no
-                // per-cycle dispose, so a concurrent cycle can never hit a disposed
-                // bridge. The factory self-disposes losing concurrent constructions.
-            }
-            else {
-                // No eligible candidate, but a retry_wait task may still be inside
-                // its backoff window — report it so the cycle is observable instead
-                // of looking like "nothing pending" (review P1: head-of-line).
-                const waiting = await handle.stateManager.listTasks({ taskKind: 'diagnostician', status: 'retry_wait', orderBy: 'updated_at_asc', limit: 1 });
-                const [oldestWaiting] = waiting;
-                if (oldestWaiting !== undefined && !isRetryWaitBackoffElapsed(oldestWaiting.status, oldestWaiting.leaseExpiresAt)) {
-                    diagnostician = { taskId: oldestWaiting.taskId, status: 'skipped', message: 'retry_wait_pending' };
+            const handle = await createRuntimeStateHandle({ workspaceDir, readonly: false });
+            try {
+                const sweep = await handle.stateManager.runRecoverySweep();
+                if (sweep.recovered > 0 || sweep.errors.length > 0) {
+                    emitEvent('CODEX_WORKER_RECOVERY_SWEEP', JSON.stringify({ recovered: sweep.recovered, failed: sweep.errors.length }));
+                }
+                const candidate = await pickDiagnosticianCandidate(handle.stateManager, options.diagnosticianCandidateLimit ?? DEFAULT_DIAG_CANDIDATE_LIMIT);
+                if (candidate !== null) {
+                    const stateDir = path.join(workspaceDir, '.state');
+                    const bridge = await createPainSignalBridge({
+                        workspaceDir,
+                        stateDir,
+                        ledgerAdapter: new PrincipleTreeLedgerAdapter({ stateDir }),
+                        owner: WORKER_OWNER,
+                        effectiveConfig: config.effective,
+                        getEnvVar: (name) => process.env[name],
+                    });
+                    const executed = await bridge.executePendingDiagnosis({ taskId: candidate.taskId });
+                    diagnostician = {
+                        taskId: candidate.taskId,
+                        status: executed.status,
+                        ...(executed.message !== undefined ? { message: executed.message.slice(0, 200) } : {}),
+                        ...(executed.errorCategory !== undefined ? { errorCategory: executed.errorCategory } : {}),
+                    };
+                    // The bridge stays cached per workspace (bounded: one per workspace
+                    // per worker process, exactly like the OpenClaw plugin host) — no
+                    // per-cycle dispose, so a concurrent cycle can never hit a disposed
+                    // bridge. The factory self-disposes losing concurrent constructions.
+                }
+                else {
+                    // No eligible candidate, but a retry_wait task may still be inside
+                    // its backoff window — report it so the cycle is observable instead
+                    // of looking like "nothing pending" (review P1: head-of-line).
+                    const waiting = await handle.stateManager.listTasks({ taskKind: 'diagnostician', status: 'retry_wait', orderBy: 'updated_at_asc', limit: 1 });
+                    const [oldestWaiting] = waiting;
+                    if (oldestWaiting !== undefined && !isRetryWaitBackoffElapsed(oldestWaiting.status, oldestWaiting.leaseExpiresAt)) {
+                        diagnostician = { taskId: oldestWaiting.taskId, status: 'skipped', message: 'retry_wait_pending' };
+                    }
                 }
             }
+            finally {
+                await handle.close().catch(() => undefined);
+            }
         }
-        finally {
-            await handle.close().catch(() => undefined);
+        catch (error) {
+            const detail = error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200);
+            return {
+                ...base,
+                mode: 'degraded',
+                reason: `diagnostician_execution_failed:${detail}`,
+                nextAction: 'Inspect the Workspace runtime profile and provider configuration; the task keeps its pending/retry state and no evidence was mutated.',
+                report: { catchUp, reconcile, diagnostician: null, downstream: null },
+            };
         }
     }
-    catch (error) {
-        const detail = error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200);
-        return {
-            ...base,
-            mode: 'degraded',
-            reason: `diagnostician_execution_failed:${detail}`,
-            nextAction: 'Inspect the Workspace runtime profile and provider configuration; the task keeps its pending/retry state and no evidence was mutated.',
-            report: { catchUp, reconcile, diagnostician: null, downstream: null },
-        };
-    }
     // Step 7 — ONE bounded downstream consumer cycle via the shared executor
     // (same implementation the OpenClaw auto-consumer runs).
     const downstream = await runInternalizationConsumerCycle(workspaceDir, {

package/package.json

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