@principles/pd-cli 1.152.11 → 1.152.13

package/src/commands/__tests__/version.test.ts

@@ -1,251 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { buildVersionReport, formatShortVersion, VersionReportError } from '../../services/version-report.js';
-
-const temporaryDirectories: string[] = [];
-
-function tempHome(): string {
-  const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'pd-version-'));
-  temporaryDirectories.push(root);
-  return root;
-}
-
-function writeDualSlotHome(home: string): void {
-  const pdHome = path.join(home, '.pd');
-  fs.mkdirSync(path.join(pdHome, 'releases', 'b'.repeat(64), 'plugin'), { recursive: true });
-  fs.mkdirSync(path.join(pdHome, 'bootstrap'), { recursive: true });
-  fs.mkdirSync(path.join(pdHome, 'logs'), { recursive: true });
-  fs.writeFileSync(path.join(pdHome, 'active.json'), JSON.stringify({
-    schemaVersion: 1,
-    generation: 4,
-    releaseId: 'b'.repeat(64),
-    releaseMetadataDigest: '2'.repeat(64),
-    previousReleaseId: 'a'.repeat(64),
-    transactionId: 'txn-9',
-    productVersion: '1.223.0',
-  }));
-  fs.writeFileSync(path.join(pdHome, 'bootstrap', 'bootstrap.json'), JSON.stringify({
-    bootstrapVersion: '1.1.0',
-    installedAt: '2026-08-25T00:00:00Z',
-  }));
-  fs.writeFileSync(path.join(pdHome, 'install.json'), JSON.stringify({ channel: 'candidate', autoCheck: true }));
-  fs.writeFileSync(path.join(pdHome, 'releases', 'b'.repeat(64), 'metadata.json'), JSON.stringify({
-    productVersion: '1.223.0',
-    releaseId: 'b'.repeat(64),
-    metadataDigest: '2'.repeat(64),
-  }));
-  fs.writeFileSync(path.join(pdHome, 'releases', 'b'.repeat(64), 'plugin', 'package.json'), JSON.stringify({ version: '1.76.1' }));
-  fs.writeFileSync(path.join(pdHome, 'logs', 'history.jsonl'), [
-    JSON.stringify({ at: '2026-08-24T00:00:00Z', kind: 'update', outcome: 'succeeded', transactionId: 'txn-8' }),
-    JSON.stringify({ at: '2026-08-25T00:00:00Z', kind: 'recovery', outcome: 'recovered', transactionId: 'txn-9' }),
-  ].join('\n') + '\n');
-}
-
-afterEach(() => {
-  while (temporaryDirectories.length > 0) {
-    const directory = temporaryDirectories.pop();
-    if (directory) fs.rmSync(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 200 });
-  }
-});
-
-describe('canonical version report (SPEC 12 / 18-1, 18-10)', () => {
-  it('reports the canonical product identity from ~/.pd, not package.json', () => {
-    const home = tempHome();
-    writeDualSlotHome(home);
-    const report = buildVersionReport(home);
-    expect(report).toMatchObject({
-      productVersion: '1.223.0',
-      releaseId: 'b'.repeat(64),
-      bootstrapVersion: '1.1.0',
-      channel: 'candidate',
-      source: 'official-installer',
-      generation: 4,
-      health: 'healthy',
-    });
-    expect(report.components.plugin).toBe('1.76.1');
-    expect(report.lastTransaction).toEqual({ id: 'txn-9', kind: 'recovery', outcome: 'recovered' });
-    expect(formatShortVersion(report)).toBe(`Principles Disciple 1.223.0 (${'b'.repeat(12)})`);
-  });
-
-  it('classifies a legacy overlay installation with an installer next action', () => {
-    const home = tempHome();
-    // The current official installer creates ~/.pd/bin before the transactional
-    // dual-slot layout is activated. That support directory must not make a
-    // valid legacy overlay look like a corrupt partial dual-slot install.
-    fs.mkdirSync(path.join(home, '.pd', 'bin'), { recursive: true });
-    const overlay = path.join(home, '.openclaw', 'extensions', 'principles-disciple');
-    fs.mkdirSync(overlay, { recursive: true });
-    fs.writeFileSync(path.join(overlay, 'package.json'), JSON.stringify({ version: '1.218.0' }));
-    const report = buildVersionReport(home);
-    expect(report).toMatchObject({
-      productVersion: '1.218.0',
-      source: 'official-legacy-overlay',
-      health: 'degraded',
-      generation: 0,
-    });
-  });
-
-  it('retains compatibility with the older nested legacy overlay manifest', () => {
-    const home = tempHome();
-    const overlay = path.join(home, '.openclaw', 'extensions', 'principles-disciple', 'plugin');
-    fs.mkdirSync(overlay, { recursive: true });
-    fs.writeFileSync(path.join(overlay, 'package.json'), JSON.stringify({ version: '1.202.0' }));
-    expect(buildVersionReport(home)).toMatchObject({
-      productVersion: '1.202.0', source: 'official-legacy-overlay', health: 'degraded',
-    });
-  });
-
-  it('refuses with a structured reason and next action when nothing is installed', () => {
-    const home = tempHome();
-    try {
-      buildVersionReport(home);
-      throw new Error('expected VersionReportError');
-    } catch (error) {
-      expect(error).toBeInstanceOf(VersionReportError);
-      const refusal = error as VersionReportError;
-      expect(refusal.reason).toBe('not_installed');
-      expect(refusal.nextAction).toMatch(/official installer/i);
-    }
-  });
-
-  it('reports degraded health when the active release directory is incomplete', () => {
-    const home = tempHome();
-    writeDualSlotHome(home);
-    fs.rmSync(path.join(home, '.pd', 'releases', 'b'.repeat(64), 'metadata.json'), { force: true });
-    const report = buildVersionReport(home);
-    expect(report.health).toBe('degraded');
-  });
-
-  it('reports corrupt health when release metadata exists but disagrees with active.json', () => {
-    const home = tempHome();
-    writeDualSlotHome(home);
-    fs.writeFileSync(path.join(home, '.pd', 'releases', 'b'.repeat(64), 'metadata.json'), '{}');
-    const report = buildVersionReport(home);
-    expect(report.health).toBe('corrupt');
-  });
-
-  it('refuses a malformed active record loudly instead of guessing', () => {
-    const home = tempHome();
-    fs.mkdirSync(path.join(home, '.pd'), { recursive: true });
-    fs.writeFileSync(path.join(home, '.pd', 'active.json'), JSON.stringify({ generation: 'four' }));
-    try {
-      buildVersionReport(home);
-      throw new Error('expected VersionReportError');
-    } catch (error) {
-      expect(error).toBeInstanceOf(VersionReportError);
-      expect((error as VersionReportError).reason).toBe('active_record_corrupt');
-    }
-  });
-});
-
-describe('runtime layout version report (SPEC 12, installed ~/.pd/runtime layout)', () => {
-  /** Mirrors the real installed layout: active.json + runtime/<component>/, no releases/, no logs/, no bootstrap/. */
-  function writeRuntimeOnlyHome(home: string): void {
-    const pdHome = path.join(home, '.pd');
-    fs.mkdirSync(pdHome, { recursive: true });
-    fs.writeFileSync(path.join(pdHome, 'active.json'), JSON.stringify({
-      schemaVersion: 1,
-      generation: 14,
-      releaseId: 'bundled-1.74.1-5eb58e30bfad',
-      releaseMetadataDigest: '5eb58e30bfad6205e3028b99fa7a3a6f67e138b9e97c7ed40b043ba9d8d85343',
-      previousReleaseId: 'bundled-1.74.1-9bbf8abc3b86',
-      transactionId: 'install-1789622247194-0346a565',
-      productVersion: '1.74.1',
-    }));
-    fs.writeFileSync(path.join(pdHome, 'install.json'), JSON.stringify({ channel: 'stable', autoCheck: true }));
-    const componentVersions: Readonly<Record<string, string>> = {
-      'codex-adapter': '0.1.0',
-      console: '0.1.0',
-      core: '1.74.1',
-      'host-runtime': '0.1.0',
-      'install-layout': '0.2.0',
-      'pd-cli': '1.74.1',
-      plugin: '1.76.1',
-      'release-manager': '1.74.1',
-    };
-    for (const [component, version] of Object.entries(componentVersions)) {
-      const dir = path.join(pdHome, 'runtime', component);
-      fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name: `@principles/${component}`, version }));
-    }
-    // The real runtime also carries non-package support directories.
-    fs.mkdirSync(path.join(pdHome, 'runtime', 'bin'), { recursive: true });
-  }
-
-  it('reads component versions from the live runtime layout and stays explicit about unverifiable identity', () => {
-    const home = tempHome();
-    writeRuntimeOnlyHome(home);
-    const report = buildVersionReport(home);
-    expect(report).toMatchObject({
-      productVersion: '1.74.1',
-      releaseId: 'bundled-1.74.1-5eb58e30bfad',
-      source: 'official-installer',
-      generation: 14,
-      channel: 'stable',
-    });
-    expect(report.components.plugin).toBe('1.76.1');
-    expect(report.components.core).toBe('1.74.1');
-    expect(report.components['pd-cli']).toBe('1.74.1');
-    expect(report.components['release-manager']).toBe('1.74.1');
-    expect(report.componentsSource).toBe('runtime');
-    // No release metadata exists to verify the active identity against, and
-    // independently versioned components are not corruption: the report stays
-    // honestly degraded instead of claiming health from package versions.
-    expect(report.health).toBe('degraded');
-    expect(report.lastTransaction).toBeNull();
-  });
-
-  it('degrades a malformed runtime component manifest to an omitted component instead of dying (PRI-833 review P1)', () => {
-    const home = tempHome();
-    writeRuntimeOnlyHome(home);
-    // Exactly the corruption this command exists to diagnose: one live
-    // component manifest is garbage. The report must survive with that
-    // component omitted — not abort with state_corrupt.
-    const corruptManifest = '{' + 'not-valid-json';
-    fs.writeFileSync(path.join(home, '.pd', 'runtime', 'plugin', 'package.json'), corruptManifest);
-    const report = buildVersionReport(home);
-    expect(report.components.plugin).toBeUndefined();
-    expect(report.components.core).toBe('1.74.1');
-    expect(report.componentsSource).toBe('runtime');
-    expect(report.health).toBe('degraded');
-  });
-
-  it('falls back to the release cache per component when the runtime copy is missing (PRI-833 review P2)', () => {
-    const home = tempHome();
-    writeRuntimeOnlyHome(home);
-    // Partially populated runtime: the core manifest vanished. The release
-    // cache (active releaseId dir) still knows core's version.
-    fs.rmSync(path.join(home, '.pd', 'runtime', 'core'), { recursive: true, force: true });
-    const coreFallbackDir = path.join(home, '.pd', 'releases', 'bundled-1.74.1-5eb58e30bfad', 'core');
-    fs.mkdirSync(coreFallbackDir, { recursive: true });
-    fs.writeFileSync(path.join(coreFallbackDir, 'package.json'), JSON.stringify({ name: '@principles/core', version: '1.60.0' }));
-    const report = buildVersionReport(home);
-    expect(report.components.core).toBe('1.60.0');
-    expect(report.components.plugin).toBe('1.76.1');
-    expect(report.componentsSource).toBe('runtime');
-  });
-
-  it('prefers live runtime component manifests over the release cache when both exist', () => {
-    const home = tempHome();
-    writeDualSlotHome(home);
-    const pdHome = path.join(home, '.pd');
-    fs.rmSync(path.join(pdHome, 'releases', 'b'.repeat(64), 'plugin'), { recursive: true, force: true });
-    fs.mkdirSync(path.join(pdHome, 'runtime', 'plugin'), { recursive: true });
-    fs.writeFileSync(path.join(pdHome, 'runtime', 'plugin', 'package.json'), JSON.stringify({ version: '1.999.0' }));
-    const report = buildVersionReport(home);
-    expect(report.health).toBe('healthy');
-    expect(report.componentsSource).toBe('runtime');
-    expect(report.components.plugin).toBe('1.999.0');
-  });
-
-  it('keeps the release-cache fallback for installs without a runtime directory', () => {
-    const home = tempHome();
-    writeDualSlotHome(home);
-    const report = buildVersionReport(home);
-    expect(report.health).toBe('healthy');
-    expect(report.componentsSource).toBe('release-cached');
-    expect(report.components.plugin).toBe('1.76.1');
-  });
-});

package/src/commands/admission-gate.ts

@@ -1,30 +0,0 @@
-/**
- * Shared admission gate helper for CLI commands that call intakeService.intake().
- *
- * PRI-442 Stage 4 / PRI-503: previously only `candidate.ts` checked the gate;
- * `pain-retry.ts` and `diagnose.ts` bypassed it (ERR-089 sibling-branch defect).
- * This shared helper is the single entry point so future CLI commands that
- * call intake() can reuse it instead of re-implementing (or skipping) the check.
- *
- * Runtime Contract: rc-9-no-silent-fallback — refusal includes reason + nextAction
- * (callers MUST surface these in their structured CLI output).
- */
-import { evaluateCandidateAdmissionFromRecord, type AdmissionGateResult } from '@principles/core/runtime-v2';
-
-/**
- * Check admission gate for a candidate. Returns null if admitted (caller may
- * proceed); returns AdmissionGateResult with reason + nextAction if refused
- * (caller must refuse and surface reason/nextAction in CLI output).
- *
- * @param candidate - Must carry recommendationKind and confidence from the candidate record
- */
-export function checkAdmissionGate(
-  candidate: { recommendationKind: string; confidence: number | null },
-): AdmissionGateResult | null {
-  const admission = evaluateCandidateAdmissionFromRecord({
-    recommendationKind: candidate.recommendationKind as Parameters<typeof evaluateCandidateAdmissionFromRecord>[0]['recommendationKind'],
-    confidence: candidate.confidence,
-  });
-  if (admission.decision === 'admitted') return null;
-  return admission;
-}

package/src/commands/artifact.ts

@@ -1,82 +0,0 @@
-/**
- * pd artifact show command — Artifact registry inspection.
- *
- * Usage:
- *   pd artifact show <artifactId> --workspace <path> [--json]
- */
-import {
-  RuntimeStateManager,
-  artifactShow,
-} from '@principles/core/runtime-v2';
-import { resolveWorkspaceDir } from '../resolve-workspace.js';
-
-interface ArtifactShowOptions {
-  artifactId: string;
-  workspace?: string;
-  json?: boolean;
-}
-
-/**
- * pd artifact show <artifactId> [--workspace <path>] [--json]
- *
- * Shows artifact content and its associated principle candidates.
- * Returns: artifactId, runId, taskId, artifactKind, contentJson, createdAt, candidates[].
- */
-export async function handleArtifactShow(opts: ArtifactShowOptions): Promise<void> {
-  const workspaceDir: string = resolveWorkspaceDir(opts.workspace);
-  const stateManager = new RuntimeStateManager({ workspaceDir });
-
-  try {
-    await stateManager.initialize();
-
-    const result = await artifactShow({
-      artifactId: opts.artifactId,
-      stateManager,
-    });
-
-    if (!result) {
-      console.error(`Artifact not found: ${opts.artifactId}`);
-      process.exit(1);
-    }
-
-    if (opts.json) {
-      console.log(JSON.stringify(result, null, 2));
-      return;
-    }
-
-    console.log(`\nArtifact: ${result.artifactId}\n`);
-    console.log(`  Kind:       ${result.artifactKind}`);
-    console.log(`  Run:        ${result.runId}`);
-    console.log(`  Task:       ${result.taskId}`);
-    console.log(`  Created:    ${result.createdAt}`);
-    console.log(`  Candidates: ${result.candidates.length}`);
-
-    // Pretty-print the JSON content
-    try {
-      const parsed = JSON.parse(result.contentJson);
-      console.log(`\n  Content (parsed):`);
-      console.log(`    diagnosisId: ${parsed.diagnosisId ?? 'N/A'}`);
-      console.log(`    summary:     ${parsed.summary ?? 'N/A'}`);
-      if (parsed.recommendations) {
-        console.log(`    recommendations: ${parsed.recommendations.length}`);
-        const principles = parsed.recommendations.filter((r: { kind: string }) => r.kind === 'principle');
-        if (principles.length > 0) {
-          console.log(`      (${principles.length} principle candidates)`);
-        }
-      }
-    } catch {
-      console.log(`  Content:    ${result.contentJson.substring(0, 200)}...`);
-    }
-
-    if (result.candidates.length > 0) {
-      console.log(`\n  Candidate Details:`);
-      for (const c of result.candidates) {
-        console.log(`    - ${c.candidateId} | ${c.title} | ${c.status}`);
-      }
-    }
-
-    console.log('');
-  } finally {
-    await stateManager.close();
-  }
-}

package/src/commands/build-trajectory-evidence.ts

@@ -1,298 +0,0 @@
-/**
- * Trajectory Evidence Builder for CLI — PRI-341
- *
- * Reads trajectory.db directly to extract evidence entries for `pd pain record`.
- * This avoids a dependency on openclaw-plugin (which uses WorkspaceContext / TrajectoryRegistry)
- * while providing the same capability for the CLI path.
- *
- * Core/plugin boundary: this file lives in pd-cli (I/O boundary), not in principles-core.
- * Uses better-sqlite3 (already a pd-cli dependency) and sanitizeString from core.
- */
-
-import Database from 'better-sqlite3';
-import * as fs from 'fs';
-import * as path from 'path';
-import {
-  MAX_EVIDENCE_ENTRIES,
-  MAX_EVIDENCE_NOTE_CHARS,
-  sanitizeString,
-} from '@principles/core/runtime-v2';
-import type { PainEvidenceEntry } from '@principles/core/runtime-v2';
-
-/**
- * PRI-642 (SPEC §7.3): discriminated acquisition result. `unavailable` carries
- * a distinct reasonCode so `pd pain record --session` can fail/degrade
- * explicitly BEFORE any LLM/task/candidate mutation, without placeholder
- * evidence.
- *
- * `binding` (PRI-783 review P1) is the small separate-axes fact the ingress
- * decision keys on: 'verified' = the sessions table was queried and DID
- * contain the id; 'unverified' = the id could not be validated (DB missing,
- * DB unopenable, id absent, or sessions table unreadable). Only verified
- * bindings may degrade to a bound submission — claiming bound for an
- * unverified id would let the observability writer persist that id into a
- * freshly created trajectory.db, laundering an unverified fact into future
- * "evidence" (self-proving loop).
- */
-export type TrajectoryEvidenceAcquisition =
-  | { status: 'available'; entries: PainEvidenceEntry[] }
-  | {
-      status: 'unavailable';
-      reasonCode: 'trajectory_unavailable' | 'session_not_found' | 'empty_trajectory' | 'evidence_read_failed';
-      detail: string;
-      binding: 'verified' | 'unverified';
-    };
-
-/** SourceRef markers that carry no real behavior trace (placeholder shapes). */
-const PLACEHOLDER_SOURCE_REFS = new Set([
-  'owner_reported:cli',
-  'owner_message:unavailable',
-  'agent_turn:unavailable',
-  'tool_call_failure:unavailable',
-  'trajectory:empty',
-]);
-
-interface TrajectoryDbCollection {
-  entries: PainEvidenceEntry[];
-  realEntryCount: number;
-  readFailed: boolean;
-}
-
-/**
- * Collect evidence entries from an open trajectory.db for one session.
- * Shared by the typed acquisition API and the legacy array wrapper so the
- * two can never drift.
- */
-function collectEvidenceFromDb(
-  db: Database.Database,
-  sessionId: string,
-  workspaceDir?: string,
-): TrajectoryDbCollection {
-  const evidence: PainEvidenceEntry[] = [];
-  let readFailed = false;
-
-  // Try to read user turns with correction detection
-  try {
-    const userTurns = db.prepare(`
-        SELECT id, raw_excerpt, correction_detected, correction_cue, created_at
-        FROM user_turns
-        WHERE session_id = ?
-        ORDER BY id ASC
-      `).all(sessionId) as Record<string, unknown>[];
-
-    const lastCorrectionTurn = [...userTurns].reverse().find(t => Boolean(t.correction_detected));
-    if (lastCorrectionTurn) {
-      const rawExcerpt = typeof lastCorrectionTurn.raw_excerpt === 'string'
-        ? lastCorrectionTurn.raw_excerpt
-        : '';
-      const sanitizedNote = sanitizeString(
-        rawExcerpt.slice(0, MAX_EVIDENCE_NOTE_CHARS),
-        workspaceDir,
-      );
-      evidence.push({
-        sourceRef: `owner_message:${String(lastCorrectionTurn.created_at ?? 'unknown')}`,
-        note: sanitizedNote,
-      });
-    }
-  } catch {
-    readFailed = true;
-    // user_turns table may not exist — degrade gracefully
-    if (evidence.length < MAX_EVIDENCE_ENTRIES) {
-      evidence.push({
-        sourceRef: 'owner_message:unavailable',
-        note: 'trajectory_user_turns_unavailable',
-      });
-    }
-  }
-
-  // Try to read assistant turns (last 3)
-  try {
-    const assistantTurns = db.prepare(`
-        SELECT id, sanitized_text, stop_reason, created_at
-        FROM assistant_turns
-        WHERE session_id = ?
-        ORDER BY id ASC
-      `).all(sessionId) as Record<string, unknown>[];
-
-    const recentAssistant = assistantTurns.slice(-3);
-    for (const turn of recentAssistant) {
-      if (evidence.length >= MAX_EVIDENCE_ENTRIES) break;
-      const sanitizedText = typeof turn.sanitized_text === 'string'
-        ? turn.sanitized_text
-        : '';
-      const sanitizedNote = sanitizeString(
-        sanitizedText.slice(0, MAX_EVIDENCE_NOTE_CHARS),
-        workspaceDir,
-      );
-      // Enhanced: append truncation warning when stop_reason=length
-      const stopReason = typeof turn.stop_reason === 'string' ? turn.stop_reason : null;
-      const truncationWarning = stopReason === 'length' ? ' [TRUNCATED: output cut off by length limit]' : '';
-      evidence.push({
-        sourceRef: `agent_turn:${String(turn.created_at ?? 'unknown')}`,
-        note: sanitizedNote + truncationWarning,
-      });
-    }
-  } catch {
-    readFailed = true;
-    // assistant_turns table may not exist — degrade gracefully
-    if (evidence.length < MAX_EVIDENCE_ENTRIES) {
-      evidence.push({
-        sourceRef: 'agent_turn:unavailable',
-        note: 'trajectory_assistant_turns_unavailable',
-      });
-    }
-  }
-
-  // PRI-358: Try to read failed tool_calls (last 3 failures, chronological order)
-  try {
-    const failedToolCalls = db.prepare(`
-        SELECT tool_name, error_type, exit_code, result_preview, created_at
-        FROM (
-          SELECT tool_name, error_type, exit_code, result_preview, created_at
-          FROM tool_calls
-          WHERE session_id = ? AND outcome = 'failure'
-          ORDER BY created_at DESC
-          LIMIT 3
-        )
-        ORDER BY created_at ASC
-      `).all(sessionId) as Record<string, unknown>[];
-
-    for (const tc of failedToolCalls) {
-      if (evidence.length >= MAX_EVIDENCE_ENTRIES) break;
-      const toolName = typeof tc.tool_name === 'string' ? tc.tool_name : 'unknown';
-      const errorType = typeof tc.error_type === 'string' ? tc.error_type : 'unknown';
-      const exitCode = tc.exit_code != null ? String(tc.exit_code) : 'N/A';
-      // Enhanced: append resultPreview when available
-      const resultPreview = typeof tc.result_preview === 'string' ? tc.result_preview : null;
-      const previewSuffix = resultPreview ? ` | ${resultPreview.slice(0, 200)}` : '';
-      const note = `Tool ${toolName} failed: ${errorType} (exitCode: ${exitCode})${previewSuffix}`;
-      evidence.push({
-        sourceRef: `tool_call_failure:${String(tc.created_at ?? 'unknown')}`,
-        note: sanitizeString(note.slice(0, MAX_EVIDENCE_NOTE_CHARS), workspaceDir),
-      });
-    }
-  } catch {
-    readFailed = true;
-    // tool_calls table may not exist — degrade gracefully (only when no other evidence)
-    if (evidence.length === 0) {
-      evidence.push({
-        sourceRef: 'tool_call_failure:unavailable',
-        note: 'trajectory_tool_calls_unavailable',
-      });
-    }
-  }
-
-  // If no evidence at all from trajectory, provide a meaningful placeholder
-  if (evidence.length === 0) {
-    evidence.push({
-      sourceRef: 'trajectory:empty',
-      note: 'trajectory_available_but_empty: no user correction or assistant turns found',
-    });
-  }
-
-  const bounded = evidence.slice(0, MAX_EVIDENCE_ENTRIES);
-  const realEntryCount = bounded.reduce(
-    (count, entry) => count + (PLACEHOLDER_SOURCE_REFS.has(entry.sourceRef) ? 0 : 1),
-    0,
-  );
-  return { entries: bounded, realEntryCount, readFailed };
-}
-
-/**
- * PRI-642 Scope A typed acquisition from trajectory.db (SPEC §7.3).
- *
- * Validates that the requested session exists in the trajectory `sessions`
- * table (every recorded turn/tool call upserts its session row, so an absent
- * row means the session was never seen) and classifies the outcome:
- *  - `available`            — session bound, ≥1 real behavior-trace entry;
- *  - `session_not_found`    — session absent from the sessions table (or a
- *                             `cli`/`unknown` sentinel — never a real session);
- *  - `trajectory_unavailable` — no trajectory.db in this workspace;
- *  - `evidence_read_failed` — the DB exists but cannot be opened/read;
- *  - `empty_trajectory`     — real session, no usable evidence rows.
- */
-export function acquireTrajectoryEvidenceFromDb(
-  stateDir: string,
-  sessionId: string | undefined,
-  workspaceDir?: string,
-): TrajectoryEvidenceAcquisition {
-  if (!sessionId || sessionId === 'cli' || sessionId === 'unknown') {
-    return {
-      status: 'unavailable',
-      reasonCode: 'session_not_found',
-      detail: sessionId ? `sentinel_session_id:${sessionId}` : 'missing_session_id',
-      binding: 'unverified',
-    };
-  }
-
-  const dbPath = path.join(stateDir, 'trajectory.db');
-  if (!fs.existsSync(dbPath)) {
-    return {
-      status: 'unavailable',
-      reasonCode: 'trajectory_unavailable',
-      detail: 'trajectory_db_missing',
-      binding: 'unverified',
-    };
-  }
-
-  let db: Database.Database;
-  try {
-    db = new Database(dbPath, { readonly: true });
-  } catch (err) {
-    return {
-      status: 'unavailable',
-      reasonCode: 'evidence_read_failed',
-      detail: `trajectory_db_unreadable: ${err instanceof Error ? err.message : String(err)}`,
-      binding: 'unverified',
-    };
-  }
-
-  try {
-    // Session existence: rows are upserted by every turn/tool-call write, so
-    // an absent row means the trajectory never saw this session.
-    let sessionExists = false;
-    // PRI-783 review P1: only a query that actually RAN and found the row
-    // counts as binding verification — the legacy fallback (sessions table
-    // missing) leaves the id unverified.
-    let sessionVerified = false;
-    try {
-      const row = db.prepare('SELECT 1 FROM sessions WHERE session_id = ?').get(sessionId);
-      sessionExists = row !== undefined;
-      sessionVerified = sessionExists;
-    } catch {
-      // sessions table missing → cannot validate existence; fall through and
-      // let the evidence rows decide (legacy DBs may lack the table).
-      sessionExists = true;
-      sessionVerified = false;
-    }
-    if (!sessionExists) {
-      return {
-        status: 'unavailable',
-        reasonCode: 'session_not_found',
-        detail: 'session_not_present_in_trajectory',
-        binding: 'unverified',
-      };
-    }
-
-    const collection = collectEvidenceFromDb(db, sessionId, workspaceDir);
-    if (collection.realEntryCount > 0) {
-      return { status: 'available', entries: collection.entries };
-    }
-    if (collection.readFailed) {
-      return {
-        status: 'unavailable',
-        reasonCode: 'evidence_read_failed',
-        detail: 'trajectory_tables_unreadable',
-        binding: sessionVerified ? 'verified' : 'unverified',
-      };
-    }
-    return {
-      status: 'unavailable',
-      reasonCode: 'empty_trajectory',
-      detail: 'session_present_but_no_usable_evidence',
-      binding: sessionVerified ? 'verified' : 'unverified',
-    };
-  } finally {
-    db.close();
-  }
-}