@principles/pd-cli 1.148.0 → 1.149.1

package/src/commands/pain-record.ts

@@ -11,16 +11,20 @@
  * workspace's trajectory.db, and collect raw evidence entries.
  *
  * Usage:
- *   pd pain record --reason <text> [--score N] [--source manual] [--workspace <path>] [--session <id>] [--host openclaw|codex] [--json]
+ *   pd pain record --reason <text> [--score N] [--source manual] [--workspace <path>] [--session <id>] [--host openclaw|codex] [--rollout-id <id> --host-turn-id <id>] [--json]
  *
  * PRI-743: `--host` makes host attribution explicit instead of assumed.
  * `--host openclaw` records the default attribution without the disclosure
- * warning; `--host codex` refuses loudly — the CLI can verify OpenClaw
- * trajectory sessions but can never verify a Codex lineage tuple
- * (rolloutIdentity / logicalObservationKey, rc-6), so codex pains must come
- * from the Codex ingestion path, never from the CLI. The correlation schema
- * itself is NOT changed — PainIngressCorrelationV1 bound branches only admit
- * openclaw/codex.
+ * warning. `--host codex` requires the caller to supply the REAL Codex
+ * lineage — `--rollout-id` / `--host-turn-id`, with `--session` as the Codex
+ * root session — because the shared ingress evaluator only writes
+ * `host_kind=codex` for a bound correlation carrying the complete lineage
+ * tuple (rc-6). The CLI never synthesises that tuple: an unverifiable Codex
+ * attribution would be a PRI-642 recurrence in another shape (Evidence Over
+ * Assumption). `--logical-key` overrides the derived observation key; a key
+ * that does not embed the given rollout identity is refused by the evaluator
+ * (lineage_mismatch). The correlation schema itself is NOT changed —
+ * PainIngressCorrelationV1 bound branches only admit openclaw/codex.
  */
 import {
   PainToPrincipleService,
@@ -31,7 +35,7 @@ import {
   isBuiltinPiAiProvider,
   evaluatePainIngress,
 } from '@principles/core/runtime-v2';
-import type { PainIngressDecision, IngressEvidenceEntry, PainEvidenceEntry } from '@principles/core/runtime-v2';
+import type { PainIngressDecision, IngressEvidenceEntry, PainEvidenceEntry, PainCorrelation } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { loadPdConfig, computeFlagsFromLoadResult } from '../services/pd-config-loader.js';
 import { acquireTrajectoryEvidenceFromDb } from './build-trajectory-evidence.js';
@@ -46,6 +50,12 @@ interface RecordOptions {
   wait?: boolean;
   /** PRI-743: explicit host attribution for a bound --session pain. */
   host?: string;
+  /** PRI-743 follow-up: Codex rollout identity — required by --host codex. */
+  rolloutId?: string;
+  /** PRI-743 follow-up: Codex turn id — required by --host codex. */
+  hostTurnId?: string;
+  /** PRI-743 follow-up: Codex logical observation key override for --host codex. */
+  logicalKey?: string;
 }
 
 function emitSessionBindingFailure(
@@ -107,6 +117,36 @@ function resolveIngressDecision(
     score,
   };
 
+  // PRI-743 follow-up: an explicit Codex attribution. The lineage ids are the
+  // caller's (presence validated in handlePainRecord); the logical observation
+  // key is derived with the SAME rule the Codex ingestion path uses
+  // (codex-adapter admission.ts buildLiveCorrectionCandidate →
+  // `codex|<rolloutIdentity>|<turnId>|user`) unless --logical-key overrides it.
+  // The CLI cannot read the Codex trajectory (that is the ingestion path's
+  // job), so the evidence class is honestly 'unavailable': the shared
+  // evaluator takes its bound+unavailable 'degrade' branch and submits the
+  // pain with real lineage and empty evidence rather than fabricating either.
+  if (opts.host === 'codex') {
+    const rolloutIdentity = opts.rolloutId as string;
+    const hostTurnId = opts.hostTurnId as string;
+    const rootSessionId = opts.session as string;
+    const correlation: PainCorrelation = {
+      status: 'bound',
+      hostKind: 'codex',
+      rootSessionId,
+      rolloutIdentity,
+      logicalObservationKey: opts.logicalKey ?? `codex|${rolloutIdentity}|${hostTurnId}|user`,
+      hostTurnId,
+    };
+    const decision = evaluatePainIngress({
+      ...base,
+      origin: { kind: 'owner_manual', channel: 'cli_explicit_session' },
+      correlation,
+      evidence: { status: 'unavailable', reason: 'trajectory_unavailable' },
+    });
+    return { decision, acquisitionDetail: null, acquisitionReason: null };
+  }
+
   if (!opts.session) {
     // No --session: external unbound Owner report (matrix row 6). Allowed
     // by SPEC §7.4 with a disclosure warning; never claims host binding.
@@ -149,8 +189,8 @@ function resolveIngressDecision(
     // PRI-743: host attribution is explicit when --host openclaw is given;
     // absent --host keeps the pre-PRI-743 'openclaw' default (validated and
     // disclosed by handlePainRecord — rc-9). --host codex never reaches this
-    // point: it is refused before any mutation (no verifiable lineage), so
-    // the bound correlation below is always the openclaw shape.
+    // point — it returns from its own branch above and must not read the
+    // OpenClaw trajectory — so the bound correlation here is the openclaw shape.
     const hostKind = 'openclaw' as const;
     const decision = evaluatePainIngress({
       ...base,
@@ -192,30 +232,40 @@ export async function handlePainRecord(opts: RecordOptions): Promise<void> {
     return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
   }
 
-  // PRI-743: a CLI-claimed codex attribution would be a PRI-642 recurrence in
-  // another shape — the shared ingress evaluator requires the rollout lineage
-  // tuple (rc-6) that only the Codex ingestion path can produce, and the CLI
-  // owns no Codex identity. Refuse before any mutation instead of faking it.
+  // PRI-743 follow-up: --host codex must carry the REAL Codex lineage. The
+  // shared ingress evaluator only attributes `host_kind=codex` to a bound
+  // correlation holding the complete tuple (rootSessionId / rolloutIdentity /
+  // logicalObservationKey / hostTurnId — rc-6); the CLI never synthesises that
+  // tuple, because an unverifiable Codex attribution would itself be the
+  // misattribution PRI-743 exists to remove. Missing lineage fails loud before
+  // any mutation (cli-5/cli-6) — the caller owns those ids.
   if (opts.host === 'codex') {
-    const message = 'the CLI cannot verify Codex lineage (rolloutIdentity / logicalObservationKey) — codex pains are produced by the Codex ingestion path, not by pd pain record';
-    if (opts.json) {
-      console.log(JSON.stringify({
-        status: 'failed',
-        reason: 'codex_lineage_unverifiable_by_cli',
-        message,
-        nextAction: 'Record Codex pains through the Codex ingestion path (pd codex setup enables it), or use --host openclaw for OpenClaw-attributed sessions.',
-      }, null, 2));
-    } else {
-      console.error(`Error: ${message}`);
-      console.error('Next action: record Codex pains through the Codex ingestion path (pd codex setup enables it), or use --host openclaw for OpenClaw-attributed sessions.');
+    const missing: string[] = [];
+    if (!opts.session) missing.push('--session <codex root session id>');
+    if (!opts.rolloutId) missing.push('--rollout-id <codex rollout identity>');
+    if (!opts.hostTurnId) missing.push('--host-turn-id <codex turn id>');
+    if (missing.length > 0) {
+      const message = `--host codex requires the real Codex lineage — missing ${missing.join(', ')}`;
+      const nextAction = 'Pass --session <root session id> --rollout-id <rollout identity> --host-turn-id <turn id> so the pain carries verifiable Codex lineage, or use --host openclaw for OpenClaw-attributed sessions.';
+      if (opts.json) {
+        console.log(JSON.stringify({
+          status: 'failed',
+          reason: 'codex_lineage_required',
+          message,
+          nextAction,
+        }, null, 2));
+      } else {
+        console.error(`Error: ${message}`);
+        console.error(`Next action: ${nextAction}`);
+      }
+      process.exit(1);
+      return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
     }
-    process.exit(1);
-    return; // guard: test stubs of process.exit continue execution (cli-2-exit-stops)
   }
 
   if (!opts.reason) {
     console.error('Error: --reason <text> is required');
-    console.error('Usage: pd pain record --reason <text> [--score N] [--source manual] [--workspace <path>] [--session <id>] [--host openclaw|codex] [--json]');
+    console.error('Usage: pd pain record --reason <text> [--score N] [--source manual] [--workspace <path>] [--session <id>] [--host openclaw|codex] [--rollout-id <id> --host-turn-id <id>] [--json]');
     process.exit(1);
     return;
   }
@@ -422,8 +472,11 @@ export async function handlePainRecord(opts: RecordOptions): Promise<void> {
   // PRI-743: the pre-existing 'openclaw' default is an assumption, not
   // evidence — disclose it whenever it actually applies (rc-9), so host
   // attribution can never silently distort PRI-743-style host comparisons.
+  // Unbound reports (no --session) keep host_kind NULL: they carry no host
+  // trace at all, so labelling them 'openclaw' would be a fresh misattribution
+  // rather than a compatibility default.
   const hostDefaultWarning = binding.sessionId !== undefined && opts.host === undefined
-    ? `host attribution defaulted to 'openclaw' (--host not given); pass --host codex to attribute this pain to the Codex host.`
+    ? 'host kind not specified, defaulting to openclaw; pass --host codex with --rollout-id/--host-turn-id to attribute this pain to the Codex host.'
     : null;
   if (hostDefaultWarning !== null) cliWarnings.push(hostDefaultWarning);
 

package/src/commands/runtime-init.ts

@@ -1,9 +1,11 @@
 /**
  * pd runtime init — Initialize all PD SQLite databases for a workspace.
  *
- * Creates state.db, trajectory.db, and subagent_workflows.db with full schema
+ * Creates state.db and trajectory.db with full schema
  * (tables + indexes + views + migrations). Idempotent: safe to run on existing
  * workspaces (all CREATE statements use IF NOT EXISTS).
+ * (subagent_workflows.db initialization removed in PRI-737 with the legacy
+ * evolution worker chain — the workflow store had no remaining producers.)
  *
  * Output contract (cli-1 strict-json, cli-4 dry-run/confirm mutex, cli-6 nextAction):
  * - Default mode is --dry-run (no writes); use --confirm to actually initialize.
@@ -22,7 +24,7 @@ import * as fs from 'fs';
 import * as yaml from 'js-yaml';
 import { SqliteConnection, SchemaConformanceReadModel } from '@principles/core/runtime-v2';
 import { getDefaultPdConfig, validatePdConfig } from '@principles/core/runtime-v2';
-import { initTrajectorySchema, initWorkflowSchema } from 'principles-disciple';
+import { initTrajectorySchema } from 'principles-disciple';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { emitResult, emitFlagConflict, emitError } from '../services/cli-output.js';
 
@@ -82,7 +84,6 @@ export interface RuntimeInitOutput {
 const DB_NAMES = {
   state: 'state.db',
   trajectory: 'trajectory.db',
-  workflow: 'subagent_workflows.db',
 } as const;
 
 // ── Config file generation ─────────────────────────────────────────────────────
@@ -290,48 +291,9 @@ export function buildRuntimeInitOutput(workspaceDir: string, confirm: boolean):
     }
   }
 
-  // 3. subagent_workflows.db (via initWorkflowSchema)
-  if (!confirm) {
-    databases.push({
-      name: DB_NAMES.workflow,
-      path: path.join(resolvedWorkspace, '.state', 'subagent_workflows.db'),
-      tables: ['schema_version', 'subagent_workflows', 'subagent_workflow_events'],
-      status: 'skipped',
-      warnings: [],
-    });
-  } else {
-    try {
-      const result = initWorkflowSchema(resolvedWorkspace);
-      if (result.warnings.length > 0) {
-        warnings.push(...result.warnings.map((w: string) => `${DB_NAMES.workflow}: ${w}`));
-      }
-      databases.push({
-        name: DB_NAMES.workflow,
-        path: path.join(resolvedWorkspace, '.state', 'subagent_workflows.db'),
-        tables: result.tables,
-        status: 'initialized',
-        warnings: result.warnings,
-      });
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      databases.push({
-        name: DB_NAMES.workflow,
-        path: path.join(resolvedWorkspace, '.state', 'subagent_workflows.db'),
-        tables: [],
-        status: 'failed',
-        warnings: [reason],
-      });
-      return {
-        ok: false,
-        mode: 'confirm',
-        workspace: resolvedWorkspace,
-        databases,
-        warnings,
-        reason: `subagent_workflows.db initialization failed: ${reason}`,
-        nextAction: 'Check workspace directory permissions and disk space, then retry.',
-      };
-    }
-  }
+  // 3. subagent_workflows.db — no longer initialized (PRI-737): the legacy
+  // workflow store had zero producers and the worker chain is retired.
+  // Existing legacy databases in old workspaces are left untouched.
 
   // Verify state.db schema conformance after initialization (confirm mode only)
   if (confirm) {

package/src/commands/runtime-internalization-run-once.ts

@@ -17,8 +17,8 @@ import {
   DefaultRolloutReviewerValidator,
   TestDoubleRuntimeAdapter,
 } from '@principles/core/runtime-v2';
-import type { WakeOnceResult, DreamerRunnerResult, PhilosopherRunnerResult, ScribeRunnerResult, ArtificerRunnerResult, EvaluatorRunnerResult, RolloutReviewerRunnerResult, PDRuntimeAdapter, PeerRunnerKind, OutputLanguage } from '@principles/core/runtime-v2';
-import { resolveRuntimeConfigForAgent, AGENT_NAME_FOR_TASK_KIND, isRuntimeConfigError } from '@principles/core/runtime-v2';
+import type { WakeOnceResult, DreamerRunnerResult, PhilosopherRunnerResult, ScribeRunnerResult, ArtificerRunnerResult, EvaluatorRunnerResult, RolloutReviewerRunnerResult, PDRuntimeAdapter, PeerRunnerKind, OutputLanguage, ArtificerHostSemanticContext } from '@principles/core/runtime-v2';
+import { resolveRuntimeConfigForAgent, AGENT_NAME_FOR_TASK_KIND, isRuntimeConfigError, buildArtificerHostSemanticContext } from '@principles/core/runtime-v2';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
 import { readOutputLanguageFromWorkspace } from '../config-reader.js';
 import { loadPdConfig } from '../services/pd-config-loader.js';
@@ -463,6 +463,7 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
   // BEFORE leasing any task (cli-5: no mutation on refusal) with the same
   // structured semantics as runtime-activation's code_tool_hook refusal.
   let evaluatorGateDeps: RefinerRuleHostGateDeps | undefined;
+  let evaluatorHostSemanticContext: ArtificerHostSemanticContext | undefined;
   if (runnerKind === 'evaluator') {
     const evaluatorContext = createEvaluatorRuntimeContext({ workspaceDir });
     if (!evaluatorContext.ok) {
@@ -482,6 +483,11 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
       return;
     }
     evaluatorGateDeps = evaluatorContext.gateDeps;
+    // PRI-741 (review round): the projection derives from the SAME registry
+    // snapshot the gateDeps were built from — never a second independent read
+    // of the durable declaration (snapshot divergence would let the sandbox
+    // and the parity case disagree on canonical kinds).
+    evaluatorHostSemanticContext = buildArtificerHostSemanticContext(evaluatorContext.registry, evaluatorContext.hostKinds ?? []);
   }
 
   const stateManager = new RuntimeStateManager({ workspaceDir });
@@ -593,9 +599,27 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
           runnerResult = await runner.run(wakeResult.taskId);
         } else if (runnerKind === 'artificer') {
           const validator = new DefaultArtificerValidator();
+          // PRI-741: artificer generation anchors on the workspace host
+          // declaration (same durable provenance the evaluator gate uses).
+          // Unresolvable provenance degrades OBSERVABLY (rc-9/EP-03) to a
+          // prompt without the host block — never a silent wrong-host guess.
+          const hostSemantics = resolveWorkspaceHostToolSemantics(workspaceDir);
+          if (!hostSemantics.ok) {
+            console.error(`[PD:run-once] artificer prompt without host tool semantics: ${hostSemantics.reason} — ${hostSemantics.nextAction}`);
+          }
           const runner = new ArtificerRunner(
             { stateManager, runtimeAdapter, eventEmitter, validator, artifactStore, contentHashFn },
-            { owner: OWNER, runtimeKind: runtimeAdapter.kind(), pollIntervalMs: 100, timeoutMs: effectiveTimeoutMs, effectiveConfig, outputLanguage },
+            {
+              owner: OWNER,
+              runtimeKind: runtimeAdapter.kind(),
+              pollIntervalMs: 100,
+              timeoutMs: effectiveTimeoutMs,
+              effectiveConfig,
+              outputLanguage,
+              ...(hostSemantics.ok
+                ? { hostSemanticContext: buildArtificerHostSemanticContext(hostSemantics.registry, hostSemantics.hostKinds) }
+                : {}),
+            },
           );
           runnerResult = await runner.run(wakeResult.taskId);
         } else if (runnerKind === 'evaluator') {
@@ -629,6 +653,9 @@ export async function handleRuntimeInternalizationRunOnce(opts: RunOnceOptions):
               timeoutMs: effectiveTimeoutMs,
               effectiveConfig,
               gateDeps: evaluatorGateDeps,
+              // PRI-741: host-name parity replay case (same provenance as
+              // gateDeps; undefined = observable skip event in the runner).
+              ...(evaluatorHostSemanticContext !== undefined ? { hostSemanticContext: evaluatorHostSemanticContext } : {}),
               outputLanguage,
             },
           );

package/src/index.ts

@@ -105,7 +105,7 @@ function handleVersionFlag(args: readonly string[]): boolean {
 
 program
   .name('pd')
-  .description('PD CLI — Pain recording, sample management, and evolution tasks')
+  .description('PD CLI — Pain recording, sample management, and evolution task history')
   .option('-V, --version', 'output the canonical PD product version')
   .enablePositionalOptions();
 
@@ -123,7 +123,10 @@ painCmd
   .option('-S, --source <text>', 'Source of the pain signal', 'manual')
   .option('-w, --workspace <path>', 'Workspace directory')
   .option('--session <id>', 'Session ID to bind (validated against this workspace\'s trajectory.db; without it the record is unbound: no trajectory evidence, candidates likely gated by the admission threshold)')
-  .option('--host <kind>', 'PRI-743: explicit host attribution (openclaw | codex). openclaw = default attribution without the disclosure warning; codex refuses — the CLI cannot verify Codex lineage.', undefined)
+  .option('--host <kind>', 'PRI-743: explicit host attribution (openclaw | codex). openclaw = default attribution without the disclosure warning; codex requires the real Codex lineage (--rollout-id, --host-turn-id, and --session as the root session).', undefined)
+  .option('--rollout-id <id>', 'PRI-743: Codex rollout identity — required by --host codex', undefined)
+  .option('--host-turn-id <id>', 'PRI-743: Codex turn id — required by --host codex', undefined)
+  .option('--logical-key <key>', 'PRI-743: Codex logical observation key override for --host codex (default: codex|<rollout-id>|<host-turn-id>|user)', undefined)
   .option('--wait', 'Wait for diagnosis to complete (sync mode, overrides async flag)')
   .option('--json', 'Output raw JSON')
   .action(async (opts) => {
@@ -179,9 +182,15 @@ samplesCmd
     await handleSamplesReview({ sampleId, decision: decision === 'approve' ? 'approved' : 'rejected', note });
   });
 
+// ── Evolution task reader (hidden) ────────────────────────────────────────────
+// PRI-752 review: the worker is gone (flag retired to `gone`), but this
+// read-only surface stays for historical `evolution_tasks` rows in already-
+// provisioned workspaces — data-retention disposition is a separate Owner
+// decision (PRI-737 reality audit §7.3). Table schema + quality-scorecard
+// reader are retained accordingly.
 const evolutionCmd = program
   .command('evolution', { hidden: true })
-  .description('Evolution task management');
+  .description('Evolution task management (historical data reader)');
 
 const tasksCmd = evolutionCmd
   .command('tasks')
@@ -375,7 +384,7 @@ runtimeCmd
 // when `pd runtime init` is actually invoked.
 runtimeCmd
   .command('init')
-  .description('Initialize all PD SQLite databases (state.db, trajectory.db, subagent_workflows.db)')
+  .description('Initialize all PD SQLite databases (state.db, trajectory.db)')
   .option('-w, --workspace <path>', 'Workspace directory')
   .option('--dry-run', 'Show what would be initialized without writing (default)')
   .option('--confirm', 'Actually initialize the databases (required to write)')

package/src/services/rulehost-pipeline-runner.ts

@@ -54,6 +54,7 @@ import {
   // PRI-714: resolve outputLanguage from the same effective config the
   // runners already receive (EP-07: canonical resolved value, not raw input).
   resolveOutputLanguage,
+  buildArtificerHostSemanticContext,
 } from '@principles/core/runtime-v2';
 import type {
   AdversarialLoopResult,
@@ -411,12 +412,21 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
       onProgress('adversarial_loop', 'failed', refusalReason);
       return rejectedResult(opts.painId, stages, `evaluator_runtime_context_unresolvable: ${evaluatorContext.reason} (nextAction: ${evaluatorContext.nextAction})`);
     }
+    // PRI-741: artificer generation + evaluator parity BOTH anchor on the ONE
+    // registry snapshot evaluatorContext resolved above (review round: a
+    // second independent resolveWorkspaceHostToolSemantics read could observe
+    // a different declaration snapshot than the replay gate). Unresolvable
+    // provenance already failed loud at the evaluatorContext refusal above.
+    const hostSemanticContext = buildArtificerHostSemanticContext(evaluatorContext.registry, evaluatorContext.hostKinds ?? []);
     const artificerRunner = new ArtificerRunner(
       {
         stateManager, runtimeAdapter: capability.artificerAdapter, eventEmitter, validator: new DefaultArtificerValidator(), artifactStore,
         contextMode: opts.contextMode ?? 'v1', behaviorExamplePack: opts.behaviorExamplePack, contentHashFn,
       },
-      runnerOptsFor(capability.artificerAdapter),
+      {
+        ...runnerOptsFor(capability.artificerAdapter),
+        hostSemanticContext,
+      },
     );
     // PRI-510 (DEFECT-004): construct EvaluatorRunnerDeps via the centralized
     // helper so the repair-loop wiring (isRepairLoopEnabled + seeder) is
@@ -435,7 +445,13 @@ export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promis
       // from durable provenance) — replaces the previous sandbox-only gate
       // deps so generation-time replay verdicts match the activation gate on
       // the same workspace. Options argument (2nd), never deps (1st).
-      { ...runnerOptsFor(agentAdapters.evaluator), gateDeps: evaluatorContext.gateDeps },
+      {
+        ...runnerOptsFor(agentAdapters.evaluator),
+        gateDeps: evaluatorContext.gateDeps,
+        // PRI-741: host-name parity replay case from the SAME registry
+        // snapshot as the gateDeps above (single resolution).
+        hostSemanticContext,
+      },
     );
 
     const loopResult = await runAdversarialLoop({

package/tests/commands/errors-list.test.ts

@@ -282,8 +282,9 @@ describe('handleErrorsList — handler behavior', () => {
     expect(parsed.workerErrors).toEqual([]);
     expect(parsed.total).toBe(0);
     expect(parsed.nextAction).toBe('No errors found. PD pipeline is healthy.');
-    // worker-status.json missing → workerStatusMissing=true
-    expect(parsed.workerStatusMissing).toBe(true);
+    // worker-status.json missing → expected steady state since PRI-737
+    // (the writer retired); no workerStatusMissing flag is emitted.
+    expect(parsed.workerStatusMissing).toBeUndefined();
     expect(parsed.workerStatusPath).toContain('worker-status.json');
     // cli-2-exit-stops: success path does NOT set exitCode to failure (1).
     // We assert "not 1" rather than "toBe(0)" because vitest may reset
@@ -657,14 +658,14 @@ describe('handleErrorsList — handler behavior', () => {
     expect(text).toContain('total:       2');
   });
 
-  it('text output: worker-status.json missing is reported in workerStatus line', async () => {
+  it('text output: worker-status.json missing is not reported (expected steady state since PRI-737)', async () => {
     setStateDbExists();
     mockListFailedTasks.mockResolvedValue([]);
 
     await handleErrorsList({ workspace: WS, json: false });
 
     const text = consoleLogSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-    expect(text).toContain('workerStatus: (missing');
+    expect(text).not.toContain('workerStatus:');
   });
 
   it('connection.close() called on success path (resource cleanup)', async () => {

package/tests/commands/pain-record-session-parser.test.ts

@@ -93,7 +93,31 @@ describe('pd pain record --session (real Commander + real trajectory.db)', () =>
     // Commander wraps help text; normalize whitespace before asserting content.
     const normalized = result.stdout.replace(/\s+/g, ' ');
     expect(normalized).toContain('openclaw | codex');
-    expect(normalized).toContain('codex refuses');
+    expect(normalized).toContain('codex requires the real Codex lineage');
+  }, 15_000);
+
+  it('PRI-743: --help registers the Codex lineage flags used by --host codex', async () => {
+    const result = await runBuiltCli(['pain', 'record', '--help']);
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('--rollout-id <id>');
+    expect(result.stdout).toContain('--host-turn-id <id>');
+    expect(result.stdout).toContain('--logical-key <key>');
+  }, 15_000);
+
+  it('PRI-743: --host codex without lineage exits non-zero with codex_lineage_required', async () => {
+    const result = await runBuiltCli([
+      'pain', 'record',
+      '--reason', 'parser test pain',
+      '--host', 'codex',
+      '--workspace', tmpDir,
+      '--json',
+    ]);
+
+    expect(result.status).not.toBe(0);
+    const parsed = JSON.parse(result.stdout.trim()) as Record<string, unknown>;
+    expect(parsed.status).toBe('failed');
+    expect(parsed.reason).toBe('codex_lineage_required');
+    expect(typeof parsed.nextAction).toBe('string');
   }, 15_000);
 
   it('PRI-743: an invalid --host value exits non-zero with a single structured JSON object', async () => {

package/tests/commands/pain-record.test.ts

@@ -414,24 +414,63 @@ describe('pd pain record', () => {
 
     const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { hostAttribution?: string; warnings?: string[] };
     expect(jsonOutput.hostAttribution).toBe('openclaw');
-    expect((jsonOutput.warnings ?? []).some((w) => w.includes("defaulted to 'openclaw'"))).toBe(false);
+    expect((jsonOutput.warnings ?? []).some((w) => w.includes('host kind not specified, defaulting to openclaw'))).toBe(false);
 
     logSpy.mockRestore();
     exitSpy.mockRestore();
   });
 
-  it('PRI-743: --host codex refuses loudly — the CLI cannot verify Codex lineage (rc-6)', async () => {
+  it('PRI-743: --host codex records host_kind=codex with the caller-supplied Codex lineage', async () => {
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = mockProcessExit();
 
-    await handlePainRecord({ reason: 'codex mistake', session: 'sess-codex', host: 'codex', json: true });
+    await handlePainRecord({
+      reason: 'codex mistake',
+      session: 'codex-root-sess',
+      host: 'codex',
+      rolloutId: 'rollout-abc',
+      hostTurnId: 'turn-7',
+      json: true,
+    });
+
+    expect(lastRecordPainInput).toBeTruthy();
+    expect(lastRecordPainInput!.hostKind).toBe('codex');
+    expect(lastRecordPainInput!.sessionId).toBe('codex-root-sess');
+    expect(lastRecordPainInput!.provenance).toBe('host_context_bound');
+    expect(lastRecordPainInput!.recordObservability).toBe(true);
+    // The CLI must NOT read the OpenClaw trajectory for a Codex attribution.
+    expect(acquireTrajectoryEvidenceFromDb).not.toHaveBeenCalled();
+    // Codex lineage is retained unflattened in the versioned payload (SPEC §8.1);
+    // the derived key mirrors the ingestion rule (codex|<rollout>|<turn>|user).
+    expect(lastRecordPainInput!.painIngress.correlation).toEqual({
+      status: 'bound',
+      hostKind: 'codex',
+      rootSessionId: 'codex-root-sess',
+      rolloutIdentity: 'rollout-abc',
+      logicalObservationKey: 'codex|rollout-abc|turn-7|user',
+      hostTurnId: 'turn-7',
+    });
+    // The degraded-but-honest path still submits (no fabricated evidence).
+    expect(lastRecordPainInput!.evidence).toEqual([]);
+    expect(exitSpy).not.toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  it('PRI-743: --host codex without the Codex lineage fails loudly before any mutation', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'codex mistake', host: 'codex', json: true });
 
     // cli-1: exactly one JSON object on stdout
     expect(logSpy).toHaveBeenCalledTimes(1);
-    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { status: string; reason: string; nextAction: string };
-    expect(jsonOutput).toMatchObject({ status: 'failed', reason: 'codex_lineage_unverifiable_by_cli' });
-    expect(jsonOutput.nextAction).toContain('Codex ingestion');
-    // cli-2/cli-5: refused before any evidence acquisition or service mutation
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { status: string; reason: string; nextAction: string; message: string };
+    expect(jsonOutput).toMatchObject({ status: 'failed', reason: 'codex_lineage_required' });
+    expect(jsonOutput.message).toContain('--rollout-id');
+    expect(jsonOutput.nextAction).toContain('--host-turn-id');
+    // cli-2/cli-5: stopped before any evidence acquisition or service mutation
     expect(lastRecordPainInput).toBeNull();
     expect(acquireTrajectoryEvidenceFromDb).not.toHaveBeenCalled();
     expect(exitSpy).toHaveBeenCalledWith(1);
@@ -440,7 +479,27 @@ describe('pd pain record', () => {
     exitSpy.mockRestore();
   });
 
-  it('PRI-743: omitting --host keeps the openclaw default but discloses the assumption (rc-9)', async () => {
+  it('PRI-743: --host codex with PARTIAL lineage still fails loudly (only the missing flag is reported)', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const exitSpy = mockProcessExit();
+
+    await handlePainRecord({ reason: 'codex mistake', session: 'codex-root', host: 'codex', rolloutId: 'rollout-abc', json: true });
+
+    const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { status: string; reason: string; message: string };
+    expect(jsonOutput).toMatchObject({ status: 'failed', reason: 'codex_lineage_required' });
+    expect(jsonOutput.message).toContain('--host-turn-id');
+    expect(jsonOutput.message).not.toContain('--rollout-id');
+    expect(lastRecordPainInput).toBeNull();
+    expect(exitSpy).toHaveBeenCalledWith(1);
+
+    logSpy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  // Task test #3/#4: legacy call compatibility — the pre-PRI-743 invocation
+  // (`--reason … --session …`, no --host) keeps host_kind=openclaw and only
+  // gains the disclosure wording.
+  it('PRI-743: legacy call omitting --host keeps the openclaw default but discloses it (rc-9)', async () => {
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     const exitSpy = mockProcessExit();
 
@@ -450,7 +509,7 @@ describe('pd pain record', () => {
     expect(lastRecordPainInput!.hostKind).toBe('openclaw');
     const jsonOutput = JSON.parse(logSpy.mock.calls[0][0]) as { hostAttribution?: string; warnings?: string[] };
     expect(jsonOutput.hostAttribution).toBe('openclaw');
-    expect((jsonOutput.warnings ?? []).some((w) => w.includes("defaulted to 'openclaw'") && w.includes('--host codex'))).toBe(true);
+    expect((jsonOutput.warnings ?? []).some((w) => w.includes('host kind not specified, defaulting to openclaw') && w.includes('--host codex'))).toBe(true);
 
     logSpy.mockRestore();
     exitSpy.mockRestore();

package/tests/commands/runtime-activation.test.ts

@@ -2035,7 +2035,7 @@ describe('handleRuntimeActivationDispatch — PRI-634-F R2 host provenance refus
   });
 
   it('code_tool_hook dispatch threads the resolved registry into RuleHostWriter and gateDeps', async () => {
-    const registry = { version: 1, hasHostLayer: true, resolve: () => 'write', lookup: () => null, hasHostTool: () => true };
+    const registry = { version: 1, hasHostLayer: true, resolve: () => 'write', lookup: () => null, hasHostTool: () => true, hostMappings: () => [{ rawToolName: 'write', canonicalKind: 'write' as const }] };
     vi.mocked(resolveWorkspaceToolSemantics).mockReturnValueOnce({ ok: true, registry, hostKind: 'openclaw' });
     await handleRuntimeActivationDispatch({
       workspace: WS,