@principles/pd-cli 1.149.0 → 1.149.2

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-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/commands/samples-list.ts

@@ -4,8 +4,9 @@
  * Usage: pd samples list [--status pending|approved|rejected]
  */
 
-import { listCorrectionSamples } from '@principles/core/trajectory-store';
+import { listCorrectionSamples, TrajectoryDbUnavailableError } from '@principles/core/trajectory-store';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
+import { exitWithTrajectoryDbUnavailable } from './trajectory-db-unavailable.js';
 
 interface SamplesListOptions {
   status?: 'pending' | 'approved' | 'rejected';
@@ -15,19 +16,14 @@ export async function handleSamplesList(opts: SamplesListOptions): Promise<void>
   const workspaceDir = resolveWorkspaceDir();
   const status = opts.status ?? 'pending';
 
-   
   let samples;
   try {
     samples = listCorrectionSamples(workspaceDir, status);
   } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes('ENOENT') || message.includes('SQLITE_CANTOPEN') || message.includes('SQLITE_NOTADB')) {
-      console.log('No correction samples found.');
-    } else {
-      console.error('Failed to list samples:', message);
-      throw err;
+    if (err instanceof TrajectoryDbUnavailableError) {
+      return exitWithTrajectoryDbUnavailable(err);
     }
-    return;
+    throw err;
   }
 
   if (samples.length === 0) {

package/src/commands/samples-review.ts

@@ -4,8 +4,9 @@
  * Usage: pd samples review <sample-id> approve|reject [note]
  */
 
-import { reviewCorrectionSample } from '@principles/core/trajectory-store';
+import { reviewCorrectionSample, TrajectoryDbUnavailableError } from '@principles/core/trajectory-store';
 import { resolveWorkspaceDir } from '../resolve-workspace.js';
+import { exitWithTrajectoryDbUnavailable } from './trajectory-db-unavailable.js';
 
 type ReviewDecision = 'approved' | 'rejected';
 
@@ -21,6 +22,9 @@ export async function handleSamplesReview(opts: SamplesReviewOptions): Promise<v
   try {
     reviewCorrectionSample(opts.sampleId, opts.decision, opts.note, workspaceDir);
   } catch (err) {
+    if (err instanceof TrajectoryDbUnavailableError) {
+      return exitWithTrajectoryDbUnavailable(err);
+    }
     if (err instanceof Error && err.message.includes('Sample not found')) {
       console.error(`Error: Sample not found: ${opts.sampleId}`);
       process.exit(1);

package/src/commands/trajectory-db-unavailable.ts

@@ -0,0 +1,19 @@
+/**
+ * Shared operator-facing failure for an unavailable trajectory database (PRI-753).
+ *
+ * The four trajectory-reading commands (`pd samples list/review`,
+ * `pd evolution tasks list/show`) surface the same structured failure:
+ * the error message carries path + reason, the second line is the next
+ * action (cli-6), and the process exits before any further mutation (cli-5).
+ */
+
+import type { TrajectoryDbUnavailableError } from '@principles/core/trajectory-store';
+
+const NEXT_ACTION =
+  "Trajectory data lives in the workspace database written by the PD plugin. Initialize this workspace with 'pd runtime init --confirm' or run PD here first.";
+
+export function exitWithTrajectoryDbUnavailable(err: TrajectoryDbUnavailableError): never {
+  console.error(`Error: ${err.message}`);
+  console.error(NEXT_ACTION);
+  process.exit(1);
+}

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')

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/evolution-tasks-list.test.ts

@@ -0,0 +1,41 @@
+/**
+ * pd evolution tasks list command tests — PRI-753 (Trajectory Reader Reality Fix).
+ *
+ * Before PRI-753 this handler wrapped every error as "No evolution tasks
+ * found." — including a missing database and real database failures. A
+ * missing trajectory database must now fail loud with reason and next action
+ * (cli-6), never masquerade as an empty task list (rc-9).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
+}));
+
+import { handleEvolutionTasksList } from '../../src/commands/evolution-tasks-list.js';
+
+describe('handleEvolutionTasksList — unavailable database (PRI-753)', () => {
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
+      throw new Error(`process.exit:${String(code)}`);
+    }) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('fails loud with reason and next action when trajectory.db is missing', async () => {
+    await expect(handleEvolutionTasksList({ status: 'all' })).rejects.toThrow('process.exit:1');
+
+    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
+    expect(stderrText).toContain('Trajectory database unavailable');
+    expect(stderrText).toContain('trajectory.db');
+    expect(stderrText).toContain('pd runtime init --confirm');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+});

package/tests/commands/evolution-tasks-show.test.ts

@@ -0,0 +1,46 @@
+/**
+ * pd evolution tasks show command tests — PRI-753 (Trajectory Reader Reality Fix).
+ *
+ * "Task not found" (database present, row absent) and "database unavailable"
+ * (file missing) are different failures and must stay distinguishable (cli-6).
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('../../src/resolve-workspace.js', () => ({
+  resolveWorkspaceDir: vi.fn().mockReturnValue('/tmp/pri753-missing-workspace'),
+}));
+
+import { handleEvolutionTasksShow } from '../../src/commands/evolution-tasks-show.js';
+
+describe('handleEvolutionTasksShow — unavailable database (PRI-753)', () => {
+  let errorSpy: ReturnType<typeof vi.spyOn>;
+  let exitSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code: number) => {
+      throw new Error(`process.exit:${String(code)}`);
+    }) as never);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('fails loud with reason and next action when trajectory.db is missing', async () => {
+    await expect(handleEvolutionTasksShow({ id: 'task-001' })).rejects.toThrow('process.exit:1');
+
+    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
+    expect(stderrText).toContain('Trajectory database unavailable');
+    expect(stderrText).toContain('trajectory.db');
+    expect(stderrText).toContain('pd runtime init --confirm');
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it('reports unavailable instead of "Task not found" when the database is missing', async () => {
+    await expect(handleEvolutionTasksShow({ id: 'task-001' })).rejects.toThrow('process.exit:1');
+
+    const stderrText = errorSpy.mock.calls.map((call) => String(call[0])).join('');
+    expect(stderrText).not.toContain('Task not found');
+  });
+});

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,