@principles/pd-cli 1.152.12 → 1.152.13

package/src/services/synthetic-baseline-runner.ts

@@ -1,400 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { RuntimeStateManager } from '@principles/core/runtime-v2';
-import { SqliteContextAssembler } from '@principles/core/runtime-v2';
-import { SqliteHistoryQuery } from '@principles/core/runtime-v2';
-import { StoreEventEmitter } from '@principles/core/runtime-v2';
-import {
-  SplitDiagnosticianRunner,
-  DiagRootCauseRunner,
-  DiagDistillerRunner,
-  DiagRouterRunner,
-  DefaultDiagRootCauseValidator,
-  DefaultDiagDistillerValidator,
-} from '@principles/core/runtime-v2';
-import { SqliteDiagnosticianCommitter } from '@principles/core/runtime-v2';
-import { TestDoubleRuntimeAdapter } from '@principles/core/runtime-v2';
-import { PainSignalBridge } from '@principles/core/runtime-v2';
-import { CandidateIntakeService } from '@principles/core/runtime-v2';
-import { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
-import { auditCandidateLedgerConsistency } from '@principles/core/runtime-v2';
-import { OperatorHealthReadModel } from '@principles/core/runtime-v2';
-import { createInternalizationQueueReadModel } from '@principles/core/runtime-v2';
-import { createPITaskDiagnosticJson } from '@principles/core/runtime-v2';
-import {
-  computeOverallStatus,
-  boundedEvidence,
-  truncateReason,
-  recommendNextIssue,
-  makeDeterministicDiagnosticianOutput,
-} from '@principles/core/runtime-v2';
-import type {
-  SyntheticBaselineSummary,
-  SyntheticBaselineStage,
-  SyntheticBaselineStageName,
-  SyntheticBaselineFailStage,
-} from '@principles/core/runtime-v2';
-
-export interface SyntheticBaselineRunnerOptions {
-  workspaceDir: string;
-  workspaceMode: 'temp' | 'explicit_workspace';
-  failAfterStage?: SyntheticBaselineFailStage;
-}
-
-export async function runSyntheticBaseline(opts: SyntheticBaselineRunnerOptions): Promise<SyntheticBaselineSummary> {
-  const { workspaceDir, workspaceMode, failAfterStage } = opts;
-  const stages: SyntheticBaselineStage[] = [];
-  const generatedAt = new Date().toISOString();
-
-  const painId = `synth-pain-${Date.now()}`;
-  const diagnosticianOutput = makeDeterministicDiagnosticianOutput(painId);
-
-  let stateManager: RuntimeStateManager | null = null;
-
-  try {
-    const pdDir = path.join(workspaceDir, '.pd');
-    const stateDir = path.join(workspaceDir, '.state');
-    await fs.promises.mkdir(pdDir, { recursive: true });
-    await fs.promises.mkdir(stateDir, { recursive: true });
-
-    stateManager = new RuntimeStateManager({ workspaceDir });
-    await stateManager.initialize();
-
-    if (failAfterStage === 'before_pain_intake') {
-      stages.push({
-        name: 'pain_intake',
-        status: 'failed',
-        reason: truncateReason('Injected failure: pain intake stage forced to fail for testing'),
-      });
-      for (const name of ['diagnostician_task_created', 'candidate_created', 'ledger_consistent', 'internalization_queue_ready', 'canary_health'] as SyntheticBaselineStageName[]) {
-        stages.push({ name, status: 'failed', reason: 'Prerequisite stage pain_intake failed' });
-      }
-      const status = computeOverallStatus(stages);
-      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
-    }
-
-    const { connection: sqliteConn, taskStore, runStore } = stateManager;
-    const historyQuery = new SqliteHistoryQuery(sqliteConn);
-    const contextAssembler = new SqliteContextAssembler(taskStore, historyQuery, runStore);
-    const eventEmitter = new StoreEventEmitter();
-    const committer = new SqliteDiagnosticianCommitter(sqliteConn);
-    const runIdToTaskId = new Map<string, string>();
-    let runCounter = 0;
-
-    // Single test-double adapter handles all pains with stage-aware output
-    const runtimeAdapter = new TestDoubleRuntimeAdapter({
-      onStartRun: (input) => {
-        runCounter += 1;
-        const runId = `td-${runCounter}`;
-        const taskId = input.taskRef?.taskId ?? '';
-        runIdToTaskId.set(runId, taskId);
-        return {
-          runId,
-          runtimeKind: 'test-double',
-          startedAt: new Date().toISOString(),
-        };
-      },
-      onFetchOutput: async (runId: string) => {
-        const taskId = runIdToTaskId.get(runId) ?? '';
-        if (taskId.includes('diag_rootcause')) {
-          return {
-            runId,
-            payload: {
-              valid: true,
-              diagnosisId: `diag-${runId}`,
-              taskId,
-              summary: 'Mock rootcause summary for synthetic-baseline',
-              causalChain: [{ why: 1, statement: 'why', evidenceRefs: ['ref-1'] }],
-              rootCause: 'Design: Mock rootcause',
-              rootCauseCategory: 'Design',
-              evidence: [{ sourceRef: 'ref-1', note: 'note' }],
-              confidence: 0.9,
-            },
-          };
-        } else if (taskId.includes('diag_distiller')) {
-          const parentTaskId = taskId.replace('diag_distiller-', '');
-          const stageATaskId = `diag_rootcause-${parentTaskId}`;
-          const artifacts = stateManager
-            ? await stateManager.piArtifactStore.listBySourceTaskId(stageATaskId)
-            : [];
-          const sourceRootCauseArtifactId = artifacts[0]?.artifactId ?? 'art-rc';
-          return {
-            runId,
-            payload: {
-              valid: true,
-              taskId,
-              sourceRootCauseArtifactId,
-              abstractedPrinciple: 'Mock abstracted principle',
-              rationale: 'Mock rationale',
-              groundedOnCorePrincipleIds: ['T-01'],
-              scope: 'domain',
-              confidence: 0.9,
-            },
-          };
-        } else {
-          return {
-            runId,
-            payload: diagnosticianOutput,
-          };
-        }
-      },
-    });
-
-    const rootCauseRunner = new DiagRootCauseRunner(
-      {
-        stateManager,
-        runtimeAdapter,
-        eventEmitter,
-        artifactStore: stateManager.piArtifactStore,
-        validator: new DefaultDiagRootCauseValidator(),
-        contextAssembler,
-      },
-      {
-        owner: 'synthetic-baseline',
-        runtimeKind: 'test-double',
-        pollIntervalMs: 50,
-        timeoutMs: 10000,
-      },
-    );
-
-    const distillerRunner = new DiagDistillerRunner(
-      {
-        stateManager,
-        runtimeAdapter,
-        eventEmitter,
-        artifactStore: stateManager.piArtifactStore,
-        validator: new DefaultDiagDistillerValidator(),
-      },
-      {
-        owner: 'synthetic-baseline',
-        runtimeKind: 'test-double',
-        pollIntervalMs: 50,
-        timeoutMs: 10000,
-      },
-    );
-
-    const routerRunner = new DiagRouterRunner(
-      {
-        stateManager,
-        runtimeAdapter,
-        eventEmitter,
-        artifactStore: stateManager.piArtifactStore,
-        committer,
-      },
-      {
-        owner: 'synthetic-baseline',
-        runtimeKind: 'test-double',
-        pollIntervalMs: 50,
-        timeoutMs: 10000,
-      },
-    );
-
-    const runner = new SplitDiagnosticianRunner({
-      rootCauseRunner,
-      distillerRunner,
-      routerRunner,
-      stateManager,
-      committer,
-      perStageTimeoutMs: 10000,
-    });
-
-    const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir });
-    const intakeService = new CandidateIntakeService({ stateManager, ledgerAdapter });
-
-    const bridge = new PainSignalBridge({
-      stateManager,
-      runner,
-      intakeService,
-      ledgerAdapter,
-      autoIntakeEnabled: true,
-    });
-
-    const bridgeResult = await bridge.onPainDetected({
-      painId,
-      painType: 'tool_failure',
-      source: 'synthetic-baseline',
-      reason: 'Synthetic baseline deterministic pain signal',
-      // Synthetic baseline is a deterministic smoke tool — it has no real host
-      // session to harvest evidence from. Provide a synthetic evidence entry so
-      // Gate B admission (TriggerController) does not short-circuit the pain
-      // before diagnosis. Without this, the baseline reports
-      // `short_circuited: input evidence empty` and every downstream stage
-      // fails, even though the pipeline itself is healthy.
-      evidence: [{ sourceRef: `synthetic:${painId}`, note: 'Synthetic baseline deterministic evidence anchor' }],
-    });
-
-    const painPassed = bridgeResult.status === 'succeeded';
-    stages.push({
-      name: 'pain_intake',
-      status: painPassed ? 'passed' : 'failed',
-      ...(painPassed ? {} : { reason: truncateReason(bridgeResult.message ?? `PainSignalBridge returned status=${bridgeResult.status}`) }),
-      evidence: boundedEvidence({
-        painId: bridgeResult.painId,
-        bridgeStatus: bridgeResult.status,
-      }),
-    });
-
-    if (failAfterStage === 'after_pain_intake') {
-      stages.push({ name: 'diagnostician_task_created', status: 'failed', reason: 'Injected failure: forced fail after pain_intake' });
-      stages.push({ name: 'candidate_created', status: 'failed', reason: 'Prerequisite stage diagnostician_task_created failed' });
-      stages.push({ name: 'ledger_consistent', status: 'failed', reason: 'Prerequisite stage candidate_created failed' });
-      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Prerequisite stage ledger_consistent failed' });
-      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
-      const status = computeOverallStatus(stages);
-      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
-    }
-
-    const { taskId } = bridgeResult;
-    const task = await stateManager.getTask(taskId);
-    const taskPassed = task !== null && task.status === 'succeeded';
-    stages.push({
-      name: 'diagnostician_task_created',
-      status: taskPassed ? 'passed' : 'failed',
-      ...(taskPassed ? {} : { reason: truncateReason(`Task ${taskId} not found or not succeeded. task=${task ? task.status : 'null'}`) }),
-      evidence: boundedEvidence({
-        taskId,
-        taskStatus: task?.status ?? 'not_found',
-      }),
-    });
-
-    const candidates = await stateManager.getCandidatesByTaskId(taskId);
-    const candidatePassed = candidates.length > 0;
-    stages.push({
-      name: 'candidate_created',
-      status: candidatePassed ? 'passed' : 'failed',
-      ...(candidatePassed ? {} : { reason: truncateReason(`No candidates found for task ${taskId}`) }),
-      evidence: boundedEvidence({
-        candidateCount: candidates.length,
-        candidateIds: candidates.map(c => c.candidateId).slice(0, 5),
-      }),
-    });
-
-    if (failAfterStage === 'after_candidate_created') {
-      stages.push({ name: 'ledger_consistent', status: 'failed', reason: 'Injected failure: forced fail after candidate_created' });
-      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Prerequisite stage ledger_consistent failed' });
-      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
-      const status = computeOverallStatus(stages);
-      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
-    }
-
-    const auditResult = await auditCandidateLedgerConsistency(workspaceDir);
-    const ledgerPassed = auditResult.status === 'ok';
-    stages.push({
-      name: 'ledger_consistent',
-      status: ledgerPassed ? 'passed' : 'failed',
-      ...(ledgerPassed ? {} : { reason: truncateReason(`Ledger audit status=${auditResult.status}. orphanCandidates=${auditResult.orphanCandidateCount} missingLedger=${auditResult.missingLedgerCount}`) }),
-      evidence: boundedEvidence({
-        auditStatus: auditResult.status,
-        consumedCount: auditResult.consumedCount,
-        orphanCandidateCount: auditResult.orphanCandidateCount,
-        missingLedgerCount: auditResult.missingLedgerCount,
-      }),
-    });
-
-    if (failAfterStage === 'after_ledger_consistent') {
-      stages.push({ name: 'internalization_queue_ready', status: 'failed', reason: 'Injected failure: forced fail after ledger_consistent' });
-      stages.push({ name: 'canary_health', status: 'failed', reason: 'Prerequisite stage internalization_queue_ready failed' });
-      const status = computeOverallStatus(stages);
-      return { status, workspaceMode, generatedAt, stages, recommendedNextIssue: recommendNextIssue(stages) };
-    }
-
-    const piTaskId = `synth-dreamer-${Date.now()}`;
-    await stateManager.createTask({
-      taskId: piTaskId,
-      taskKind: 'dreamer',
-      status: 'pending',
-      attemptCount: 0,
-      maxAttempts: 3,
-      diagnosticJson: createPITaskDiagnosticJson({
-        dependencyTaskIds: [],
-        channel: 'prompt',
-        timeoutMs: 300_000,
-        inputArtifactRefs: [],
-        outputArtifactRefs: [],
-      }),
-    });
-
-    const { readModel: queueReadModel, close: queueClose } = await createInternalizationQueueReadModel({
-      workspaceDir,
-      readonly: true,
-    });
-    try {
-      const queueSnapshot = await queueReadModel.getSnapshot();
-      const queueReady = queueSnapshot.readyTasks.length > 0;
-      stages.push({
-        name: 'internalization_queue_ready',
-        status: queueReady ? 'passed' : 'failed',
-        ...(queueReady ? {} : { reason: truncateReason(`Queue has no ready tasks. pendingCount=${queueSnapshot.pendingCount} noReadyTasks=${queueSnapshot.noReadyTasks?.reason ?? 'n/a'}`) }),
-        evidence: boundedEvidence({
-          readyCount: queueSnapshot.readyTasks.length,
-          pendingCount: queueSnapshot.pendingCount,
-          noReadyReason: queueSnapshot.noReadyTasks?.reason ?? null,
-        }),
-      });
-    } catch (err) {
-      stages.push({
-        name: 'internalization_queue_ready',
-        status: 'failed',
-        reason: truncateReason(`Queue read model failed: ${err instanceof Error ? err.message : String(err)}`),
-      });
-    } finally {
-      await queueClose();
-    }
-
-    const healthModel = new OperatorHealthReadModel({ workspaceDir });
-    try {
-      const healthSnapshot = await healthModel.getSnapshot();
-      const healthPassed = healthSnapshot.overallStatus === 'healthy' || healthSnapshot.overallStatus === 'degraded';
-      stages.push({
-        name: 'canary_health',
-        status: healthPassed ? 'passed' : 'failed',
-        ...(healthPassed ? {} : { reason: truncateReason(`Operator health: ${healthSnapshot.overallStatus}. Actions: ${healthSnapshot.recommendedActions.join('; ')}`) }),
-        evidence: boundedEvidence({
-          overallStatus: healthSnapshot.overallStatus,
-          recommendedActions: healthSnapshot.recommendedActions.slice(0, 3),
-        }),
-      });
-    } catch (err) {
-      stages.push({
-        name: 'canary_health',
-        status: 'failed',
-        reason: truncateReason(`Health read model failed: ${err instanceof Error ? err.message : String(err)}`),
-      });
-    } finally {
-      await healthModel.close();
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    const stageNames: SyntheticBaselineStageName[] = [
-      'pain_intake',
-      'diagnostician_task_created',
-      'candidate_created',
-      'ledger_consistent',
-      'internalization_queue_ready',
-      'canary_health',
-    ];
-    const existingNames = new Set(stages.map(s => s.name));
-    for (const name of stageNames) {
-      if (!existingNames.has(name)) {
-        stages.push({
-          name,
-          status: 'failed',
-          reason: truncateReason(`Unexpected error: ${errorMessage}`),
-        });
-      }
-    }
-  } finally {
-    if (stateManager) {
-      await stateManager.close();
-    }
-  }
-
-  const status = computeOverallStatus(stages);
-  return {
-    status,
-    workspaceMode,
-    generatedAt,
-    stages,
-    recommendedNextIssue: recommendNextIssue(stages),
-  };
-}

package/src/services/version-report.ts

@@ -1,253 +0,0 @@
-/**
- * Canonical version report builder (SPEC §12).
- *
- * `pd --version` prints one stable short text line; `pd version --json`
- * exposes the full canonical report: productVersion, releaseId, components,
- * bootstrapVersion, channel, source, generation, health, and the last
- * transaction. The canonical product identity comes from the installation
- * state under ~/.pd — never from a checkout's package.json.
- *
- * The record shapes here mirror the canonical contracts owned by
- * create-principles-disciple/src/update/ (the deep ReleaseManager module);
- * this reader is deliberately thin: it READS installation state and never
- * performs update logic.
- */
-
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-export type VersionReportSource = 'official-installer' | 'official-legacy-overlay' | 'unknown';
-
-/**
- * Where the component versions in a report were read from (SPEC §12, additive
- * field). The installed canonical runtime is the live truth
- * (`~/.pd/runtime/<component>/package.json`); the release cache under
- * `~/.pd/releases/<id>/` remains the fallback for layouts without a runtime
- * directory, and the legacy overlay reports its own bundle.
- */
-export type VersionComponentsSource = 'runtime' | 'release-cached' | 'legacy-overlay';
-
-export interface VersionReport {
-  readonly productVersion: string;
-  readonly releaseId: string;
-  readonly components: Readonly<Record<string, string>>;
-  /**
-   * Which layout the component versions were read from. Additive diagnostic
-   * ahead of the canonical SPEC §12 contract update (the authoritative copy
-   * lives in create-principles-disciple/src/update/product-identity.ts):
-   * optional so older consumers of this mirror stay compatible; the builder
-   * always emits it.
-   */
-  readonly componentsSource?: VersionComponentsSource;
-  readonly bootstrapVersion: string;
-  readonly channel: 'stable' | 'candidate';
-  readonly source: VersionReportSource;
-  readonly generation: number;
-  readonly health: 'healthy' | 'degraded' | 'corrupt';
-  readonly lastTransaction: Readonly<{ id: string; kind: string; outcome: string }> | null;
-}
-
-export class VersionReportError extends Error {
-  readonly reason: string;
-  readonly nextAction: string;
-
-  constructor(reason: string, message: string, nextAction: string) {
-    super(message);
-    this.name = 'VersionReportError';
-    this.reason = reason;
-    this.nextAction = nextAction;
-  }
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function readJsonIfPresent(filePath: string): Record<string, unknown> | null {
-  if (!fs.existsSync(filePath)) return null;
-  let value: unknown;
-  try {
-    value = JSON.parse(fs.readFileSync(filePath, 'utf8')) as unknown;
-  } catch (error) {
-    throw new VersionReportError(
-      'state_corrupt',
-      `Installation state file is not valid JSON: ${filePath} (${error instanceof Error ? error.message : String(error)})`,
-      'Run the official installer recovery, or re-run the official installer to repair the installation record.',
-    );
-  }
-  if (!isPlainObject(value)) {
-    throw new VersionReportError(
-      'state_corrupt',
-      `Installation state file is not a JSON object: ${filePath}`,
-      'Run the official installer recovery, or re-run the official installer to repair the installation record.',
-    );
-  }
-  return value;
-}
-
-/** `pd --version` short stable text contract. */
-export function formatShortVersion(report: Pick<VersionReport, 'productVersion' | 'releaseId'>): string {
-  return `Principles Disciple ${report.productVersion} (${report.releaseId.slice(0, 12)})`;
-}
-
-function buildLegacyOverlayReport(overlayDir: string, bootstrap: Record<string, unknown> | null): VersionReport {
-  // The current official installer copies the plugin package directly into
-  // the OpenClaw extension root. Older overlay bundles kept it under plugin/;
-  // accept that layout only when the canonical root manifest is absent.
-  const rootManifest = readJsonIfPresent(path.join(overlayDir, 'package.json'));
-  const pluginManifest = rootManifest ?? readJsonIfPresent(path.join(overlayDir, 'plugin', 'package.json'));
-  const version = pluginManifest?.version;
-  if (typeof version !== 'string' || version.length === 0) {
-    throw new VersionReportError(
-      'legacy_overlay_manifest_invalid',
-      `The legacy overlay at ${overlayDir} has no readable plugin version.`,
-      'Re-install PD with the official installer to migrate this installation into the supported layout.',
-    );
-  }
-  const bootstrapVersion = bootstrap?.bootstrapVersion;
-  return {
-    productVersion: version,
-    releaseId: '0'.repeat(64),
-    components: { plugin: version },
-    componentsSource: 'legacy-overlay',
-    bootstrapVersion: typeof bootstrapVersion === 'string' ? bootstrapVersion : 'unknown',
-    channel: 'stable',
-    source: 'official-legacy-overlay',
-    generation: 0,
-    health: 'degraded',
-    lastTransaction: null,
-  };
-}
-
-function readLastTransaction(historyPath: string): VersionReport['lastTransaction'] {
-  if (!fs.existsSync(historyPath)) return null;
-  const lines = fs.readFileSync(historyPath, 'utf8').split('\n').filter((line) => line.trim().length > 0);
-  const lastLine = lines[lines.length - 1];
-  if (lastLine === undefined) return null;
-  let value: unknown;
-  try {
-    value = JSON.parse(lastLine) as unknown;
-  } catch (error) {
-    throw new VersionReportError(
-      'state_corrupt',
-      `The last transaction record is not valid JSON: ${historyPath} (${error instanceof Error ? error.message : String(error)})`,
-      'Run the official installer recovery to reconcile the transaction journal before trusting the installed version.',
-    );
-  }
-  if (!isPlainObject(value)) return null;
-  const { transactionId, kind, outcome } = value;
-  if (typeof transactionId !== 'string' || typeof kind !== 'string' || typeof outcome !== 'string') {
-    return null;
-  }
-  return { id: transactionId, kind, outcome };
-}
-
-/**
- * Builds the canonical version report from the installation state. Throws
- * VersionReportError with an installer next-action when no installation
- * exists at all.
- */
-export function buildVersionReport(homeDir: string = os.homedir()): VersionReport {
-  const pdHome = path.join(homeDir, '.pd');
-  const active = readJsonIfPresent(path.join(pdHome, 'active.json'));
-  const bootstrap = readJsonIfPresent(path.join(pdHome, 'bootstrap', 'bootstrap.json'));
-  const installConfig = readJsonIfPresent(path.join(pdHome, 'install.json'));
-
-  const overlayDir = path.join(homeDir, '.openclaw', 'extensions', 'principles-disciple');
-
-  if (active === null && fs.existsSync(overlayDir)) {
-    return buildLegacyOverlayReport(overlayDir, bootstrap);
-  }
-  if (active === null && !fs.existsSync(pdHome)) {
-    throw new VersionReportError(
-      'not_installed',
-      'No PD installation was found under ~/.pd or the legacy overlay location.',
-      'Install PD with the official installer (npx create-principles-disciple), then run pd version again.',
-    );
-  }
-  if (active === null) {
-    throw new VersionReportError(
-      'active_record_missing',
-      'The ~/.pd installation exists but has no active release record.',
-      'Run the official installer to complete the installation, or re-run it to repair the record.',
-    );
-  }
-
-  const { generation, releaseId, productVersion } = active;
-  if (typeof generation !== 'number' || !Number.isSafeInteger(generation) || generation < 1
-    || typeof releaseId !== 'string' || releaseId.length === 0
-    || typeof productVersion !== 'string' || productVersion.length === 0) {
-    throw new VersionReportError(
-      'active_record_corrupt',
-      'The active release record under ~/.pd is malformed.',
-      'Run the official installer recovery, or re-run the official installer to repair the installation record.',
-    );
-  }
-
-  const releaseDir = path.join(pdHome, 'releases', releaseId);
-  const releaseManifest = readJsonIfPresent(path.join(releaseDir, 'metadata.json'));
-  const releaseMetadataMatchesActive = releaseManifest !== null
-    && releaseManifest.productVersion === productVersion
-    && releaseManifest.releaseId === releaseId
-    && releaseManifest.metadataDigest === active.releaseMetadataDigest;
-  const health: VersionReport['health'] = releaseManifest === null
-    ? 'degraded'
-    : releaseMetadataMatchesActive ? 'healthy' : 'corrupt';
-
-  // The live canonical runtime is the primary component-version source; the
-  // release cache stays as the fallback for layouts without a runtime
-  // directory (and per component when the runtime copy is absent). Component
-  // versions are read, never judged: independently versioned components are
-  // not corruption, and health remains bound to the active-identity
-  // verification above (a runtime full of readable package versions alone
-  // never makes the report healthy). A malformed component manifest degrades
-  // to an omitted component — this command exists to diagnose broken
-  // installs, so one corrupt manifest must not kill the whole report.
-  const runtimeDir = path.join(pdHome, 'runtime');
-  const componentsBaseDir = fs.existsSync(runtimeDir) ? runtimeDir : releaseDir;
-  const componentsSource: VersionReport['componentsSource'] = componentsBaseDir === runtimeDir
-    ? 'runtime'
-    : 'release-cached';
-  const readComponentManifest = (component: string): Record<string, unknown> | null => {
-    try {
-      return readJsonIfPresent(path.join(componentsBaseDir, component, 'package.json'));
-    } catch {
-      return null; // malformed live manifest: omit the component, keep the report
-    }
-  };
-  const components: Record<string, string> = {};
-  for (const component of ['plugin', 'console', 'core', 'pd-cli', 'host-runtime', 'install-layout', 'codex-adapter', 'release-manager']) {
-    let manifest = readComponentManifest(component);
-    if (manifest === null && componentsBaseDir === runtimeDir) {
-      // Per-component fallback: a partially populated runtime dir (partial
-      // sync) must not silently drop components that the release cache can
-      // still report.
-      try {
-        manifest = readJsonIfPresent(path.join(releaseDir, component, 'package.json'));
-      } catch {
-        manifest = null;
-      }
-    }
-    const version = manifest?.version;
-    if (typeof version === 'string') {
-      components[component] = version;
-    }
-  }
-
-  const bootstrapVersion = bootstrap?.bootstrapVersion;
-  const channelValue = installConfig?.channel;
-
-  return {
-    productVersion,
-    releaseId,
-    components,
-    componentsSource,
-    bootstrapVersion: typeof bootstrapVersion === 'string' ? bootstrapVersion : 'unknown',
-    channel: channelValue === 'candidate' ? 'candidate' : 'stable',
-    source: 'official-installer',
-    generation,
-    health,
-    lastTransaction: readLastTransaction(path.join(pdHome, 'logs', 'history.jsonl')),
-  };
-}

package/src/services/workspace-tool-semantics.ts

@@ -1,26 +0,0 @@
-/**
- * Workspace Tool Semantics Resolution — PRI-634-F R2 (review P1-2), R3
- * (SPEC §五 P1-1): thin delegation to the ONE host-runtime resolver so CLI,
- * Console, and any future entry point share the same multi-host
- * load/merge/validate/resolve path. The CLI refusal policy (code_tool_hook
- * refuses when unresolvable — no host guessing, no silent skip) stays here.
- */
-
-import type { ToolSemanticRegistry } from '@principles/core/runtime-v2';
-import { resolveWorkspaceHostToolSemantics } from '@principles/host-runtime';
-
-export type WorkspaceToolSemanticsResolution =
-  | { readonly ok: true; readonly registry: ToolSemanticRegistry; readonly hostKind: string }
-  | { readonly ok: false; readonly reason: string; readonly nextAction: string };
-
-export function resolveWorkspaceToolSemantics(workspaceDir: string): WorkspaceToolSemanticsResolution {
-  const resolved = resolveWorkspaceHostToolSemantics(workspaceDir);
-  if (!resolved.ok) {
-    return { ok: false, reason: resolved.reason, nextAction: resolved.nextAction };
-  }
-  return {
-    ok: true,
-    registry: resolved.registry,
-    hostKind: resolved.hostKinds.join('+'),
-  };
-}