@principles/pd-cli 1.152.11 → 1.152.13

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

@@ -1,1216 +0,0 @@
-/**
- * RuleHost Pipeline Runner — full-chain internalization driver (PRI-429).
- *
- * Drives a pain signal all the way to a validated rule artifact in ONE call:
- *   pain → dreamer → philosopher → scribe → artificer↔evaluator adversarial loop
- *
- * This is the "last mile" wiring that makes `runAdversarialLoop` reachable
- * from a real host entry point (the PRI-428 pr-review finding: the loop had no
- * production caller). Operators invoke it via
- *   `pd runtime internalization run-rulehost --pain-id <id>`
- *
- * Design:
- *   - Does NOT reuse the lease-based InternalizationOrchestrator. Instead it
- *     chains runners directly (mirrors full-chain-real-llm.test.ts), because
- *     the lease model is single-step + successor-proposal and cannot host a
- *     synchronous multi-round loop.
- *   - The artificer↔evaluator stage delegates to `runAdversarialLoop` (PRI-428),
- *     which never throws and degrades to { decision: 'rejected' } with a reason.
- *   - gateDeps (the sandbox adapter) is built from `compileDemoRule` +
- *     `evaluateInRefinerSandbox`. `compileDemoRule` delegates to the canonical
- *     hardened replay evaluator in @principles/core (PRI-809), so pre-activation
- *     replay crosses the same vm trust boundary as the production gate.
- *
- * @see docs/plans/rulehost-mvp-activation.md
- * @see runAdversarialLoop in @principles/core/runtime-v2
- */
-import {
-  RuntimeStateManager,
-  StoreEventEmitter,
-  DreamerRunner,
-  DefaultDreamerValidator,
-  PhilosopherRunner,
-  DefaultPhilosopherValidator,
-  ScribeRunner,
-  DefaultScribeValidator,
-  ArtificerRunner,
-  DefaultArtificerValidator,
-  EvaluatorRunner,
-  DefaultEvaluatorValidator,
-  createPITaskDiagnosticJson,
-  parsePITaskMetadata,
-  artificerRepairTaskId,
-  runAdversarialLoop,
-  evaluateInRefinerSandbox,
-  DEFAULT_MAX_ROUNDS,
-  SqliteApprovalQueueStore,
-  getChannelRiskLevel,
-  // PRI-510: feature-flag resolvers imported from the core barrel (EP-02:
-  // pd-config-loader.ts only re-exports loadPdConfig + computeFlagsFromLoadResult;
-  // computeFeatureFlagsFromConfig / isFeatureEnabled live in core).
-  computeFeatureFlagsFromConfig,
-  isFeatureEnabled,
-  // PRI-714: resolve outputLanguage from the same effective config the
-  // runners already receive (EP-07: canonical resolved value, not raw input).
-  resolveOutputLanguage,
-  buildArtificerHostSemanticContext,
-  // PRI-804(a): ledger identity lookup for the source_principle_id backfill.
-  PrincipleTreeLedgerAdapter,
-} from '@principles/core/runtime-v2';
-import type {
-  AdversarialLoopResult,
-  PDRuntimeAdapter,
-  PeerRunnerResult,
-  RefinerRuleHostGateDeps,
-  PIArtifactStore,
-  ApprovalRecord,
-  BehaviorExamplePack,
-  // PRI-510: type-only import for the repair-loop deps contract (EP-02 wiring).
-  // RuntimeStateManager / StoreEventEmitter are already imported as values
-  // above; EvaluatorValidator is type-only.
-  EvaluatorRunnerDeps,
-  SeedArtificerRepairParams,
-  EvaluatorValidator,
-} from '@principles/core/runtime-v2';
-import * as path from 'node:path';
-import { loadPdConfig } from './pd-config-loader.js';
-import { createEvaluatorRuntimeContext } from '@principles/host-runtime';
-/* eslint-disable @typescript-eslint/no-use-before-define -- helpers declared after main, matching codebase convention */
-import { compileDemoRule } from './demo-rule-compiler.js';
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-/**
- * Code-rule capability (atomic: ArtificerL2 + Evaluator).
- *
- * Per the user correction (2026-06-18): ArtificerL2 and Evaluator are atomic —
- * both must run or neither runs. When enabled, the adversarial loop runs with
- * the artificerAdapter (L2 write-test-fix). When disabled or not provided, the
- * pipeline degrades to text-principle-only.
- *
- * The caller (CLI handler) resolves per-agent config (enabled/runtimeProfile)
- * and constructs the ArtificerL2Adapter when both artificer + evaluator are
- * enabled. The pipeline runner branches on `enabled` — it does NOT do config
- * resolution itself (separation of concerns: service vs I/O).
- */
-export interface CodeRuleCapability {
-  /** Whether the capability is enabled (atomic: both artificer + evaluator enabled in config). */
-  readonly enabled: boolean;
-  /**
-   * The ArtificerL2Adapter (or test-double) for the artificer stage. Required
-   * when enabled. When enabled, this adapter replaces the base runtimeAdapter
-   * for the ArtificerRunner only; EvaluatorRunner still uses the base adapter.
-   * Ignored when disabled (may be omitted or set to the base adapter).
-   */
-  readonly artificerAdapter?: PDRuntimeAdapter;
-  /** Structured reason when disabled (for degradation reporting). Required when disabled. */
-  readonly disabledReason?: string;
-}
-
-export interface RuleHostAgentAdapters {
-  readonly dreamer: PDRuntimeAdapter;
-  readonly philosopher: PDRuntimeAdapter;
-  readonly scribe: PDRuntimeAdapter;
-  readonly evaluator: PDRuntimeAdapter;
-}
-
-export interface RuleHostPipelineOptions {
-  /** Workspace directory containing .state/ (SQLite stores). */
-  readonly workspaceDir: string;
-  /** Pain ID whose internalization chain to drive. */
-  readonly painId: string;
-  /**
-   * Runtime adapter (LLM). Caller constructs it (PiAi / test-double) so the
-   * service stays runtime-agnostic. Mirrors full-chain-real-llm.test.ts.
-   *
-   * Used for: dreamer, philosopher, scribe, and evaluator (when capability ON).
-   * The artificer stage uses codeRuleCapability.artificerAdapter when enabled.
-   */
-  readonly runtimeAdapter: PDRuntimeAdapter;
-  /** Production per-agent adapters. Tests may omit this to use runtimeAdapter for every stage. */
-  readonly agentAdapters?: RuleHostAgentAdapters;
-  /**
-   * Code-rule capability (atomic: ArtificerL2 + Evaluator). When omitted, the
-   * capability is treated as OFF with reason 'code_rule_capability not provided'.
-   */
-  readonly codeRuleCapability?: CodeRuleCapability;
-  /**
-   * PRI-780: required whenever code-rule generation runs — v2 is the only
-   * Artificer contract (no v1 fallback). Assembled from Owner-labelled
-   * production evidence; a missing pack refuses the adversarial loop loud.
-   */
-  readonly behaviorExamplePack?: BehaviorExamplePack;
-  /** Internalization channel for created tasks (default 'code_tool_hook'). */
-  readonly channel?: 'prompt' | 'code_tool_hook' | 'defer_archive';
-  /** Max adversarial rounds (PRD cap = 2). */
-  readonly maxRounds?: number;
-  /** Per-LLM-call timeout (default 300_000). */
-  readonly timeoutMs?: number;
-  /** Runner poll interval (default 100). */
-  readonly pollIntervalMs?: number;
-  /**
-   * Max stage retry attempts for transient `retried` status (default 2).
-   * Each retry gets fresh state from the state manager (Runtime Contract Rule 7).
-   * When exhausted, the stage is marked 'degraded' with a structured reason.
-   */
-  readonly maxStageRetries?: number;
-  /** Correlation prefix for task IDs. */
-  readonly correlationId?: string;
-  /** Progress callback (stage start/complete). Optional. */
-  readonly onProgress?: (stage: string, status: 'start' | 'succeeded' | 'failed' | 'degraded' | 'skipped', detail?: string) => void;
-  /**
-   * Called once after the internal RuntimeStateManager + artifactStore are
-   * constructed, so the caller (e.g. a test-double adapter) can wire the store
-   * for artifactId resolution. Optional.
-   */
-  readonly onStoreReady?: (store: PIArtifactStore) => void;
-}
-
-export type RuleHostPipelineStageStatus = 'succeeded' | 'failed' | 'skipped' | 'degraded';
-
-export interface RuleHostPipelineStage {
-  readonly name: 'pain_lookup' | 'dreamer' | 'philosopher' | 'scribe' | 'adversarial_loop';
-  readonly status: RuleHostPipelineStageStatus;
-  readonly taskId?: string;
-  readonly reason?: string;
-}
-
-/**
- * Final pipeline decision.
- *
- * - `candidate_ready_for_owner_review`: adversarial loop approved. A validated
- *   rule artifact exists and is WAITING for owner review. This is NOT owner
- *   approval — it means the candidate is ready for the owner to review.
- * - `text_principle_only`: code-rule capability OFF (artificer or evaluator
- *   disabled). No rule artifact; a text principle artifact is produced for the
- *   prompt channel and enqueued into the existing approval queue (PRI-804).
- * - `generation_rejected`: pipeline failed (no dreamer task, stage failure, or
- *   evaluator rejected the candidate). No rule artifact.
- */
-export interface RuleHostPipelineResult {
-  readonly decision: 'candidate_ready_for_owner_review' | 'text_principle_only' | 'generation_rejected';
-  readonly painId: string;
-  readonly stages: RuleHostPipelineStage[];
-  /** Scribe task that fed the adversarial loop (or text-principle path). */
-  readonly scribeTaskId: string | null;
-  /** From the adversarial loop result, when reached. */
-  readonly adversarialLoop?: AdversarialLoopResult;
-  /** Rule artifact ID when candidate_ready_for_owner_review; null otherwise. */
-  readonly ruleArtifactId: string | null;
-  /** Principle artifact ID (always present when scribe ran). */
-  readonly principleArtifactId: string | null;
-  /**
-   * Approval ID when the candidate was auto-enqueued into the ApprovalQueue.
-   * Present for decision='candidate_ready_for_owner_review' (rule artifact,
-   * code_tool_hook channel) AND for decision='text_principle_only' (principle
-   * artifact, prompt channel — PRI-804 wiring). Null when the enqueue itself
-   * failed — check degradationReason for the structured reason.
-   */
-  readonly approvalId: string | null;
-  /** Structured reason when decision is not candidate_ready_for_owner_review. */
-  readonly degradationReason?: string;
-}
-
-// ── gateDeps builder ─────────────────────────────────────────────────────────
-
-/**
- * Build the sandbox gate deps for adversarial replay.
- *
- * `compileDemoRule` delegates to the canonical hardened replay evaluator in
- * @principles/core (PRI-809) — capability-identical across packages without a
- * duplicate vm implementation. See demo-rule-compiler.ts header comment.
- */
-export function createSandboxGateDeps(): RefinerRuleHostGateDeps {
-  return {
-    evaluateInSandbox: (code, goldenTrace, opts) => {
-      // compileDemoRule throws on bad code. The throw propagates out of
-      // evaluateInSandbox; EvaluatorRunner (and runAdversarialLoop's
-      // evaluator_run_threw catch) classifies it as a sandbox failure, so it
-      // surfaces as a rejected round rather than an uncaught exception.
-      // evaluateInRefinerSandbox separately catches its own runtime throws
-      // (from executing the evaluate function) and classifies them as
-      // validation_failed / runtime_error.
-      const evaluateCode = compileDemoRule(code, 'rulehost-pipeline');
-      return evaluateInRefinerSandbox(code, goldenTrace, { evaluateCode, ...opts });
-    },
-  };
-}
-
-// ── Pipeline ─────────────────────────────────────────────────────────────────
-
-const DEFAULT_TIMEOUT_MS = 300_000;
-const DEFAULT_POLL_MS = 100;
-const DEFAULT_MAX_STAGE_RETRIES = 2;
-
-export async function runRuleHostPipeline(opts: RuleHostPipelineOptions): Promise<RuleHostPipelineResult> {
-  const channel = opts.channel ?? 'code_tool_hook';
-  const maxRounds = opts.maxRounds ?? DEFAULT_MAX_ROUNDS;
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_MS;
-  const maxStageRetries = opts.maxStageRetries ?? DEFAULT_MAX_STAGE_RETRIES;
-  const correlation = opts.correlationId ?? `rulehost-${opts.painId}`;
-  const onProgress = opts.onProgress ?? (() => { /* noop */ });
-
-  // ── Resolve code-rule capability (atomic: ArtificerL2 + Evaluator) ──
-  // Per user correction (2026-06-18): both must be enabled or neither runs.
-  // When OFF, degrade to text-principle-only after scribe. When ON, run the
-  // adversarial loop with the artificerAdapter (L2 write-test-fix).
-  const capability = opts.codeRuleCapability;
-  const capabilityEnabled = capability?.enabled === true;
-  const capabilityDisabledReason = capability?.enabled === false
-    ? (capability.disabledReason ?? 'code_rule_capability is disabled')
-    : 'code_rule_capability not provided — default OFF (set codeRuleCapability.enabled=true when both artificer + evaluator agents are enabled)';
-
-  const stages: RuleHostPipelineStage[] = [];
-  const stateManager = new RuntimeStateManager({ workspaceDir: opts.workspaceDir });
-  await stateManager.initialize();
-
-  try {
-    const artifactStore = stateManager.piArtifactStore;
-    const eventEmitter = new StoreEventEmitter();
-    // Issue 2: load effective config once so every stage runner can resolve
-    // feature flags (e.g. `artificer_output_retry`). Mirrors
-    // createEvaluatorRunnerDeps (rc-9: malformed config → fallback defaults).
-    const configLoad = loadPdConfig(opts.workspaceDir);
-    const effectiveConfig = configLoad.ok ? configLoad.effective : configLoad.defaults;
-    // PRI-714: resolve outputLanguage once from the effective config so every
-    // stage runner (dreamer/philosopher/scribe/artificer/evaluator) receives
-    // the same language value. Mirrors pain-signal-runtime-factory (EP-07).
-    // Default config also resolves (to zh-CN) — pipeline stages always
-    // declare the owner's language instead of leaving review artifacts English.
-    const {outputLanguage} = resolveOutputLanguage(effectiveConfig.config.principles?.outputLanguage);
-    // Allow the caller's adapter to resolve real artifactIds (needed by
-    // test-double adapters whose scripted outputs must match store-assigned IDs).
-    opts.onStoreReady?.(artifactStore);
-    const owner = 'rulehost-pipeline';
-    const agentAdapters = opts.agentAdapters ?? {
-      dreamer: opts.runtimeAdapter,
-      philosopher: opts.runtimeAdapter,
-      scribe: opts.runtimeAdapter,
-      evaluator: opts.runtimeAdapter,
-    };
-    const runnerOptsFor = (adapter: PDRuntimeAdapter) => ({ owner, runtimeKind: adapter.kind(), pollIntervalMs, timeoutMs, effectiveConfig, outputLanguage });
-
-    // ── Stage: pain lookup ──
-    // Find a dreamer task already seeded for this pain (the pain→dreamer bridge
-    // runs via `pd pain record` → PainSignalBridge.onPainDetected). We need the
-    // dreamer task to start the chain. If none exists, the operator must run
-    // `pd pain record` first — fail loud with guidance.
-    //
-    // D fix (PRI-429): exact sourcePainId match via Object.hasOwn on parsed
-    // diagnosticJson. No substring matching (pain-1 must NOT match pain-10).
-    onProgress('pain_lookup', 'start', `painId=${opts.painId}`);
-    const dreamerLookup = await findDreamerTaskForPain(stateManager, opts.painId, channel);
-    if (dreamerLookup.status === 'ambiguous') {
-      const reason = `ambiguous_dreamer_tasks_for_pain: ${dreamerLookup.taskIds.join(',')}`;
-      stages.push({ name: 'pain_lookup', status: 'failed', reason });
-      onProgress('pain_lookup', 'failed', reason);
-      return rejectedResult(opts.painId, stages, reason);
-    }
-    if (dreamerLookup.status === 'not_found') {
-      stages.push({ name: 'pain_lookup', status: 'failed', reason: 'no_dreamer_task_seeded_for_pain' });
-      onProgress('pain_lookup', 'failed', 'no dreamer task seeded');
-      return rejectedResult(opts.painId, stages, 'no_dreamer_task_seeded_for_pain: run `pd pain record` first');
-    }
-    const dreamerSeedTaskId = dreamerLookup.taskId;
-    stages.push({ name: 'pain_lookup', status: 'succeeded', taskId: dreamerSeedTaskId });
-    onProgress('pain_lookup', 'succeeded', `dreamerTaskId=${dreamerSeedTaskId}`);
-
-    // ── Stage: dreamer ──
-    onProgress('dreamer', 'start');
-    if (dreamerLookup.taskStatus === 'succeeded') {
-      stages.push({ name: 'dreamer', taskId: dreamerSeedTaskId, status: 'succeeded' });
-    } else {
-      const dreamerRunner = new DreamerRunner(
-        { stateManager, runtimeAdapter: agentAdapters.dreamer, eventEmitter, validator: new DefaultDreamerValidator(), artifactStore },
-        runnerOptsFor(agentAdapters.dreamer),
-      );
-      const dreamerResult = await runStage(dreamerRunner, dreamerSeedTaskId, { maxStageRetries, pollIntervalMs });
-      stages.push(stageFromResult('dreamer', dreamerSeedTaskId, dreamerResult));
-      if (dreamerResult.status !== 'succeeded') {
-        onProgress('dreamer', 'failed', dreamerResult.failureReason);
-        return rejectedResult(opts.painId, stages, `dreamer_failed: ${dreamerResult.failureReason ?? dreamerResult.status}`);
-      }
-    }
-    onProgress('dreamer', 'succeeded');
-
-    // ── Stage: philosopher ──
-    onProgress('philosopher', 'start');
-    const philosopherTaskId = `${correlation}-philosopher-${Date.now().toString(36)}`;
-    await createInternalizationTask(stateManager, philosopherTaskId, 'philosopher', [dreamerSeedTaskId], channel, timeoutMs);
-    const philosopherRunner = new PhilosopherRunner(
-      { stateManager, runtimeAdapter: agentAdapters.philosopher, eventEmitter, validator: new DefaultPhilosopherValidator(), artifactStore },
-      runnerOptsFor(agentAdapters.philosopher),
-    );
-    const philosopherResult = await runStage(philosopherRunner, philosopherTaskId, { maxStageRetries, pollIntervalMs });
-    stages.push(stageFromResult('philosopher', philosopherTaskId, philosopherResult));
-    if (philosopherResult.status !== 'succeeded') {
-      onProgress('philosopher', 'failed', philosopherResult.failureReason);
-      return rejectedResult(opts.painId, stages, `philosopher_failed: ${philosopherResult.failureReason ?? philosopherResult.status}`);
-    }
-    onProgress('philosopher', 'succeeded');
-
-    // ── Stage: scribe ──
-    onProgress('scribe', 'start');
-    const scribeTaskId = `${correlation}-scribe-${Date.now().toString(36)}`;
-    await createInternalizationTask(stateManager, scribeTaskId, 'scribe', [philosopherTaskId], channel, timeoutMs);
-    const scribeRunner = new ScribeRunner(
-      { stateManager, runtimeAdapter: agentAdapters.scribe, eventEmitter, validator: new DefaultScribeValidator(), artifactStore },
-      runnerOptsFor(agentAdapters.scribe),
-    );
-    const scribeResult = await runStage(scribeRunner, scribeTaskId, { maxStageRetries, pollIntervalMs });
-    stages.push(stageFromResult('scribe', scribeTaskId, scribeResult));
-    if (scribeResult.status !== 'succeeded') {
-      onProgress('scribe', 'failed', scribeResult.failureReason);
-      return rejectedResult(opts.painId, stages, `scribe_failed: ${scribeResult.failureReason ?? scribeResult.status}`);
-    }
-    onProgress('scribe', 'succeeded');
-
-    // EP002-R4 follow-up #2 + Owner Decision Experience v1 Phase A: backfill
-    // the LEDGER principle UUID on the scribe artifact for BOTH paths (rule +
-    // text). Downstream identity resolution (extractPrincipleId's column-first
-    // order) then binds the rule artifact, the approval grouping, and the
-    // post-approve ledger upgrade to the ledger UUID instead of falling back
-    // to principleDraft.title — the title namespace is what left rule-channel
-    // approvals stranded as title-keyed groups the Console detail page cannot
-    // reach.
-    //
-    // Phase A (SPEC §9.1): the binding outcome is STRUCTURED. An unverified
-    // binding no longer silently continues into Owner approval publication —
-    // the enqueue sites below refuse to create an approval subject for an
-    // artifact whose stable ledger identity is not established, while the
-    // generation chain and its artifacts are preserved for later replay.
-    const identityBinding = await backfillScribeIdentity({
-      stateManager, artifactStore, scribeTaskId, dreamerTaskId: dreamerSeedTaskId,
-      workspaceDir: opts.workspaceDir, now: new Date().toISOString(),
-    });
-    if (scribeIdentityNote(identityBinding) !== '') {
-      const scribeStage = stages.find((s) => s.name === 'scribe');
-      if (scribeStage) (scribeStage as { reason?: string }).reason = scribeIdentityNote(identityBinding).replace(/^; /, '');
-    }
-
-    // ── Atomic capability branching ──
-    // Per user correction (2026-06-18): ArtificerL2 + Evaluator are atomic.
-    // When OFF (or not provided), skip the adversarial loop entirely and
-    // degrade to text-principle-only. The scribe's principle artifact remains
-    // for prompt-channel fallback.
-    if (!capabilityEnabled) {
-      stages.push({ name: 'adversarial_loop', status: 'skipped', reason: capabilityDisabledReason });
-      onProgress('adversarial_loop', 'skipped', capabilityDisabledReason);
-      // PRI-804: text principles enter the existing prompt-channel approval
-      // queue (Owner governance, same gate as RuleCode) instead of dead-ending.
-      const approvalStore = new SqliteApprovalQueueStore(stateManager.connection);
-      return await textPrincipleOnlyResult({
-        painId: opts.painId, stages, scribeTaskId, disabledReason: capabilityDisabledReason,
-        artifactStore, approvalStore, now: new Date().toISOString(),
-        identityBinding,
-      });
-    }
-
-    // ── Stage: adversarial loop (artificer↔evaluator) ──
-    // Capability ON: use the artificerAdapter (L2 write-test-fix) for the
-    // artificer stage, and the base runtimeAdapter for the evaluator stage.
-    if (!capability?.artificerAdapter) {
-      // Contract violation: enabled but no adapter provided. Fail loud.
-      stages.push({ name: 'adversarial_loop', status: 'failed', reason: 'artificerAdapter not provided' });
-      onProgress('adversarial_loop', 'failed', 'artificerAdapter not provided');
-      return rejectedResult(opts.painId, stages, 'code_rule_capability enabled but artificerAdapter not provided');
-    }
-    // PRI-780: v2-only generation — an enabled code-rule capability without
-    // an Owner-labelled BehaviorExamplePack refuses BEFORE any artificer LLM
-    // stage runs. Never degrade to an action-only (v1) rule.
-    if (!opts.behaviorExamplePack) {
-      const reason = 'behavior_example_pack_missing: v2 is the only RuleCode generation contract (PRI-780); provide Owner-labelled behavior examples via --behavior-examples';
-      stages.push({ name: 'adversarial_loop', status: 'failed', reason });
-      onProgress('adversarial_loop', 'failed', reason);
-      return rejectedResult(opts.painId, stages, reason);
-    }
-    onProgress('adversarial_loop', 'start');
-    // PRI-661: the loop's evaluator replay must use the SAME production gate
-    // context as the consumer cycle and the activation gate (workspace root +
-    // durable host tool registry). The previous sandbox-only gateDeps could
-    // pass generation-time replay and fail the production activation gate on
-    // the same workspace — the drift class PRI-634-F closed elsewhere.
-    // Unresolvable provenance fails the loop LOUD (never a silent baseline
-    // fallback — ERR-114), mirroring the artificerAdapter-not-provided failure
-    // precedent below.
-    const evaluatorContext = createEvaluatorRuntimeContext({ workspaceDir: opts.workspaceDir });
-    if (!evaluatorContext.ok) {
-      const refusalReason = `${evaluatorContext.reason} — ${evaluatorContext.nextAction}`;
-      stages.push({ name: 'adversarial_loop', status: 'failed', reason: refusalReason });
-      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,
-        behaviorExamplePack: opts.behaviorExamplePack,
-      },
-      {
-        ...runnerOptsFor(capability.artificerAdapter),
-        hostSemanticContext,
-      },
-    );
-    // PRI-510 (DEFECT-004): construct EvaluatorRunnerDeps via the centralized
-    // helper so the repair-loop wiring (isRepairLoopEnabled + seeder) is
-    // actually invoked in the production CLI path. EP-02: prior code passed
-    // only the 5 base deps, leaving the repair loop as dead code at runtime.
-    const evaluatorRunner = new EvaluatorRunner(
-      createEvaluatorRunnerDeps({
-        stateManager,
-        runtimeAdapter: agentAdapters.evaluator,
-        eventEmitter,
-        validator: new DefaultEvaluatorValidator(),
-        artifactStore,
-        workspaceDir: opts.workspaceDir,
-      }),
-      // PRI-661: production gate context (workspace root + host tool registry
-      // 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,
-        // PRI-741: host-name parity replay case from the SAME registry
-        // snapshot as the gateDeps above (single resolution).
-        hostSemanticContext,
-      },
-    );
-
-    const loopResult = await runAdversarialLoop({
-      artificerRunner,
-      evaluatorRunner,
-      stateManager,
-      artifactStore,
-      scribeTaskId,
-      maxRounds,
-      correlationId: correlation,
-      channel,
-    });
-
-    const loopStatus: RuleHostPipelineStageStatus = loopResult.decision === 'approved' ? 'succeeded' : 'degraded';
-    stages.push({ name: 'adversarial_loop', status: loopStatus, taskId: loopResult.finalEvaluatorTaskId, reason: loopResult.degradationReason });
-    onProgress('adversarial_loop', loopResult.decision === 'approved' ? 'succeeded' : 'degraded', loopResult.degradationReason);
-
-    // Map adversarial loop decision to pipeline decision:
-    //   'approved' → candidate_ready_for_owner_review (NOT owner approval)
-    //   'rejected' → generation_rejected
-    const pipelineDecision = loopResult.decision === 'approved'
-      ? 'candidate_ready_for_owner_review' as const
-      : 'generation_rejected' as const;
-
-    // P1 #1 fix: auto-enqueue the candidate into the ApprovalQueue so the
-    // owner can review it. Without this, the pipeline produces a candidate
-    // artifact but it never enters the approval queue — the production chain
-    // is broken at step 2→3. Tests manually called enqueue(); production did not.
-    //
-    // Owner Decision Experience v1 Phase A (SPEC §9.1.4/§9.1.6): creating an
-    // Owner approval subject is a governance publication — it requires a
-    // verified stable ledger identity. When the chain's candidate could not be
-    // bound to exactly one existing ledger principle, the rule artifact must
-    // NOT enter the approvable set, even though the artifact itself (and every
-    // intermediate artifact) is preserved. Recovery is replay: after the
-    // ledger/identity repair, re-running the pipeline re-attempts the binding
-    // idempotently and then publishes.
-    let approvalId: string | null = null;
-    if (pipelineDecision === 'candidate_ready_for_owner_review' && loopResult.ruleArtifactId) {
-      const ruleIdentity = await resolveRuleArtifactIdentity(artifactStore, loopResult.ruleArtifactId, identityBinding);
-      if (ruleIdentity === null) {
-        const reasonCode = scribeIdentityReasonCode(identityBinding);
-        return {
-          decision: pipelineDecision,
-          painId: opts.painId,
-          stages,
-          scribeTaskId,
-          adversarialLoop: loopResult,
-          ruleArtifactId: loopResult.ruleArtifactId,
-          principleArtifactId: loopResult.principleArtifactId,
-          approvalId: null,
-          degradationReason: `identity_binding_unverified: ${reasonCode}. Rule artifact NOT enqueued for Owner approval (governance publication boundary). Artifacts preserved; repair the ledger identity and re-run this pipeline to publish.`,
-        };
-      }
-      try {
-        const approvalStore = new SqliteApprovalQueueStore(stateManager.connection);
-        const riskLevel = getChannelRiskLevel(channel);
-        const enqueuedRecord: ApprovalRecord = await approvalStore.enqueue({
-          artifactId: loopResult.ruleArtifactId,
-          channel,
-          riskLevel,
-          summary: `RuleHost pipeline candidate for pain ${opts.painId}`,
-          triggerReason: `adversarial_loop_approved: pain=${opts.painId}, rule=${loopResult.ruleArtifactId}`,
-        }, new Date().toISOString());
-        const { approvalId: enqueuedApprovalId } = enqueuedRecord;
-        approvalId = enqueuedApprovalId;
-        onProgress('adversarial_loop', 'succeeded', `auto-enqueued as approval ${approvalId}`);
-      } catch (err: unknown) {
-        // Enqueue failed — the candidate artifact exists but is not in the
-        // approval queue. Degrade gracefully with a structured reason (ERR-002).
-        const enqueueErr = err instanceof Error ? err.message : String(err);
-        const degradeReason = `candidate_approved_but_enqueue_failed: ${enqueueErr}. Manual enqueue required: pd activation dispatch --artifact-id ${loopResult.ruleArtifactId} --channel ${channel}`;
-        return {
-          decision: pipelineDecision,
-          painId: opts.painId,
-          stages,
-          scribeTaskId,
-          adversarialLoop: loopResult,
-          ruleArtifactId: loopResult.ruleArtifactId,
-          principleArtifactId: loopResult.principleArtifactId,
-          approvalId: null,
-          degradationReason: degradeReason,
-        };
-      }
-    }
-
-    return {
-      decision: pipelineDecision,
-      painId: opts.painId,
-      stages,
-      scribeTaskId,
-      adversarialLoop: loopResult,
-      ruleArtifactId: loopResult.ruleArtifactId,
-      principleArtifactId: loopResult.principleArtifactId,
-      approvalId,
-      degradationReason: loopResult.degradationReason,
-    };
-  } finally {
-    await stateManager.close();
-  }
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Find the dreamer task seeded for a given pain ID.
- *
- * D fix (PRI-429): exact sourcePainId match via Object.hasOwn on parsed
- * diagnosticJson. No substring matching — 'pain-1' must NOT match 'pain-10'.
- *
- * The sourcePainId is stored as a top-level key in diagnosticJson (outside the
- * pi_metadata envelope), mirroring the pattern in source-trace-locator.test.ts
- * and PainSignalBridge. Malformed JSON is skipped (not crashed). Missing
- * sourcePainId is skipped (no match).
- *
- * ERR refs:
- *   - ERR-001: parsed JSON treated as unknown
- *   - ERR-005/007: no `as` bypass; type narrowing via typeof + Object.hasOwn
- *   - ERR-013: Object.hasOwn for untrusted key checks
- *   - ERR-009: missing sourcePainId = no match (fail loud, not silent skip)
- */
-type DreamerTaskLookup =
-  | { readonly status: 'found'; readonly taskId: string; readonly taskStatus: 'pending' | 'retry_wait' | 'succeeded' }
-  | { readonly status: 'not_found' }
-  | { readonly status: 'ambiguous'; readonly taskIds: readonly string[] };
-
-async function findDreamerTaskForPain(
-  stateManager: RuntimeStateManager,
-  painId: string,
-  channel: 'prompt' | 'code_tool_hook' | 'defer_archive',
-): Promise<DreamerTaskLookup> {
-  const tasks = await stateManager.listTasks();
-  const dreamerTasks = tasks.filter((t) =>
-    t.taskKind === 'dreamer' && (t.status === 'pending' || t.status === 'retry_wait' || t.status === 'succeeded'),
-  );
-  const allMatches: typeof dreamerTasks = [];
-  const channelMatches: typeof dreamerTasks = [];
-  for (const t of dreamerTasks) {
-    if (typeof t.diagnosticJson !== 'string') continue;
-    const metadata = parsePITaskMetadata(t.diagnosticJson);
-    if (!metadata) continue;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(t.diagnosticJson);
-    } catch {
-      // Malformed JSON — skip this task, don't crash (Runtime Contract Rule 9:
-      // graceful degradation with observable behavior — the task is simply not
-      // a match, and the caller will report no_dreamer_task_seeded_for_pain).
-      continue;
-    }
-    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) continue;
-    if (!Object.hasOwn(parsed, 'sourcePainId')) continue;
-    const stored = Reflect.get(parsed, 'sourcePainId');
-    if (typeof stored === 'string' && stored === painId) {
-      allMatches.push(t);
-      if (metadata.channel === channel) channelMatches.push(t);
-    }
-  }
-  const matches = channelMatches.length > 0 ? channelMatches : allMatches;
-  matches.sort((left, right) => left.taskId.localeCompare(right.taskId));
-  if (matches.length === 0) return { status: 'not_found' };
-  if (matches.length > 1) return { status: 'ambiguous', taskIds: matches.map((task) => task.taskId) };
-  const [match] = matches;
-  if (!match || (match.status !== 'pending' && match.status !== 'retry_wait' && match.status !== 'succeeded')) {
-    return { status: 'not_found' };
-  }
-  return { status: 'found', taskId: match.taskId, taskStatus: match.status };
-}
-
-// eslint-disable-next-line @typescript-eslint/max-params
-async function createInternalizationTask(
-  stateManager: RuntimeStateManager,
-  taskId: string,
-  taskKind: string,
-  dependencyTaskIds: string[],
-  channel: 'prompt' | 'code_tool_hook' | 'defer_archive',
-  timeoutMs: number,
-): Promise<void> {
-  await stateManager.createTask({
-    taskId,
-    taskKind,
-    status: 'pending',
-    attemptCount: 0,
-    maxAttempts: 3,
-    diagnosticJson: createPITaskDiagnosticJson({
-      dependencyTaskIds,
-      channel,
-      timeoutMs,
-      inputArtifactRefs: [],
-      outputArtifactRefs: [],
-    }),
-  });
-}
-
-// ── PRI-510 (DEFECT-004): EvaluatorRunner repair-loop CLI wiring ────────────
-//
-// EP-02 (Production Path Wiring): PRI-509 added the `isRepairLoopEnabled` and
-// `seedArtificerRepairTask` deps to `EvaluatorRunnerDeps` (core), but the two
-// CLI production paths (runtime-internalization-run-once.ts and this file)
-// constructed `EvaluatorRunner` with only the base deps — the repair loop was
-// dead code at runtime (evaluator needs_revision seeded nothing).
-//
-// This helper centralizes the construction of the full deps so both CLI sites
-// stay in sync. The flag resolver reads `.pd/config.yaml` (the unified config
-// — ADR-0016); the seeder writes the repair task via `stateManager.createTask`
-// (the only sanctioned task-creation path; core peer runners are forbidden
-// from calling it directly — architecture-regression.test.ts enforces this).
-
-/**
- * Inputs for {@link createEvaluatorRunnerDeps}. Carries the base `PeerRunnerDeps`
- * fields plus `workspaceDir` (used to resolve the feature flag from
- * `.pd/config.yaml`).
- */
-export interface CreateEvaluatorRunnerDepsInputs {
-  readonly stateManager: RuntimeStateManager;
-  readonly runtimeAdapter: PDRuntimeAdapter;
-  readonly eventEmitter: StoreEventEmitter;
-  readonly validator: EvaluatorValidator;
-  readonly artifactStore: PIArtifactStore;
-  /** Workspace directory containing `.pd/config.yaml` (flag source). */
-  readonly workspaceDir: string;
-}
-
-/**
- * Build the full `EvaluatorRunnerDeps` for CLI production paths, including the
- * PRI-509 repair-loop wiring (EP-02: production path must invoke core logic).
- *
- * - `isRepairLoopEnabled`: reads `.pd/config.yaml` and resolves the
- *   `evaluator_artificer_repair_loop` flag. Defaults to false when the config
- *   is missing or malformed (rc-9: fail safe — legacy path runs, never throws).
- * - `seedArtificerRepairTask`: creates a new `artificer` task carrying the
- *   `repairPayload` in `diagnosticJson` (rc-1, rc-6: serialized via the
- *   validated `createPITaskDiagnosticJson`, no `as` bypass). Reuses the
- *   artificer runner (PRI-509 D1) rather than introducing a new task kind.
- *
- * Returns the newly created repair task's ID (UUIDv4, rc-7: fresh per call).
- */
-export function createEvaluatorRunnerDeps(inputs: CreateEvaluatorRunnerDepsInputs): EvaluatorRunnerDeps {
-  const { stateManager, runtimeAdapter, eventEmitter, validator, artifactStore, workspaceDir } = inputs;
-  return {
-    stateManager,
-    runtimeAdapter,
-    eventEmitter,
-    validator,
-    artifactStore,
-    isRepairLoopEnabled: (): boolean => {
-      // rc-9: never throw on malformed config — fail safe to false so the
-      // legacy (non-repair) path runs. The malformed config is already
-      // surfaced by `pd config doctor` and CLI start-up warnings.
-      try {
-        const result = loadPdConfig(workspaceDir);
-        const effective = result.ok ? result.effective : result.defaults;
-        const flags = computeFeatureFlagsFromConfig(effective);
-        return isFeatureEnabled(flags, 'evaluator_artificer_repair_loop');
-      } catch {
-        return false;
-      }
-    },
-    seedArtificerRepairTask: async (params: SeedArtificerRepairParams): Promise<string> => {
-      // rc-7: each call gets a fresh task ID — never reuse a cached ID.
-      // P0-4: deterministic revision identity + reuse on replay.
-      // PRI-718: id 约定收敛到 pitask-metadata 的单一 owner。
-      const repairTaskId = artificerRepairTaskId(
-        params.repairPayload.sourceEvaluatorTaskId,
-        params.repairPayload.repairIteration,
-      );
-      const existing = await stateManager.getTask(repairTaskId);
-      if (existing) {
-        // PRI-718 (revise ≠ resume): terminal repair rounds are finished
-        // corrective work — never vehicles for new corrective work. In-flight
-        // rounds are the legitimate replay-reuse population.
-        if (existing.status === 'succeeded' || existing.status === 'failed' || existing.status === 'needs_human_review') {
-          throw new Error(
-            `repair task ${repairTaskId} already reached terminal status ${existing.status}; refusing to reuse it as new corrective work (PRI-718 revise-ne-resume)`,
-          );
-        }
-        return repairTaskId;
-      }
-      await stateManager.createTask({
-        taskId: repairTaskId,
-        // D1 (PRI-509): task kind is 'artificer' — reuses the artificer
-        // runner, which detects repairPayload in diagnosticJson and
-        // forwards it to the prompt builder as repairFeedback.
-        taskKind: 'artificer',
-        status: 'pending',
-        attemptCount: 0,
-        maxAttempts: 3,
-        // rc-1, rc-6: serialize via the validated helper — repairPayload
-        // is untrusted LLM output but `createPITaskDiagnosticJson` writes
-        // it through `serializePITaskMetadata`, which `parsePITaskMetadata`
-        // re-validates on read (defense in depth).
-        diagnosticJson: createPITaskDiagnosticJson({
-          // PITaskMetadata fields are mutable arrays (the metadata envelope
-          // serializes them as JSON arrays). The SeedArtificerRepairParams
-          // contract carries readonly arrays (rc-1: untrusted input from the
-          // evaluator LLM). Spread to a fresh mutable array — no mutation of
-          // the caller's data.
-          dependencyTaskIds: [...params.inheritedDependencyTaskIds],
-          channel: params.inheritedChannel,
-          timeoutMs: params.inheritedTimeoutMs,
-          inputArtifactRefs: [...params.inheritedInputArtifactRefs],
-          outputArtifactRefs: [],
-          repairPayload: params.repairPayload,
-        }),
-      });
-      return repairTaskId;
-    },
-  };
-}
-
-/**
- * Run a single pipeline stage with bounded retry for transient `retried` status.
- *
- * Runtime Contract Rule 7: retry/repair loops must distinguish current, next,
- * and recorded state. Each iteration calls `runner.run(taskId)` fresh — the
- * runner reads from the state manager which has the updated task state
- * (including any `retry_wait` → `pending` transition from the previous
- * iteration). No stale state is carried across iterations.
- *
- * `retried` is NOT terminal — it means the runner hit a transient error and
- * marked the task for retry. The pipeline retries up to `maxStageRetries`
- * times (default 2). When exhausted, the stage is marked 'degraded' with a
- * structured reason, and the caller treats it as a non-success outcome.
- */
-interface RunStageOptions {
-  readonly maxStageRetries: number;
-  readonly pollIntervalMs: number;
-}
-
-async function runStage(
-  runner: { run(id: string): Promise<PeerRunnerResult<unknown>> },
-  taskId: string,
-  opts: RunStageOptions,
-): Promise<PeerRunnerResult<unknown>> {
-  let attempt = 0;
-  // First attempt is not a retry — it's the initial run.
-  let result = await runner.run(taskId);
-  while (result.status === 'retried' && attempt < opts.maxStageRetries) {
-    attempt++;
-    // Brief wait before retry to allow transient conditions to clear.
-    // The state manager has already marked the task as retry_wait; the runner
-    // will re-read it on the next .run() call (fresh state per iteration).
-    await new Promise<void>((resolve) => setTimeout(resolve, opts.pollIntervalMs));
-    result = await runner.run(taskId);
-  }
-  return result;
-}
-
-function stageFromResult(
-  name: RuleHostPipelineStage['name'],
-  taskId: string,
-  result: PeerRunnerResult<unknown>,
-): RuleHostPipelineStage {
-  // `retried` after exhausting retries is a transient-exhausted state, not a
-  // hard failure. Mark as 'degraded' so the caller can distinguish "stage
-  // failed permanently" from "stage exhausted transient retries".
-  if (result.status === 'succeeded') {
-    return { name, taskId, status: 'succeeded' };
-  }
-  if (result.status === 'retried') {
-    return {
-      name,
-      taskId,
-      status: 'degraded',
-      reason: `transient_retry_exhausted: ${result.failureReason ?? result.status}`,
-    };
-  }
-  return {
-    name,
-    taskId,
-    status: 'failed',
-    reason: result.failureReason ?? result.status,
-  };
-}
-
-function rejectedResult(painId: string, stages: RuleHostPipelineStage[], degradationReason: string): RuleHostPipelineResult {
-  return {
-    decision: 'generation_rejected',
-    painId,
-    stages,
-    scribeTaskId: null,
-    ruleArtifactId: null,
-    principleArtifactId: null,
-    approvalId: null,
-    degradationReason,
-  };
-}
-
-/**
- * Build a text-principle-only result when the code-rule capability is OFF.
- *
- * The scribe stage already produced a principle artifact (stored via the
- * artifact store). We look it up by the scribe task ID so the caller can
- * reference it for prompt-channel fallback.
- */
-interface TextPrincipleOnlyParams {
-  readonly painId: string;
-  readonly stages: RuleHostPipelineStage[];
-  readonly scribeTaskId: string;
-  readonly disabledReason: string;
-  readonly artifactStore: PIArtifactStore;
-  /** PRI-804: approval queue used to enqueue the text principle (prompt channel). */
-  readonly approvalStore: SqliteApprovalQueueStore;
-  readonly now: string;
-  /** Phase A: structured identity outcome from the shared post-scribe backfill. */
-  readonly identityBinding: ScribeIdentityBinding;
-}
-
-/**
- * Owner Decision Experience v1 Phase A (SPEC §9.1) — structured ledger
- * identity binding outcome for the internalization chain.
- *
- * `bound`/`already_bound` mean the scribe principle artifact carries a
- * source_principle_id that was READ BACK from the PI store after the write
- * and, when the chain candidate resolved, that it equals the unique existing
- * ledger principle. Every other status is a publication blocker: the reason
- * codes follow the SPEC's suggested vocabulary
- * (candidate_unresolved / ledger_missing / ledger_ambiguous /
- * identity_conflict / binding_write_failed).
- */
-export type ScribeIdentityBinding =
-  | { status: 'bound'; principleId: string }
-  | { status: 'already_bound'; principleId: string }
-  | { status: 'no_principle_artifact' }
-  | { status: 'candidate_unresolved' }
-  | { status: 'ledger_missing'; candidateId: string }
-  | { status: 'ledger_ambiguous'; candidateId: string; principleIds: string[] }
-  | { status: 'identity_conflict'; existingPrincipleId: string; resolvedPrincipleId: string }
-  | { status: 'bound_target_missing'; principleId: string }
-  | { status: 'binding_write_failed'; errorMessage: string }
-  | { status: 'binding_readback_failed'; expectedPrincipleId: string; errorMessage: string };
-
-/** Only these two statuses authorize governance publication (approval enqueue). */
-export function isIdentityBindingVerified(
-  binding: ScribeIdentityBinding,
-): binding is Extract<ScribeIdentityBinding, { status: 'bound' | 'already_bound' }> {
-  return binding.status === 'bound' || binding.status === 'already_bound';
-}
-
-/** Stable machine reason code for observability/logs (SPEC §9.1 vocabulary). */
-export function scribeIdentityReasonCode(binding: ScribeIdentityBinding): string {
-  switch (binding.status) {
-    case 'bound':
-    case 'already_bound':
-      return 'bound';
-    case 'no_principle_artifact':
-      return 'no_principle_artifact';
-    case 'candidate_unresolved':
-      return 'candidate_unresolved';
-    case 'ledger_missing':
-      return 'ledger_missing';
-    case 'ledger_ambiguous':
-      return 'ledger_ambiguous';
-    case 'identity_conflict':
-      return 'identity_conflict';
-    case 'bound_target_missing':
-      return 'identity_conflict';
-    case 'binding_write_failed':
-      return 'binding_write_failed';
-    case 'binding_readback_failed':
-      return 'binding_write_failed';
-  }
-}
-
-/** Human/telemetry note for the scribe stage; '' on a verified binding. */
-export function scribeIdentityNote(binding: ScribeIdentityBinding): string {
-  switch (binding.status) {
-    case 'bound':
-    case 'already_bound':
-      return '';
-    case 'no_principle_artifact':
-      return '; source_principle_id_backfill_skipped: no principle artifact from scribe';
-    case 'candidate_unresolved':
-      return '; source_principle_id_backfill_skipped: no candidateId on the dreamer seed (candidate_unresolved)';
-    case 'ledger_missing':
-      return `; source_principle_id_backfill_skipped: candidate ${binding.candidateId} matches no ledger principle (ledger_missing)`;
-    case 'ledger_ambiguous':
-      return `; source_principle_id_backfill_skipped: candidate ${binding.candidateId} matches ${binding.principleIds.length} ledger principles (ledger_ambiguous)`;
-    case 'identity_conflict':
-      return `; source_principle_id_backfill_refused: artifact already bound to ${binding.existingPrincipleId}, chain resolves to ${binding.resolvedPrincipleId} (identity_conflict)`;
-    case 'bound_target_missing':
-      return `; source_principle_id_backfill_refused: artifact bound to ${binding.principleId} which is absent from the ledger (identity_conflict)`;
-    case 'binding_write_failed':
-      return `; source_principle_id_backfill_failed: ${binding.errorMessage}`;
-    case 'binding_readback_failed':
-      return `; source_principle_id_backfill_unverified: read-back mismatch for ${binding.expectedPrincipleId}: ${binding.errorMessage}`;
-  }
-}
-
-/**
- * PRI-804(a) + Phase A: resolve the UNIQUE ledger principle for the chain.
- *
- * The ledger principle is the identity the Console groups approvals by and the
- * one `upgradeLedgerPrinciple` activates after approval. The only durable link
- * from the internalization chain to the ledger is the candidateId carried in
- * the dreamer task's diagnosticJson (set by the intake bridge) — the ledger
- * entry stores it in derivedFromPainIds. Phase A hardens the lookup:
- * `listForCandidate` (plural, same adapter the intake bridge uses — one
- * authority, no second truth) rejects zero and multi matches instead of
- * silently taking the first hit.
- */
-async function resolveLedgerIdentity(
-  stateManager: RuntimeStateManager,
-  dreamerTaskId: string,
-  workspaceDir: string,
-): Promise<ScribeIdentityBinding | { status: 'resolved'; principleId: string }> {
-  let candidateId: string | undefined;
-  try {
-    const dreamerTask = await stateManager.getTask(dreamerTaskId);
-    if (typeof dreamerTask?.diagnosticJson === 'string') {
-      const parsed: unknown = JSON.parse(dreamerTask.diagnosticJson);
-      if (parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
-        && Object.hasOwn(parsed, 'candidateId')) {
-        const stored = Reflect.get(parsed, 'candidateId');
-        if (typeof stored === 'string' && stored.length > 0) candidateId = stored;
-      }
-    }
-  } catch {
-    return { status: 'candidate_unresolved' }; // malformed dreamer diagnosticJson
-  }
-  if (!candidateId) return { status: 'candidate_unresolved' };
-  let matches: { id: string }[];
-  try {
-    const ledger = new PrincipleTreeLedgerAdapter({ stateDir: path.join(workspaceDir, '.state') });
-    matches = ledger.listForCandidate(candidateId);
-  } catch {
-    // Ledger unreadable cannot be distinguished from "no ledger" here — the
-    // write attempt below will surface the concrete error; treat as missing
-    // with the skip note (same observable class as before Phase A).
-    return { status: 'ledger_missing', candidateId };
-  }
-  if (matches.length === 0) return { status: 'ledger_missing', candidateId };
-  if (matches.length > 1) {
-    return { status: 'ledger_ambiguous', candidateId, principleIds: matches.map((m) => m.id) };
-  }
-  const [unique] = matches;
-  if (unique === undefined) return { status: 'ledger_missing', candidateId };
-  return { status: 'resolved', principleId: unique.id };
-}
-
-interface BackfillIdentityParams {
-  readonly stateManager: RuntimeStateManager;
-  readonly artifactStore: PIArtifactStore;
-  readonly scribeTaskId: string;
-  readonly dreamerTaskId: string;
-  readonly workspaceDir: string;
-  readonly now: string;
-}
-
-/**
- * EP002-R4 follow-up #2 + Phase A: backfill the scribe principle artifact's
- * source_principle_id with the LEDGER principle UUID (shared by the rule and
- * text paths — runs right after the scribe stage succeeds). Every downstream
- * identity resolution reads this column FIRST (extractPrincipleId /
- * EvaluatorRunner.extractPrincipleIdFromArtifact), so this single write is
- * what binds approvals, Console grouping, ledger upgrades, and rule
- * artifacts to the ledger UUID instead of the title namespace.
- *
- * Phase A contract changes vs the note-only version:
- *   - the outcome is structured (ScribeIdentityBinding), not a free string;
- *   - an existing binding that DISAGREES with the resolved ledger target is an
- *     identity_conflict — never overwritten;
- *   - a successful write is verified by reading the artifact back from the
- *     PI store (log success alone is not binding evidence — SPEC §9.1);
- *   - a pre-existing binding is only trusted when its target exists in the
- *     ledger read (listForCandidate is not applicable — we check presence by
- *     resolving through the same ledger load).
- *
- * Still never throws — identity enrichment must not break the generation
- * chain; it only gates the later governance publication.
- */
-export async function backfillScribeIdentity(params: BackfillIdentityParams): Promise<ScribeIdentityBinding> {
-  const { stateManager, artifactStore, scribeTaskId, dreamerTaskId, workspaceDir, now } = params;
-  try {
-    const arts = await artifactStore.listBySourceTaskId(scribeTaskId);
-    const principleArt = arts.find((a) => a.artifactKind === 'principle');
-    if (!principleArt) return { status: 'no_principle_artifact' };
-    const resolution = await resolveLedgerIdentity(stateManager, dreamerTaskId, workspaceDir);
-    if (principleArt.sourcePrincipleId) {
-      // Already bound (rerun). Idempotent success only when the binding is
-      // consistent with what the chain resolves to now.
-      if (resolution.status === 'resolved') {
-        if (resolution.principleId === principleArt.sourcePrincipleId) {
-          return { status: 'already_bound', principleId: principleArt.sourcePrincipleId };
-        }
-        return {
-          status: 'identity_conflict',
-          existingPrincipleId: principleArt.sourcePrincipleId,
-          resolvedPrincipleId: resolution.principleId,
-        };
-      }
-      if (resolution.status === 'ledger_ambiguous') return resolution;
-      // Chain candidate unresolved/missing on this replay — the durable
-      // binding still stands only if its target is a real ledger principle.
-      const ledger = new PrincipleTreeLedgerAdapter({ stateDir: path.join(workspaceDir, '.state') });
-      if (ledger.hasPrinciple(principleArt.sourcePrincipleId)) {
-        return { status: 'already_bound', principleId: principleArt.sourcePrincipleId };
-      }
-      return { status: 'bound_target_missing', principleId: principleArt.sourcePrincipleId };
-    }
-    if (resolution.status !== 'resolved') return resolution;
-    const ledgerPrincipleId = resolution.principleId;
-    await artifactStore.upsertArtifact({ ...principleArt, sourcePrincipleId: ledgerPrincipleId, updatedAt: now });
-    // Read-back verification: the PI store must return the bound ID.
-    try {
-      const readBack = await artifactStore.getArtifactById(principleArt.artifactId);
-      if (readBack?.sourcePrincipleId !== ledgerPrincipleId) {
-        return {
-          status: 'binding_readback_failed',
-          expectedPrincipleId: ledgerPrincipleId,
-          errorMessage: `read-back sourcePrincipleId=${readBack?.sourcePrincipleId ?? 'null'}`,
-        };
-      }
-    } catch (readErr: unknown) {
-      const msg = readErr instanceof Error ? readErr.message : String(readErr);
-      return { status: 'binding_readback_failed', expectedPrincipleId: ledgerPrincipleId, errorMessage: msg };
-    }
-    return { status: 'bound', principleId: ledgerPrincipleId };
-  } catch (err: unknown) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return { status: 'binding_write_failed', errorMessage: msg };
-  }
-}
-
-/**
- * Phase A (SPEC §9.1.6): before the rule artifact enters the approvable set,
- * verify the chain's ledger identity is VERIFIED and the rule artifact carries
- * exactly that binding. A chain without a verified unique ledger target must
- * not publish, even if the artifact itself carries some id (e.g. a legacy
- * title-namespace value the evaluator would have echoed). Returns the
- * verified principle id, or null when publication must be refused.
- */
-async function resolveRuleArtifactIdentity(
-  artifactStore: PIArtifactStore,
-  ruleArtifactId: string,
-  identityBinding: ScribeIdentityBinding,
-): Promise<string | null> {
-  if (!isIdentityBindingVerified(identityBinding)) return null;
-  let artifactSourcePrincipleId: string | undefined;
-  try {
-    const ruleArt = await artifactStore.getArtifactById(ruleArtifactId);
-    artifactSourcePrincipleId = ruleArt?.sourcePrincipleId;
-  } catch {
-    return null;
-  }
-  if (artifactSourcePrincipleId === undefined || artifactSourcePrincipleId !== identityBinding.principleId) return null;
-  return artifactSourcePrincipleId;
-}
-
-async function textPrincipleOnlyResult(
-  params: TextPrincipleOnlyParams,
-): Promise<RuleHostPipelineResult> {
-  const { painId, stages, scribeTaskId, disabledReason, artifactStore, approvalStore, now, identityBinding } = params;
-  // Look up the principle artifact produced by the scribe stage.
-  try {
-    const arts = await artifactStore.listBySourceTaskId(scribeTaskId);
-    const principleArt = arts.find((a) => a.artifactKind === 'principle');
-    // Identity backfill already ran on the shared post-scribe step
-    // (backfillScribeIdentity) for BOTH paths; nothing to do here.
-    // On the text path the evaluator never runs, so nothing else flips the
-    // validation status — mark it validated here (same store API the
-    // evaluator uses; scribe task success already implies its validator
-    // passed — peer-runner contract: output_invalid tasks never succeed).
-    let identityNote = '';
-    if (principleArt && principleArt.validationStatus !== 'validated') {
-      try {
-        await artifactStore.updateValidationStatus(principleArt.artifactId, 'validated');
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        identityNote = `; validation_status_mark_failed: ${msg}`;
-      }
-    }
-    // PRI-804: a text principle is a prompt-channel intervention and follows the
-    // same Owner governance as RuleCode (Owner decision 2026-09-15): enqueue it
-    // into the EXISTING approval queue so the Owner can approve it in Console.
-    // Deterministic approval id (apr_prompt_<artifactId>) + INSERT OR IGNORE make
-    // replays idempotent. Enqueue failure degrades observably (rc-9), never
-    // throwing away the artifact.
-    //
-    // Phase A governance publication boundary: an enqueue is only allowed when
-    // the artifact's ledger identity binding is VERIFIED. Unverified bindings
-    // keep the artifact (and its validation status) but must not create an
-    // Owner approval subject; recovery is a replay after identity repair.
-    let approvalId: string | null = null;
-    let enqueueNote = '';
-    if (!principleArt) {
-      enqueueNote = '; approval_enqueue_skipped: no principle artifact from scribe';
-    } else if (!isIdentityBindingVerified(identityBinding)) {
-      const reasonCode = scribeIdentityReasonCode(identityBinding);
-      enqueueNote = `; approval_enqueue_skipped: identity_binding_unverified (${reasonCode}). Principle artifact preserved; repair the ledger identity and re-run this pipeline to publish.`;
-    } else if (identityBinding.principleId !== principleArt.sourcePrincipleId) {
-      enqueueNote = `; approval_enqueue_skipped: identity_binding_unverified (identity_conflict: chain resolves to ${identityBinding.principleId}, artifact carries ${principleArt.sourcePrincipleId ?? 'no binding'}). Principle artifact preserved; repair the ledger identity and re-run this pipeline to publish.`;
-    } else {
-      try {
-        const record = await approvalStore.enqueue({
-          artifactId: principleArt.artifactId,
-          channel: 'prompt',
-          riskLevel: getChannelRiskLevel('prompt'),
-          summary: `Text principle candidate for pain ${painId}`,
-          triggerReason: `text_principle_only: pain=${painId}, principle=${principleArt.artifactId}; code-rule capability off (${disabledReason})`,
-        }, now);
-        const { approvalId: enqueuedApprovalId } = record;
-        approvalId = enqueuedApprovalId;
-      } catch (err: unknown) {
-        const msg = err instanceof Error ? err.message : String(err);
-        enqueueNote = `; approval_enqueue_failed: ${msg}. Manual enqueue required: pd activation dispatch --artifact-id ${principleArt.artifactId} --channel prompt`;
-      }
-    }
-    return {
-      decision: 'text_principle_only',
-      painId,
-      stages,
-      scribeTaskId,
-      ruleArtifactId: null,
-      principleArtifactId: principleArt?.artifactId ?? null,
-      approvalId,
-      degradationReason: `code_rule_capability_off: ${disabledReason}${identityNote}${enqueueNote}`,
-    };
-  } catch (error: unknown) {
-    const message = error instanceof Error ? error.message : String(error);
-    return {
-      decision: 'text_principle_only',
-      painId,
-      stages,
-      scribeTaskId,
-      ruleArtifactId: null,
-      principleArtifactId: null,
-      approvalId: null,
-      degradationReason: `code_rule_capability_off: ${disabledReason}; principle_artifact_lookup_failed: ${message}`,
-    };
-  }
-
-}