@principles/pd-cli 1.152.6 → 1.152.8

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

@@ -297,13 +297,42 @@ function resolveRunRuleHostRuntime(
   };
 }
 
-function formatTextOutput(result: RuleHostPipelineResult): string {
+/**
+ * Owner Decision Experience v1 review fix (Codex P1): derive the PUBLICATION
+ * outcome from the pipeline result. The generation can fully succeed while the
+ * governance publication (approval enqueue) is REFUSED by the Phase A identity
+ * boundary — that state must never be presented as "waiting for owner review".
+ * Exported pure so the CLI output contract is testable without spawning the
+ * command (cli-7).
+ */
+export function describePublicationOutcome(result: RuleHostPipelineResult): {
+  blocked: boolean;
+  nextAction: string;
+} {
+  const identityBlocked = result.decision === 'candidate_ready_for_owner_review'
+    && result.approvalId === null
+    && (result.degradationReason ?? '').includes('identity_binding_unverified');
+  if (identityBlocked) {
+    return {
+      blocked: true,
+      nextAction: 'Identity binding could not be verified, so the artifact was NOT enqueued for Owner review. Artifacts are preserved; repair the ledger identity for this candidate and re-run this pipeline to publish.',
+    };
+  }
+  return { blocked: false, nextAction: '' };
+}
+
+export function formatTextOutput(result: RuleHostPipelineResult): string {
   const lines: string[] = [];
   const isReady = result.decision === 'candidate_ready_for_owner_review';
-  const icon = isReady ? '✓' : result.decision === 'text_principle_only' ? '⚠' : '✗';
+  // Owner Decision Experience v1 review fix (Codex P1): an identity-gated
+  // refusal keeps the service decision but did NOT enqueue an approval —
+  // reporting it as plain success ("WAITING for owner review") lied to the
+  // operator. The publication outcome is derived explicitly and reported.
+  const publication = describePublicationOutcome(result);
+  const icon = publication.blocked ? '⚠' : isReady ? '✓' : result.decision === 'text_principle_only' ? '⚠' : '✗';
   lines.push('RuleHost Pipeline (PRI-429)');
   lines.push(`pain: ${result.painId}`);
-  lines.push(`OVERALL: ${icon} ${result.decision.toUpperCase()}`);
+  lines.push(`OVERALL: ${icon} ${result.decision.toUpperCase()}${publication.blocked ? ' (PUBLICATION REFUSED)' : ''}`);
   lines.push('');
 
   for (const stage of result.stages) {
@@ -314,15 +343,25 @@ function formatTextOutput(result: RuleHostPipelineResult): string {
   lines.push('');
   lines.push(`ruleArtifactId: ${result.ruleArtifactId ?? '(none)'}`);
   lines.push(`principleArtifactId: ${result.principleArtifactId ?? '(none)'}`);
+  if (result.approvalId) {
+    lines.push(`approvalId: ${result.approvalId}`);
+  }
   if (result.degradationReason) {
     lines.push(`degradationReason: ${result.degradationReason}`);
   }
-  if (result.decision === 'candidate_ready_for_owner_review') {
+  if (publication.blocked) {
+    lines.push('');
+    lines.push(`Next: ${publication.nextAction}`);
+  } else if (result.decision === 'candidate_ready_for_owner_review') {
     lines.push('');
     lines.push('Next: the rule artifact is validated and WAITING for owner review. This is NOT owner approval.');
   } else if (result.decision === 'text_principle_only') {
     lines.push('');
-    lines.push('Next: code-rule capability is OFF. Principle artifact remains for prompt-channel fallback.');
+    if (result.approvalId) {
+      lines.push(`Next: code-rule capability is OFF. Text principle enqueued for Owner review in the approval queue (${result.approvalId}). Approve it in the Console.`);
+    } else {
+      lines.push('Next: code-rule capability is OFF and the text principle could NOT be enqueued. Check degradationReason.');
+    }
   } else {
     lines.push('');
     lines.push('Next: generation rejected. Check degradationReason. Principle artifact may still exist for prompt-channel fallback.');
@@ -517,12 +556,14 @@ export async function handleRunRuleHost(opts: RunRuleHostOptions): Promise<void>
         return;
       }
       if (opts.confirm) {
-        // Lazy import: avoids loading `principles-disciple` at module init time.
-        // `pd --version` (and the create-principles-disciple smoke test) loads
-        // this file statically via index.ts. If we used a static import, the
-        // module would fail with MODULE_NOT_FOUND in bundled environments where
-        // `principles-disciple` is not resolvable from pd-cli's node_modules.
-        // The import only executes when `--confirm` is actually used.
+        // Lazy import: avoids loading `principles-disciple` at module init
+        // time. `pd --version` (and the create-principles-disciple smoke
+        // test) loads this file statically via index.ts; a static import
+        // would pull the plugin package into every pd startup even when
+        // `--confirm` is never used. Both install layouts resolve the
+        // package via a `pd-cli/node_modules/principles-disciple` link
+        // (release: installer.ts syncPdCli; local dev: sync-plugin.mjs,
+        // PRI-808).
         const { BehaviorExamplePackAssembler, RuleHostEvidenceRegistry } = await import('principles-disciple/rulehost-evidence');
         try {
           const assembler = new BehaviorExamplePackAssembler({ workspaceDir, stateDir: path.join(workspaceDir, '.state') });
@@ -631,16 +672,29 @@ export async function handleRunRuleHost(opts: RunRuleHostOptions): Promise<void>
   }
 
   // ── Output ──
+  // Owner Decision Experience v1 review fix (Codex P1): an identity-gated
+  // refusal is a degraded outcome — the JSON carries the structured
+  // reason/nextAction (cli-6) and the exit code is non-zero so automation
+  // does not treat an unpublishable artifact as a fully successful run.
+  const publication = describePublicationOutcome(result);
   if (opts.json) {
     // Exactly one parseable JSON object on stdout (CLI gate rule 1).
     // CLI gate rule 6: degraded/refused results include structured reason + nextAction.
     const output = result.decision === 'candidate_ready_for_owner_review'
-      ? { status: 'candidate_ready_for_owner_review', ...result }
+      ? {
+          status: 'candidate_ready_for_owner_review',
+          ...result,
+          ...(publication.blocked
+            ? { publicationRefused: true, nextAction: publication.nextAction }
+            : {}),
+        }
       : {
           status: result.decision,
           ...result,
           nextAction: result.decision === 'text_principle_only'
-            ? 'code-rule capability OFF; principle artifact available for prompt-channel fallback.'
+            ? (result.approvalId
+              ? `code-rule capability OFF; text principle enqueued for Owner review (${result.approvalId}). Approve it in the Console.`
+              : 'code-rule capability OFF and approval enqueue failed; check degradationReason for the manual enqueue command.')
             : 'Check degradationReason; principle artifact may still exist for prompt-channel fallback.',
         };
     process.stdout.write(JSON.stringify(output) + '\n');
@@ -648,8 +702,8 @@ export async function handleRunRuleHost(opts: RunRuleHostOptions): Promise<void>
     process.stdout.write(formatTextOutput(result) + '\n');
   }
 
-  // exit 1 when not candidate_ready_for_owner_review (CLI gate: operator knows it didn't fully succeed)
-  if (result.decision !== 'candidate_ready_for_owner_review') {
+  // exit 1 when the run did not fully succeed (not ready, or publication refused).
+  if (result.decision !== 'candidate_ready_for_owner_review' || publication.blocked) {
     process.exitCode = 1;
   }
 }

package/src/index.ts

@@ -46,7 +46,6 @@ import { handleRuntimePainFlood } from './commands/runtime-pain-flood-simulation
 import { handleRuntimeInternalizationIntegrity } from './commands/runtime-internalization-integrity.js';
 import { handleRuntimeInternalizationIntegrityRepair } from './commands/runtime-internalization-integrity-repair.js';
 import { handleRuntimeInternalizationEnqueueSuccessors } from './commands/runtime-internalization-enqueue-successors.js';
-import { handleRuntimeInternalizationContextTrace } from './commands/runtime-internalization-context-trace.js';
 import { handleRuntimeDiagnosticsExport } from './commands/runtime-diagnostics-export.js';
 import { registerRuntimeCompatibilityScanCommand } from './commands/runtime-compatibility-scan.js';
 import { handleRuntimeRecoverySweep } from './commands/runtime-recovery.js';
@@ -803,18 +802,6 @@ internalizationCmd
     await handleRuntimeInternalizationEnqueueSuccessors({ workspace: opts.workspace, dryRun: opts.dryRun, confirm: opts.confirm, json: opts.json });
   });
 
-// Layer 3 (design §6.7, PR 5): read-only context-trace command.
-internalizationCmd
-  .command('context-trace')
-  .description('Trace the internalization context chain: summaries, three-segment diagnosis, truncations, degradations')
-  .requiredOption('-t, --task <taskId>', 'Task ID to trace')
-  .option('-a, --artifact <artifactId>', 'Specific artifact ID to start from')
-  .option('-w, --workspace <path>', 'Workspace directory')
-  .option('--json', 'Output raw JSON (default)')
-  .action(async (opts) => {
-    await handleRuntimeInternalizationContextTrace({ workspace: opts.workspace, task: opts.task, artifact: opts.artifact, json: opts.json });
-  });
-
 const activationCmd = runtimeCmd
   .command('activation', { hidden: true })
   .description('Activation dispatch operations (hidden — use pd activation for list/deactivate)');

package/src/services/__tests__/rulehost-readiness.test.ts

@@ -89,7 +89,6 @@ function writeConfig(workspaceDir: string, opts: ConfigOptions = {}): void {
         evaluator: { enabled: agentEnabled.evaluator, runtimeProfile: profileId },
         rolloutReviewer: { enabled: false, runtimeProfile: profileId },
         correctionObserver: { enabled: false, runtimeProfile: profileId },
-        empathyObserver: { enabled: false, runtimeProfile: profileId },
       },
     },
     ui: { diagnostics: { mode: 'simple' } },
@@ -128,7 +127,6 @@ function writeDefaultInstalledConfig(workspaceDir: string): void {
         evaluator: { enabled: false, runtimeProfile: 'openclaw.default' },
         rolloutReviewer: { enabled: false, runtimeProfile: 'openclaw.default' },
         correctionObserver: { enabled: false, runtimeProfile: 'openclaw.default' },
-        empathyObserver: { enabled: false, runtimeProfile: 'openclaw.default' },
       },
     },
     ui: { diagnostics: { mode: 'simple' } },
@@ -278,7 +276,6 @@ describe('resolveRuleHostReadiness', () => {
           evaluator: { enabled: true, runtimeProfile: 'pi-ai.main' },
           rolloutReviewer: { enabled: false, runtimeProfile: 'pi-ai.main' },
           correctionObserver: { enabled: false, runtimeProfile: 'pi-ai.main' },
-          empathyObserver: { enabled: false, runtimeProfile: 'pi-ai.main' },
         },
       },
       ui: { diagnostics: { mode: 'simple' } },

package/src/services/pain-flood-simulation-runner.ts

@@ -18,7 +18,6 @@ import { PainSignalBridge } from '@principles/core/runtime-v2';
 import { CandidateIntakeService } from '@principles/core/runtime-v2';
 import { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { makeDeterministicDiagnosticianOutput } from '@principles/core/runtime-v2';
-import { contentHashFn } from './rulehost-pipeline-runner.js';
 import type {
   PainFloodSimulationSummary,
   PainFloodStage,
@@ -252,7 +251,6 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         artifactStore: stateManager.piArtifactStore,
         validator: new DefaultDiagRootCauseValidator(),
         contextAssembler,
-        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',
@@ -269,7 +267,6 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         eventEmitter,
         artifactStore: stateManager.piArtifactStore,
         validator: new DefaultDiagDistillerValidator(),
-        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',
@@ -286,7 +283,6 @@ export async function runPainFloodSimulation(opts: PainFloodSimulationRunnerOpti
         eventEmitter,
         artifactStore: stateManager.piArtifactStore,
         committer,
-        contentHashFn,
       },
       {
         owner: 'pain-flood-simulation',