agentic-orchestrator 0.1.26 → 0.1.28

package/packages/web-dashboard/src/lib/aop-client.ts

@@ -2,31 +2,75 @@ import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
 import { getProjectByName, readMultiProjectConfig } from '@/lib/multi-project-config.js';
+import { parseUnifiedDiff } from '@/lib/dashboard-utils.js';
 import type {
+  AgentLogEntry,
+  AgentSessionCluster,
   AgentPipelineStatus,
   CostSummary,
   DashboardStatusPayload,
   EvidenceArtifact,
+  FeatureCheckpointComparison,
+  FeatureCheckpointDiff,
   FeatureDetail,
   FeatureLog,
   FeatureLogEntry,
   FeaturesIndex,
   FeatureSummary,
+  FeatureCheckpoint,
+  FeatureExecutionMode,
   GateRunEvidence,
+  InteractiveExecutionModeMetrics,
+  InteractivePerformanceLatestCheckpoint,
+  InteractivePerformanceMetrics,
   LockLease,
   QaTestIndex,
+  RawLogFileMeta,
   ReviewBrief,
   RoleStatus,
   RuntimeSession,
+  WorkerEventEntry,
 } from '@/lib/types.js';
 
 const AOP_ROOT = process.env.AOP_ROOT ?? process.cwd();
+const LOG_FILENAME_PATTERN = /^(planner|builder|qa)-(\d{13})\.txt$/;
+const CHECKPOINT_METRICS_HISTORY_LIMIT = 200;
 
 interface ParsedFrontMatter {
   frontMatter: Record<string, unknown>;
   body: string;
 }
 
+interface InteractiveCheckpointMetricRecord {
+  recorded_at: string;
+  feature_id: string;
+  checkpoint_id: string;
+  trigger: string;
+  validation_status: 'valid' | 'invalid' | 'skipped';
+  checkpoint_latency_ms: number;
+  validation_latency_ms: number;
+  diff_capture_latency_ms: number;
+  files_changed: number;
+}
+
+interface InteractiveMetricsFileShape {
+  schema_version: number;
+  updated_at: string;
+  totals: {
+    checkpoint_count: number;
+    valid_count: number;
+    invalid_count: number;
+    skipped_count: number;
+    files_changed_total: number;
+  };
+  histories: {
+    checkpoint_latency_ms: number[];
+    validation_latency_ms: number[];
+    diff_capture_latency_ms: number[];
+  };
+  latest: InteractiveCheckpointMetricRecord | null;
+}
+
 const STATUS_TO_PHASE: Record<string, FeatureSummary['phase']> = {
   planning: 'planning',
   building: 'building',
@@ -91,6 +135,39 @@ function parseRoleStatus(frontMatter: Record<string, unknown>): AgentPipelineSta
   return { planner, builder, qa };
 }
 
+function isSessionId(value: unknown): value is string {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  const trimmed = value.trim();
+  return (
+    trimmed.length > 0 && trimmed !== 'unknown' && trimmed !== 'unassigned' && trimmed !== 'none'
+  );
+}
+
+function parseSessionCluster(frontMatter: Record<string, unknown>): AgentSessionCluster | null {
+  const raw = frontMatter.cluster;
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+  const cluster = raw as Record<string, unknown>;
+  const orchestrator = isSessionId(cluster.orchestrator_session_id)
+    ? cluster.orchestrator_session_id
+    : null;
+  const planner = isSessionId(cluster.planner_session_id) ? cluster.planner_session_id : null;
+  const builder = isSessionId(cluster.builder_session_id) ? cluster.builder_session_id : null;
+  const qa = isSessionId(cluster.qa_session_id) ? cluster.qa_session_id : null;
+  if (!orchestrator && !planner && !builder && !qa) {
+    return null;
+  }
+  return {
+    orchestrator_session_id: orchestrator ?? 'unknown',
+    planner_session_id: planner ?? 'unknown',
+    builder_session_id: builder ?? 'unknown',
+    qa_session_id: qa ?? 'unknown',
+  };
+}
+
 function firstValidTimestamp(frontMatter: Record<string, unknown>): number | null {
   const candidates = [
     frontMatter.activity_last_event_at,
@@ -166,6 +243,133 @@ function asRecord(value: unknown): Record<string, unknown> | null {
   return value && typeof value === 'object' ? (value as Record<string, unknown>) : null;
 }
 
+function normalizeFeatureExecutionMode(value: unknown): FeatureExecutionMode | null {
+  return value === 'deterministic' || value === 'interactive' ? value : null;
+}
+
+function normalizeFeatureCheckpoints(frontMatter: Record<string, unknown>): FeatureCheckpoint[] {
+  const raw = frontMatter['checkpoints'];
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const checkpoints: FeatureCheckpoint[] = [];
+  for (const entry of raw) {
+    const record = asRecord(entry);
+    if (!record) {
+      continue;
+    }
+    const checkpointId =
+      typeof record.checkpoint_id === 'string' ? record.checkpoint_id.trim() : '';
+    const timestamp = typeof record.timestamp === 'string' ? record.timestamp.trim() : '';
+    const diffSnapshot =
+      typeof record.diff_snapshot === 'string' ? record.diff_snapshot.trim() : '';
+    const validationStatus =
+      record.validation_status === 'valid' ||
+      record.validation_status === 'invalid' ||
+      record.validation_status === 'skipped'
+        ? record.validation_status
+        : null;
+    if (!checkpointId || !timestamp || !diffSnapshot || !validationStatus) {
+      continue;
+    }
+
+    const filesChanged = Array.isArray(record.files_changed)
+      ? record.files_changed.filter((item): item is string => typeof item === 'string')
+      : [];
+    const violations = Array.isArray(record.violations)
+      ? record.violations.filter((item): item is string => typeof item === 'string')
+      : [];
+    const severity =
+      record.severity === 'info' ||
+      record.severity === 'warning' ||
+      record.severity === 'error' ||
+      record.severity === 'critical'
+        ? record.severity
+        : undefined;
+    checkpoints.push({
+      checkpoint_id: checkpointId,
+      timestamp,
+      files_changed: filesChanged,
+      validation_status: validationStatus,
+      violations,
+      severity,
+      diff_snapshot: diffSnapshot,
+    });
+  }
+
+  checkpoints.sort((left, right) => {
+    const rightTs = Date.parse(right.timestamp);
+    const leftTs = Date.parse(left.timestamp);
+    if (Number.isNaN(rightTs) || Number.isNaN(leftTs)) {
+      return right.checkpoint_id.localeCompare(left.checkpoint_id);
+    }
+    return rightTs - leftTs;
+  });
+
+  return checkpoints;
+}
+
+function average(values: number[]): number | null {
+  if (values.length === 0) {
+    return null;
+  }
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function percentile(values: number[], percentileRank: number): number | null {
+  if (values.length === 0) {
+    return null;
+  }
+  const sorted = [...values].sort((left, right) => left - right);
+  const rank = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil((percentileRank / 100) * sorted.length) - 1),
+  );
+  return sorted[rank] ?? null;
+}
+
+function normalizeNumberArray(value: unknown): number[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(
+    (entry): entry is number => typeof entry === 'number' && Number.isFinite(entry),
+  );
+}
+
+function truncateNumber(value: number | null, digits = 2): number | null {
+  if (value == null) {
+    return null;
+  }
+  const factor = Math.pow(10, digits);
+  return Math.round(value * factor) / factor;
+}
+
+function resolveRepoRelativePath(repoRoot: string, relativePath: string): string | null {
+  const resolved = path.resolve(repoRoot, relativePath);
+  const normalizedRoot = path.resolve(repoRoot);
+  if (resolved === normalizedRoot) {
+    return resolved;
+  }
+  if (!resolved.startsWith(`${normalizedRoot}${path.sep}`)) {
+    return null;
+  }
+  return resolved;
+}
+
+function normalizeCheckpointDiffSignature(rawDiff: string): Map<string, string> {
+  const signatures = new Map<string, string>();
+  const files = parseUnifiedDiff(rawDiff);
+  for (const file of files) {
+    const key = file.filePath.trim();
+    if (!key) {
+      continue;
+    }
+    signatures.set(key, JSON.stringify(file));
+  }
+  return signatures;
+}
+
 async function readJsonFile<T>(filePath: string): Promise<T | null> {
   try {
     const raw = await readFile(filePath, 'utf-8');
@@ -295,6 +499,7 @@ function normalizeFeatureSummary(
         }
       : undefined;
   const roleStatus = parseRoleStatus(frontMatter);
+  const cluster = parseSessionCluster(frontMatter);
   const rawLocks =
     frontMatter.locks && typeof frontMatter.locks === 'object'
       ? (frontMatter.locks as Record<string, unknown>)
@@ -331,6 +536,7 @@ function normalizeFeatureSummary(
     revision_reason:
       typeof frontMatter.revision_reason === 'string' ? frontMatter.revision_reason : null,
     role_status: roleStatus ?? undefined,
+    cluster: cluster ?? undefined,
     gate_retry_count:
       typeof frontMatter.gate_retry_count === 'number' ? frontMatter.gate_retry_count : undefined,
     last_retry_at: typeof frontMatter.last_retry_at === 'string' ? frontMatter.last_retry_at : null,
@@ -469,6 +675,26 @@ export async function readFeatureState(
   }
 }
 
+export async function readFeatureCheckpoints(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<{
+  execution_mode: FeatureExecutionMode | null;
+  checkpoints: FeatureCheckpoint[];
+} | null> {
+  const statePath = path.join(getFeatureRoot(featureId, repoRoot), 'state.md');
+  try {
+    const raw = await readFile(statePath, 'utf-8');
+    const { frontMatter } = parseFrontMatter(raw);
+    return {
+      execution_mode: normalizeFeatureExecutionMode(frontMatter.execution_mode),
+      checkpoints: normalizeFeatureCheckpoints(frontMatter),
+    };
+  } catch {
+    return null;
+  }
+}
+
 export async function readFeaturePlan(
   featureId: string,
   repoRoot = AOP_ROOT,
@@ -622,6 +848,93 @@ export async function readFeatureDiff(featureId: string, repoRoot = AOP_ROOT): P
   }
 }
 
+export async function readFeatureCheckpointDiff(
+  featureId: string,
+  checkpointId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureCheckpointDiff | null> {
+  const checkpointState = await readFeatureCheckpoints(featureId, repoRoot);
+  if (!checkpointState) {
+    return null;
+  }
+  const checkpoint = checkpointState.checkpoints.find(
+    (entry) => entry.checkpoint_id === checkpointId,
+  );
+  if (!checkpoint) {
+    return null;
+  }
+  const resolvedSnapshotPath = resolveRepoRelativePath(repoRoot, checkpoint.diff_snapshot);
+  if (!resolvedSnapshotPath) {
+    return null;
+  }
+  try {
+    const diff = await readFile(resolvedSnapshotPath, 'utf-8');
+    return {
+      checkpoint,
+      diff,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function compareFeatureCheckpoints(
+  featureId: string,
+  fromCheckpointId: string,
+  toCheckpointId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureCheckpointComparison | null> {
+  if (fromCheckpointId === toCheckpointId) {
+    return null;
+  }
+  const [fromSnapshot, toSnapshot] = await Promise.all([
+    readFeatureCheckpointDiff(featureId, fromCheckpointId, repoRoot),
+    readFeatureCheckpointDiff(featureId, toCheckpointId, repoRoot),
+  ]);
+  if (!fromSnapshot || !toSnapshot) {
+    return null;
+  }
+
+  const fromSignatures = normalizeCheckpointDiffSignature(fromSnapshot.diff);
+  const toSignatures = normalizeCheckpointDiffSignature(toSnapshot.diff);
+  const allPaths = new Set<string>([...fromSignatures.keys(), ...toSignatures.keys()]);
+
+  const files: FeatureCheckpointComparison['files'] = [];
+  for (const filePath of allPaths) {
+    const fromSignature = fromSignatures.get(filePath);
+    const toSignature = toSignatures.get(filePath);
+    let status: FeatureCheckpointComparison['files'][number]['status'] = 'unchanged';
+    if (fromSignature == null && toSignature != null) {
+      status = 'added';
+    } else if (fromSignature != null && toSignature == null) {
+      status = 'removed';
+    } else if (fromSignature !== toSignature) {
+      status = 'changed';
+    }
+    files.push({ path: filePath, status });
+  }
+
+  files.sort((left, right) => left.path.localeCompare(right.path));
+
+  const summary = {
+    added: files.filter((file) => file.status === 'added').length,
+    removed: files.filter((file) => file.status === 'removed').length,
+    changed: files.filter((file) => file.status === 'changed').length,
+    unchanged: files.filter((file) => file.status === 'unchanged').length,
+  };
+
+  return {
+    from_checkpoint_id: fromCheckpointId,
+    to_checkpoint_id: toCheckpointId,
+    from_timestamp: fromSnapshot.checkpoint.timestamp,
+    to_timestamp: toSnapshot.checkpoint.timestamp,
+    summary,
+    files,
+    from_diff: fromSnapshot.diff,
+    to_diff: toSnapshot.diff,
+  };
+}
+
 export async function listEvidenceArtifacts(
   featureId: string,
   repoRoot = AOP_ROOT,
@@ -798,6 +1111,76 @@ function parseStateLogBody(body: string): FeatureLogEntry[] {
   return entries;
 }
 
+function parseRoleFromActor(actor: string): AgentLogEntry['role'] {
+  const candidate = actor.split(':')[0]?.trim().toLowerCase();
+  if (!candidate) {
+    return 'orchestrator';
+  }
+  return candidate;
+}
+
+function parseDecisionEntries(raw: string): AgentLogEntry[] {
+  const lines = raw.replace(/\r\n/g, '\n').split('\n');
+  const entries: AgentLogEntry[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith('#')) {
+      continue;
+    }
+    const match = trimmed.match(/^-?\s*([0-9TZ:.-]{10,})\s+\[([^\]]+)\]\s+([\s\S]+)$/);
+    if (match) {
+      const timestampRaw = match[1];
+      const actor = match[2].trim();
+      const text = match[3].trim();
+      const timestamp = Number.isNaN(Date.parse(timestampRaw))
+        ? new Date().toISOString()
+        : new Date(timestampRaw).toISOString();
+      entries.push({
+        id: `${timestamp}:${entries.length}`,
+        timestamp,
+        actor,
+        role: parseRoleFromActor(actor),
+        text,
+      });
+      continue;
+    }
+
+    entries.push({
+      id: `line:${entries.length}`,
+      timestamp: new Date().toISOString(),
+      actor: 'system:unknown',
+      role: 'orchestrator',
+      text: trimmed,
+    });
+  }
+
+  return entries;
+}
+
+export async function readDecisionLogEntries(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: { order?: 'asc' | 'desc' } = {},
+): Promise<AgentLogEntry[]> {
+  const logPath = path.join(getFeatureRoot(featureId, repoRoot), 'decisions.md');
+  const order = options.order ?? 'desc';
+  try {
+    const raw = await readFile(logPath, 'utf8');
+    const sorted = parseDecisionEntries(raw).sort((left, right) => {
+      const leftMs = Date.parse(left.timestamp);
+      const rightMs = Date.parse(right.timestamp);
+      if (leftMs === rightMs) {
+        return left.id.localeCompare(right.id);
+      }
+      return leftMs - rightMs;
+    });
+    return order === 'desc' ? [...sorted].reverse() : sorted;
+  } catch {
+    return [];
+  }
+}
+
 export async function readFeatureLog(featureId: string, repoRoot = AOP_ROOT): Promise<FeatureLog> {
   const statePath = path.join(getFeatureRoot(featureId, repoRoot), 'state.md');
   const entries: FeatureLogEntry[] = [];
@@ -833,6 +1216,342 @@ export async function readFeatureLog(featureId: string, repoRoot = AOP_ROOT): Pr
   };
 }
 
+function normalizeRawLogRole(value: unknown): RawLogFileMeta['role'] | null {
+  return value === 'planner' || value === 'builder' || value === 'qa' ? value : null;
+}
+
+export async function listRawLogFiles(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: { role?: string | null; limit?: number } = {},
+): Promise<RawLogFileMeta[]> {
+  const logsDir = path.join(getFeatureRoot(featureId, repoRoot), 'logs');
+  const roleFilter = normalizeRawLogRole(options.role ?? null);
+  const hardLimit = Math.min(Math.max(options.limit ?? 100, 1), 200);
+  try {
+    const files = await readdir(logsDir);
+    const entries: RawLogFileMeta[] = [];
+    for (const filename of files) {
+      const match = filename.match(LOG_FILENAME_PATTERN);
+      if (!match) {
+        continue;
+      }
+      const role = normalizeRawLogRole(match[1]);
+      if (!role) {
+        continue;
+      }
+      if (roleFilter && role !== roleFilter) {
+        continue;
+      }
+      const unixMs = Number.parseInt(match[2], 10);
+      const filePath = path.join(logsDir, filename);
+      const fileStat = await stat(filePath).catch(() => null);
+      if (!fileStat?.isFile()) {
+        continue;
+      }
+      entries.push({
+        filename,
+        role,
+        timestamp: Number.isNaN(unixMs)
+          ? fileStat.mtime.toISOString()
+          : new Date(unixMs).toISOString(),
+        size_bytes: fileStat.size,
+      });
+    }
+    return entries
+      .sort((left, right) => Date.parse(right.timestamp) - Date.parse(left.timestamp))
+      .slice(0, hardLimit);
+  } catch {
+    return [];
+  }
+}
+
+export async function readRawLogFile(
+  featureId: string,
+  filename: string,
+  repoRoot = AOP_ROOT,
+): Promise<string | null> {
+  if (!LOG_FILENAME_PATTERN.test(filename)) {
+    return null;
+  }
+  const logPath = path.join(getFeatureRoot(featureId, repoRoot), 'logs', filename);
+  try {
+    return await readFile(logPath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+interface WorkerTimelineReadOptions {
+  role?: string | null;
+  valid?: 'all' | 'valid' | 'invalid';
+  limit?: number;
+}
+
+function asWorkerEventEntry(value: unknown): WorkerEventEntry | null {
+  if (!value || typeof value !== 'object') {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (typeof record.ts !== 'string' || typeof record.role !== 'string') {
+    return null;
+  }
+  const outputTypes = Array.isArray(record.output_types)
+    ? record.output_types.filter((item): item is string => typeof item === 'string')
+    : [];
+  return {
+    ts: record.ts,
+    role: record.role,
+    output_types: outputTypes,
+    patch_count: typeof record.patch_count === 'number' ? record.patch_count : 0,
+    plan_submission_count:
+      typeof record.plan_submission_count === 'number' ? record.plan_submission_count : 0,
+    request_count: typeof record.request_count === 'number' ? record.request_count : 0,
+    note_count: typeof record.note_count === 'number' ? record.note_count : 0,
+    valid: record.valid !== false,
+    error_code: typeof record.error_code === 'string' ? record.error_code : null,
+    provider: typeof record.provider === 'string' ? record.provider : 'unknown',
+    model: typeof record.model === 'string' ? record.model : 'unknown',
+    elapsed_ms: typeof record.elapsed_ms === 'number' ? record.elapsed_ms : undefined,
+    feature_id: typeof record.feature_id === 'string' ? record.feature_id : undefined,
+    event_type: typeof record.event_type === 'string' ? record.event_type : undefined,
+    execution_mode:
+      record.execution_mode === 'interactive' || record.execution_mode === 'deterministic'
+        ? record.execution_mode
+        : undefined,
+    run_id: typeof record.run_id === 'string' ? record.run_id : undefined,
+  };
+}
+
+export async function readWorkerTimelineEntries(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: WorkerTimelineReadOptions = {},
+): Promise<WorkerEventEntry[]> {
+  const eventsRoot = path.join(repoRoot, '.aop', 'runtime', 'worker-events');
+  const hardLimit = Math.min(Math.max(options.limit ?? 100, 1), 100);
+  const roleFilter =
+    typeof options.role === 'string' && options.role.length > 0 ? options.role : null;
+  const validityFilter = options.valid ?? 'all';
+
+  try {
+    const files = (await readdir(eventsRoot))
+      .filter((name) => name.endsWith('.jsonl'))
+      .sort((left, right) => right.localeCompare(left));
+    const entries: WorkerEventEntry[] = [];
+    for (const file of files) {
+      const fullPath = path.join(eventsRoot, file);
+      const raw = await readFile(fullPath, 'utf8').catch(() => '');
+      if (!raw) {
+        continue;
+      }
+      for (const line of raw.replace(/\r\n/g, '\n').split('\n')) {
+        if (line.trim().length === 0) {
+          continue;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const entry = asWorkerEventEntry(parsed);
+        if (!entry) {
+          continue;
+        }
+        if (entry.feature_id !== featureId) {
+          continue;
+        }
+        if (roleFilter && entry.role !== roleFilter) {
+          continue;
+        }
+        if (validityFilter === 'valid' && !entry.valid) {
+          continue;
+        }
+        if (validityFilter === 'invalid' && entry.valid) {
+          continue;
+        }
+        entries.push(entry);
+      }
+    }
+    return entries
+      .sort((left, right) => Date.parse(right.ts) - Date.parse(left.ts))
+      .slice(0, hardLimit);
+  } catch {
+    return [];
+  }
+}
+
+function normalizeLatestInteractiveMetric(
+  value: unknown,
+): InteractivePerformanceLatestCheckpoint | null {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  if (
+    typeof record.feature_id !== 'string' ||
+    typeof record.checkpoint_id !== 'string' ||
+    typeof record.trigger !== 'string' ||
+    typeof record.validation_status !== 'string' ||
+    typeof record.recorded_at !== 'string'
+  ) {
+    return null;
+  }
+  if (
+    record.validation_status !== 'valid' &&
+    record.validation_status !== 'invalid' &&
+    record.validation_status !== 'skipped'
+  ) {
+    return null;
+  }
+  return {
+    feature_id: record.feature_id,
+    checkpoint_id: record.checkpoint_id,
+    trigger: record.trigger,
+    validation_status: record.validation_status,
+    checkpoint_latency_ms:
+      typeof record.checkpoint_latency_ms === 'number' ? record.checkpoint_latency_ms : 0,
+    validation_latency_ms:
+      typeof record.validation_latency_ms === 'number' ? record.validation_latency_ms : 0,
+    diff_capture_latency_ms:
+      typeof record.diff_capture_latency_ms === 'number' ? record.diff_capture_latency_ms : 0,
+    files_changed: typeof record.files_changed === 'number' ? record.files_changed : 0,
+    recorded_at: record.recorded_at,
+  };
+}
+
+async function readAllWorkerEvents(repoRoot = AOP_ROOT): Promise<WorkerEventEntry[]> {
+  const eventsRoot = path.join(repoRoot, '.aop', 'runtime', 'worker-events');
+  try {
+    const files = (await readdir(eventsRoot))
+      .filter((name) => name.endsWith('.jsonl'))
+      .sort((left, right) => right.localeCompare(left));
+    const entries: WorkerEventEntry[] = [];
+    for (const file of files) {
+      const fullPath = path.join(eventsRoot, file);
+      const raw = await readFile(fullPath, 'utf8').catch(() => '');
+      if (!raw) {
+        continue;
+      }
+      for (const line of raw.replace(/\r\n/g, '\n').split('\n')) {
+        if (!line.trim()) {
+          continue;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const entry = asWorkerEventEntry(parsed);
+        if (entry) {
+          entries.push(entry);
+        }
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+
+function computeExecutionModeMetrics(entries: WorkerEventEntry[]): InteractiveExecutionModeMetrics {
+  const deterministic = entries.filter((entry) => entry.execution_mode === 'deterministic');
+  const interactive = entries.filter((entry) => entry.execution_mode === 'interactive');
+
+  const deterministicElapsed = deterministic
+    .map((entry) => entry.elapsed_ms)
+    .filter((value): value is number => typeof value === 'number' && Number.isFinite(value));
+  const interactiveElapsed = interactive
+    .map((entry) => entry.elapsed_ms)
+    .filter((value): value is number => typeof value === 'number' && Number.isFinite(value));
+  const deterministicRequests = deterministic.map((entry) => entry.request_count);
+  const interactiveRequests = interactive.map((entry) => entry.request_count);
+
+  const deterministicAvgRequest = average(deterministicRequests);
+  const interactiveAvgRequest = average(interactiveRequests);
+  const reductionRatio =
+    deterministicAvgRequest != null && deterministicAvgRequest > 0 && interactiveAvgRequest != null
+      ? (deterministicAvgRequest - interactiveAvgRequest) / deterministicAvgRequest
+      : null;
+
+  return {
+    interactive_iterations: interactive.length,
+    deterministic_iterations: deterministic.length,
+    interactive_avg_elapsed_ms: truncateNumber(average(interactiveElapsed), 1),
+    deterministic_avg_elapsed_ms: truncateNumber(average(deterministicElapsed), 1),
+    interactive_avg_request_count: truncateNumber(interactiveAvgRequest, 2),
+    deterministic_avg_request_count: truncateNumber(deterministicAvgRequest, 2),
+    context_request_reduction_ratio: truncateNumber(reductionRatio, 4),
+  };
+}
+
+export async function readInteractivePerformanceMetrics(
+  repoRoot = AOP_ROOT,
+): Promise<InteractivePerformanceMetrics> {
+  const metricsPath = path.join(repoRoot, '.aop', 'analytics', 'interactive-mode.json');
+  const parsed = await readJsonFile<InteractiveMetricsFileShape>(metricsPath);
+  const executionModes = computeExecutionModeMetrics(await readAllWorkerEvents(repoRoot));
+
+  if (!parsed) {
+    return {
+      updated_at: null,
+      checkpoint_count: 0,
+      valid_count: 0,
+      invalid_count: 0,
+      skipped_count: 0,
+      avg_files_changed: null,
+      avg_checkpoint_latency_ms: null,
+      p95_checkpoint_latency_ms: null,
+      avg_validation_latency_ms: null,
+      p95_validation_latency_ms: null,
+      avg_diff_capture_latency_ms: null,
+      latest: null,
+      execution_modes: executionModes,
+    };
+  }
+
+  const checkpointLatencies = normalizeNumberArray(parsed.histories?.checkpoint_latency_ms).slice(
+    -CHECKPOINT_METRICS_HISTORY_LIMIT,
+  );
+  const validationLatencies = normalizeNumberArray(parsed.histories?.validation_latency_ms).slice(
+    -CHECKPOINT_METRICS_HISTORY_LIMIT,
+  );
+  const diffCaptureLatencies = normalizeNumberArray(
+    parsed.histories?.diff_capture_latency_ms,
+  ).slice(-CHECKPOINT_METRICS_HISTORY_LIMIT);
+
+  const checkpointCount =
+    typeof parsed.totals?.checkpoint_count === 'number'
+      ? parsed.totals.checkpoint_count
+      : checkpointLatencies.length;
+  const validCount = typeof parsed.totals?.valid_count === 'number' ? parsed.totals.valid_count : 0;
+  const invalidCount =
+    typeof parsed.totals?.invalid_count === 'number' ? parsed.totals.invalid_count : 0;
+  const skippedCount =
+    typeof parsed.totals?.skipped_count === 'number' ? parsed.totals.skipped_count : 0;
+  const filesChangedTotal =
+    typeof parsed.totals?.files_changed_total === 'number' ? parsed.totals.files_changed_total : 0;
+  const averageFilesChanged = checkpointCount > 0 ? filesChangedTotal / checkpointCount : null;
+
+  return {
+    updated_at: typeof parsed.updated_at === 'string' ? parsed.updated_at : null,
+    checkpoint_count: checkpointCount,
+    valid_count: validCount,
+    invalid_count: invalidCount,
+    skipped_count: skippedCount,
+    avg_files_changed: truncateNumber(averageFilesChanged, 2),
+    avg_checkpoint_latency_ms: truncateNumber(average(checkpointLatencies), 1),
+    p95_checkpoint_latency_ms: truncateNumber(percentile(checkpointLatencies, 95), 1),
+    avg_validation_latency_ms: truncateNumber(average(validationLatencies), 1),
+    p95_validation_latency_ms: truncateNumber(percentile(validationLatencies, 95), 1),
+    avg_diff_capture_latency_ms: truncateNumber(average(diffCaptureLatencies), 1),
+    latest: normalizeLatestInteractiveMetric(parsed.latest),
+    execution_modes: executionModes,
+  };
+}
+
 function buildMergeHistogram14d(features: FeatureSummary[]): number[] {
   const days = 14;
   const buckets = new Array<number>(days).fill(0);
@@ -947,6 +1666,9 @@ export async function readFeatureDetail(
   if (!feature) {
     return null;
   }
+
+  const checkpointState = await readFeatureCheckpoints(featureId, repoRoot);
+
   return {
     feature,
     plan: await readFeaturePlan(featureId, repoRoot),
@@ -956,5 +1678,8 @@ export async function readFeatureDetail(
     cost: await readFeatureCost(featureId, repoRoot),
     qa_test_index: await readFeatureQaTestIndex(featureId, repoRoot),
     review_brief: await readFeatureReviewBrief(featureId, repoRoot),
+    log_entries: (await readDecisionLogEntries(featureId, repoRoot)).slice(0, 50),
+    execution_mode: checkpointState?.execution_mode ?? null,
+    checkpoints: checkpointState?.checkpoints ?? [],
   };
 }