agentic-orchestrator 0.1.27 → 0.2.0

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

@@ -1,40 +1,92 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import path from 'node:path';
 import YAML from 'yaml';
+import { buildCollisionRadar } from '@/lib/collision-radar.js';
 import { getProjectByName, readMultiProjectConfig } from '@/lib/multi-project-config.js';
-import { parseUnifiedDiff } from '@/lib/dashboard-utils.js';
+import { hasGateFailure, normalizeCiStatus, parseUnifiedDiff } from '@/lib/dashboard-utils.js';
+import {
+  buildActionableRisks,
+  buildPlanProgressSummary,
+  buildRevisionSummary,
+  buildVerificationSummary,
+  summarizeFeatureSpec,
+} from '@/lib/focus-detail-derivations.js';
+import {
+  buildFeatureIntakeWorkspace,
+  buildFeaturePlanningWorkspace,
+  buildPlannerLifecycleSummary,
+  normalizeAcceptedPlanRecord,
+  normalizeBootstrapManifestRecord,
+  normalizeIntakeReviewRecord,
+  normalizeVerifiedManifestRecord,
+} from '@/lib/planner-workspace.js';
+import { readPolicyYaml } from '@/lib/policy-reader.js';
+import { buildUsageBurnProjection } from '@/lib/usage-burn.js';
 import type {
   AgentLogEntry,
+  AgentRolePerformanceCardData,
+  AgentRolePerformanceMetric,
   AgentSessionCluster,
   AgentPipelineStatus,
+  CollisionRadarSnapshot,
   CostSummary,
   DashboardStatusPayload,
   EvidenceArtifact,
+  FeatureBudgetState,
+  FeatureCheckpointsPage,
   FeatureCheckpointComparison,
   FeatureCheckpointDiff,
   FeatureDetail,
+  FeatureFileIndex,
+  FeatureGenealogy,
+  FeatureGenealogyNode,
+  FeatureIntakeWorkspace,
   FeatureLog,
   FeatureLogEntry,
+  FeaturePlanningWorkspace,
+  FeatureQuestion,
+  FeatureRunHistoryDetail,
+  FeatureRunHistoryEntry,
+  FeatureSpecSummary,
   FeaturesIndex,
+  GateHistoryEntry,
   FeatureSummary,
+  FeatureTriageDetail,
   FeatureCheckpoint,
   FeatureExecutionMode,
+  FeatureIntakeReviewSummary,
+  FeatureIntakeSummary,
   GateRunEvidence,
   InteractiveExecutionModeMetrics,
   InteractivePerformanceLatestCheckpoint,
   InteractivePerformanceMetrics,
+  LiveAgentOutputSnapshot,
+  LiveAgentOutputStatusSnapshot,
   LockLease,
+  MergeQueueEntry,
+  MergeQueueSnapshot,
+  PlannerArtifactView,
+  PlannerLifecycleSummary,
+  RolePerformanceSummary,
   QaTestIndex,
   RawLogFileMeta,
   ReviewBrief,
   RoleStatus,
   RuntimeSession,
+  TokenCostConversion,
+  ProviderAnalytics,
   WorkerEventEntry,
+  WorkerEventSummary,
+  OrganizerStatusProjection,
 } from '@/lib/types.js';
 
 const AOP_ROOT = process.env.AOP_ROOT ?? process.cwd();
-const LOG_FILENAME_PATTERN = /^(planner|builder|qa)-(\d{13})\.txt$/;
+const LOG_FILENAME_PATTERN = /^(planner|builder|qa|reconciler)-(\d{13})\.txt$/;
 const CHECKPOINT_METRICS_HISTORY_LIMIT = 200;
+const TRACKED_AGENT_ROLES = ['planner', 'builder', 'qa', 'reconciler'] as const;
+export const DEFAULT_LIVE_AGENT_OUTPUT_LINE_LIMIT = 500;
+
+type TrackedAgentRole = (typeof TRACKED_AGENT_ROLES)[number];
 
 interface ParsedFrontMatter {
   frontMatter: Record<string, unknown>;
@@ -72,9 +124,11 @@ interface InteractiveMetricsFileShape {
 }
 
 const STATUS_TO_PHASE: Record<string, FeatureSummary['phase']> = {
+  intake: 'intake',
   planning: 'planning',
   building: 'building',
   qa: 'qa',
+  awaiting_input: 'awaiting_input',
   ready_to_merge: 'ready_to_merge',
   merged: 'merged',
   blocked: 'blocked',
@@ -83,11 +137,21 @@ const STATUS_TO_PHASE: Record<string, FeatureSummary['phase']> = {
 };
 
 const ACTIVE_PHASES = new Set<FeatureSummary['phase']>([
+  'intake',
   'planning',
   'building',
   'qa',
   'ready_to_merge',
 ]);
+const DEFAULT_BUDGET_ALERT_THRESHOLD = 0.8;
+const STALE_FEATURE_MS = 20 * 60_000;
+const RECENT_CHANGE_MS = 24 * 60_000 * 60;
+
+interface BudgetConfig {
+  per_feature_limit_tokens: number | null;
+  alert_threshold: number;
+  token_cost_conversion: TokenCostConversion | null;
+}
 
 function isActivityState(value: unknown): value is NonNullable<FeatureSummary['activity_state']> {
   return (
@@ -100,6 +164,331 @@ function isActivityState(value: unknown): value is NonNullable<FeatureSummary['a
   );
 }
 
+function parseBudgetConfig(policy: Record<string, unknown> | null): BudgetConfig {
+  const budget =
+    policy && typeof policy.budget === 'object' ? (policy.budget as Record<string, unknown>) : null;
+  const tokenCostConversion =
+    budget?.token_cost_conversion &&
+    typeof budget.token_cost_conversion === 'object' &&
+    typeof (budget.token_cost_conversion as Record<string, unknown>).usd_per_1k_tokens === 'number'
+      ? {
+          usd_per_1k_tokens: (budget.token_cost_conversion as Record<string, number>)
+            .usd_per_1k_tokens,
+        }
+      : null;
+
+  return {
+    per_feature_limit_tokens:
+      typeof budget?.per_feature_limit_tokens === 'number' ? budget.per_feature_limit_tokens : null,
+    alert_threshold:
+      typeof budget?.alert_threshold === 'number'
+        ? budget.alert_threshold
+        : DEFAULT_BUDGET_ALERT_THRESHOLD,
+    token_cost_conversion: tokenCostConversion,
+  };
+}
+
+interface LiveAgentOutputReadOptions {
+  tailLines?: number;
+}
+
+function tailTextByLines(content: string, lineLimit: number | undefined): string {
+  if (!lineLimit || lineLimit < 1 || content.length === 0) {
+    return content;
+  }
+  let newlineCount = 0;
+  let start = 0;
+  for (let index = content.length - 1; index >= 0; index -= 1) {
+    if (content.charCodeAt(index) !== 10) {
+      continue;
+    }
+    if (index === content.length - 1) {
+      continue;
+    }
+    newlineCount += 1;
+    if (newlineCount >= lineLimit) {
+      start = index + 1;
+      break;
+    }
+  }
+  return content.slice(start);
+}
+
+function deriveBudgetState(
+  tokensUsed: number | null,
+  budgetConfig: BudgetConfig,
+): FeatureBudgetState {
+  if (tokensUsed == null || budgetConfig.per_feature_limit_tokens == null) {
+    return 'unknown';
+  }
+  if (budgetConfig.per_feature_limit_tokens <= 0) {
+    return 'unknown';
+  }
+
+  const ratio = tokensUsed / budgetConfig.per_feature_limit_tokens;
+  if (ratio >= 1) {
+    return 'exceeded';
+  }
+  if (ratio >= 0.9) {
+    return 'critical';
+  }
+  if (ratio >= budgetConfig.alert_threshold) {
+    return 'warning';
+  }
+  return 'normal';
+}
+
+function deriveCostFromTokens(
+  tokensUsed: number | null,
+  tokenCostConversion: TokenCostConversion | null,
+): number | null {
+  if (tokensUsed == null || tokenCostConversion == null) {
+    return null;
+  }
+  return Number(((tokensUsed / 1000) * tokenCostConversion.usd_per_1k_tokens).toFixed(4));
+}
+
+function lastMeaningfulChange(frontMatter: Record<string, unknown>): string | undefined {
+  const recovery =
+    frontMatter.recovery && typeof frontMatter.recovery === 'object'
+      ? (frontMatter.recovery as Record<string, unknown>)
+      : null;
+  const candidates = [
+    recovery?.last_attempt_at,
+    frontMatter.last_meaningful_change_at,
+    frontMatter.activity_last_event_at,
+    frontMatter.last_updated,
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === 'string' && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+function isRecentChange(iso: string | undefined, nowMs = Date.now()): boolean {
+  if (!iso) {
+    return false;
+  }
+  const timestamp = Date.parse(iso);
+  if (Number.isNaN(timestamp) || timestamp > nowMs) {
+    return false;
+  }
+  return nowMs - timestamp <= RECENT_CHANGE_MS;
+}
+
+function isStalledFeature(feature: FeatureSummary, nowMs = Date.now()): boolean {
+  if (!ACTIVE_PHASES.has(feature.phase ?? 'unknown')) {
+    return false;
+  }
+  if (feature.activity_state === 'waiting_input' || feature.activity_state === 'blocked') {
+    return false;
+  }
+  const changeAt = feature.last_meaningful_change_at ?? feature.last_updated;
+  if (!changeAt) {
+    return false;
+  }
+  const timestamp = Date.parse(changeAt);
+  if (Number.isNaN(timestamp) || timestamp > nowMs) {
+    return false;
+  }
+  return nowMs - timestamp >= STALE_FEATURE_MS;
+}
+
+const STALE_RECOVERY_MS = 10 * 60 * 1000;
+
+function isRetryingRecovery(
+  feature: Pick<FeatureSummary, 'phase' | 'recovery' | 'status_reason' | 'activity_state'>,
+  nowMs = Date.now(),
+): boolean {
+  if (!feature.recovery || feature.recovery.state !== 'retrying') {
+    return false;
+  }
+  if (feature.phase === 'merged' || feature.phase === 'ready_to_merge') {
+    return false;
+  }
+  // If the feature is not actively running and the last recovery attempt was
+  // long ago, the recovery is stale — the reconciler or agent is no longer
+  // working on it.
+  if (feature.activity_state !== 'active' && feature.recovery.last_attempt_at) {
+    const lastAttempt = Date.parse(feature.recovery.last_attempt_at);
+    if (!Number.isNaN(lastAttempt) && nowMs - lastAttempt > STALE_RECOVERY_MS) {
+      return false;
+    }
+  }
+  const cause = feature.recovery.cause?.trim().toLowerCase();
+  if (!cause) {
+    return true;
+  }
+  if (feature.phase !== 'blocked') {
+    return true;
+  }
+  return feature.status_reason?.trim().toLowerCase().startsWith(`${cause}:`) ?? false;
+}
+
+function formatRecoveryStatusLabel(feature: Pick<FeatureSummary, 'recovery'>): string {
+  const role = feature.recovery?.role?.trim();
+  if (!role) {
+    return 'Recovering';
+  }
+  return `${role.charAt(0).toUpperCase()}${role.slice(1)} Retrying`;
+}
+
+function deriveClientStatusLabel(feature: FeatureSummary, dependencyBlocked: boolean): string {
+  if (feature.status === 'failed') {
+    return 'Failed';
+  }
+  // Plan collision — user must approve overlap before the feature can proceed
+  if (feature.collision) {
+    return 'Plan Collision';
+  }
+  // Blocked by mainline divergence — user may need to commit outstanding changes
+  if (
+    feature.status === 'blocked' &&
+    feature.recovery?.state === 'retrying' &&
+    feature.recovery.cause === 'mainline_divergence'
+  ) {
+    return 'Merge Conflict';
+  }
+  if (feature.phase === 'intake') {
+    return feature.intake_status === 'awaiting_input' ? 'Needs Input' : 'In Intake';
+  }
+  if (feature.phase === 'ready_to_merge') {
+    return 'Ready';
+  }
+  if (feature.phase === 'merged') {
+    return 'Merged';
+  }
+  if (feature.activity_state === 'waiting_input' || (feature.waiting_input_count ?? 0) > 0) {
+    return 'Needs Input';
+  }
+  if (dependencyBlocked) {
+    return 'Waiting On Dependencies';
+  }
+  if (isRetryingRecovery(feature)) {
+    return formatRecoveryStatusLabel(feature);
+  }
+  if (normalizeCiStatus(feature.pr?.ci_status) === 'pending') {
+    return 'Waiting On CI';
+  }
+  if (feature.phase === 'blocked') {
+    return 'Blocked';
+  }
+  if (
+    hasGateFailure(feature) ||
+    feature.budget_state === 'critical' ||
+    feature.budget_state === 'exceeded'
+  ) {
+    return 'At Risk';
+  }
+  if (isStalledFeature(feature)) {
+    return 'Stalled';
+  }
+  if (feature.activity_state === 'active') {
+    return 'In Progress';
+  }
+  if (feature.activity_state === 'idle') {
+    return 'Idle';
+  }
+  return feature.status.replace(/_/g, ' ');
+}
+
+function deriveAttentionReasons(
+  feature: FeatureSummary,
+  dependencyBlocked: boolean,
+  nowMs = Date.now(),
+): string[] {
+  const reasons: string[] = [];
+  const ciStatus = normalizeCiStatus(feature.pr?.ci_status);
+
+  if (feature.activity_state === 'waiting_input' || (feature.waiting_input_count ?? 0) > 0) {
+    reasons.push('Needs Me');
+  }
+  if (feature.phase === 'intake' && feature.activity_state === 'active') {
+    reasons.push('Requirements Intake');
+  }
+  if (isRetryingRecovery(feature)) {
+    reasons.push('Recovering');
+  }
+  if (feature.collision) {
+    reasons.push('Plan Collision');
+  }
+  if (
+    (feature.phase === 'blocked' && !isRetryingRecovery(feature)) ||
+    hasGateFailure(feature) ||
+    feature.budget_state === 'critical' ||
+    feature.budget_state === 'exceeded'
+  ) {
+    reasons.push('At Risk');
+  }
+  if (feature.phase === 'ready_to_merge') {
+    reasons.push('Ready');
+  }
+  if (isStalledFeature(feature, nowMs)) {
+    reasons.push('Stalled');
+  }
+  if (dependencyBlocked) {
+    reasons.push('Waiting On Dependencies');
+  }
+  if (ciStatus === 'pending') {
+    reasons.push('Waiting On CI');
+  }
+  if (isRecentChange(feature.last_meaningful_change_at, nowMs)) {
+    reasons.push('Recently Changed');
+  }
+  return reasons;
+}
+
+function enrichFeatureSummary(
+  feature: FeatureSummary,
+  options: {
+    cost: CostSummary | null;
+    budgetConfig: BudgetConfig;
+    dependencyBlocked: boolean;
+    nowMs?: number;
+  },
+): FeatureSummary {
+  const nowMs = options.nowMs ?? Date.now();
+  const usageTokens = options.cost?.tokens_used ?? null;
+  const budgetState = deriveBudgetState(usageTokens, options.budgetConfig);
+  const hasWaitingInputSignal =
+    feature.status === 'awaiting_input' ||
+    feature.phase === 'awaiting_input' ||
+    feature.activity_state === 'waiting_input' ||
+    feature.status_reason?.includes('waiting_input') ||
+    feature.status_reason?.includes('awaiting_input') ||
+    false;
+  const enriched: FeatureSummary = {
+    ...feature,
+    usage_tokens: usageTokens,
+    budget_state: budgetState,
+    waiting_input_count: hasWaitingInputSignal ? (feature.open_question_count ?? 1) : 0,
+    last_meaningful_change_at:
+      feature.last_meaningful_change_at ?? feature.activity_last_event_at ?? feature.last_updated,
+  };
+
+  enriched.attention_reasons = deriveAttentionReasons(enriched, options.dependencyBlocked, nowMs);
+  enriched.client_status_label = deriveClientStatusLabel(enriched, options.dependencyBlocked);
+  return enriched;
+}
+
+function summarizeBlocker(feature: FeatureSummary, dependencySummary: string[]): string | null {
+  if (dependencySummary.length > 0) {
+    return `Waiting on ${dependencySummary.join(', ')}`;
+  }
+  if (feature.status_reason && feature.status_reason.trim().length > 0) {
+    return feature.status_reason;
+  }
+  if (feature.phase === 'blocked') {
+    return 'Blocked and needs operator attention';
+  }
+  if (feature.activity_state === 'waiting_input') {
+    return 'Waiting on operator input';
+  }
+  return null;
+}
+
 function normalizeRoleStatus(value: unknown): RoleStatus {
   if (typeof value !== 'string') {
     return 'unknown';
@@ -169,7 +558,12 @@ function parseSessionCluster(frontMatter: Record<string, unknown>): AgentSession
 }
 
 function firstValidTimestamp(frontMatter: Record<string, unknown>): number | null {
+  const recovery =
+    frontMatter.recovery && typeof frontMatter.recovery === 'object'
+      ? (frontMatter.recovery as Record<string, unknown>)
+      : null;
   const candidates = [
+    recovery?.last_attempt_at,
     frontMatter.activity_last_event_at,
     frontMatter.last_heartbeat_at,
     frontMatter.last_updated,
@@ -190,12 +584,55 @@ function inferActivityState(
   frontMatter: Record<string, unknown>,
   phase: FeatureSummary['phase'],
 ): NonNullable<FeatureSummary['activity_state']> | undefined {
-  if (isActivityState(frontMatter.activity_state)) {
-    return frontMatter.activity_state;
+  const status = typeof frontMatter.status === 'string' ? frontMatter.status : '';
+  const statusReason =
+    typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason.toLowerCase() : '';
+  const persistedActivity = isActivityState(frontMatter.activity_state)
+    ? frontMatter.activity_state
+    : undefined;
+  if (persistedActivity === 'waiting_input') {
+    if (
+      status === 'awaiting_input' ||
+      phase === 'awaiting_input' ||
+      statusReason.startsWith('waiting_input') ||
+      statusReason.startsWith('question_awaiting_input') ||
+      statusReason.includes('awaiting_input')
+    ) {
+      return 'waiting_input';
+    }
+  } else if (persistedActivity) {
+    return persistedActivity;
+  }
+
+  if (status === 'awaiting_input' || phase === 'awaiting_input') {
+    return 'waiting_input';
+  }
+
+  if (
+    statusReason.startsWith('waiting_input') ||
+    statusReason.startsWith('question_awaiting_input')
+  ) {
+    return 'waiting_input';
   }
 
-  const status = typeof frontMatter.status === 'string' ? frontMatter.status : '';
   if (phase === 'blocked') {
+    const recovery =
+      frontMatter.recovery && typeof frontMatter.recovery === 'object'
+        ? (frontMatter.recovery as Record<string, unknown>)
+        : null;
+    const recoveryState = typeof recovery?.state === 'string' ? recovery.state : null;
+    const recoveryCause = typeof recovery?.cause === 'string' ? recovery.cause.toLowerCase() : null;
+    if (
+      recoveryState === 'retrying' &&
+      (!recoveryCause || statusReason.startsWith(`${recoveryCause}:`))
+    ) {
+      const timestamp = firstValidTimestamp(frontMatter);
+      if (timestamp == null) {
+        return 'blocked';
+      }
+      const ageMs = Date.now() - timestamp;
+      return ageMs >= 0 && ageMs <= 120_000 ? 'active' : 'blocked';
+    }
     return 'blocked';
   }
   if (phase === 'merged' || status === 'failed') {
@@ -239,12 +676,141 @@ function parseFrontMatter(raw: string): ParsedFrontMatter {
   return { frontMatter, body: normalized.slice(match[0].length) };
 }
 
+function normalizeIntakeStatus(value: unknown): FeatureIntakeSummary['status'] | null {
+  return value === 'not_started' ||
+    value === 'in_progress' ||
+    value === 'awaiting_input' ||
+    value === 'verified'
+    ? value
+    : null;
+}
+
+function normalizeWholeNumber(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value)
+    ? Math.max(0, Math.floor(value))
+    : null;
+}
+
+function normalizeFeatureRecoverySummary(
+  frontMatter: Record<string, unknown>,
+): FeatureSummary['recovery'] {
+  const raw = frontMatter.recovery;
+  if (!raw || typeof raw !== 'object') {
+    return null;
+  }
+  const recovery = raw as Record<string, unknown>;
+  const state =
+    recovery.state === 'retrying' || recovery.state === 'awaiting_operator' ? recovery.state : null;
+  if (!state) {
+    return null;
+  }
+  return {
+    state,
+    cause: typeof recovery.cause === 'string' ? recovery.cause : null,
+    role: typeof recovery.role === 'string' ? recovery.role : null,
+    resume_phase: typeof recovery.resume_phase === 'string' ? recovery.resume_phase : null,
+    attempt:
+      typeof recovery.attempt === 'number' && Number.isFinite(recovery.attempt)
+        ? Math.max(0, Math.floor(recovery.attempt))
+        : null,
+    run_id: typeof recovery.run_id === 'string' ? recovery.run_id : null,
+    started_at: typeof recovery.started_at === 'string' ? recovery.started_at : null,
+    last_attempt_at: typeof recovery.last_attempt_at === 'string' ? recovery.last_attempt_at : null,
+  };
+}
+
+function normalizeFeatureIntakeSummary(
+  frontMatter: Record<string, unknown>,
+): FeatureIntakeSummary | null {
+  const intake = asRecord(frontMatter.intake);
+  if (!intake) {
+    return null;
+  }
+  return {
+    status:
+      normalizeIntakeStatus(intake.status) ??
+      (frontMatter.status === 'awaiting_input' ? 'awaiting_input' : 'in_progress'),
+    bootstrap_manifest_version: normalizeWholeNumber(intake.bootstrap_manifest_version),
+    verified_manifest_version: normalizeWholeNumber(intake.verified_manifest_version),
+    open_ambiguity_count: normalizeWholeNumber(intake.open_ambiguity_count) ?? 0,
+    last_verified_at: typeof intake.last_verified_at === 'string' ? intake.last_verified_at : null,
+    promotion_basis: typeof intake.promotion_basis === 'string' ? intake.promotion_basis : null,
+  };
+}
+
+function normalizeMergeRepairSummary(frontMatter: Record<string, unknown>) {
+  const raw = asRecord(frontMatter.merge_repair);
+  if (!raw) {
+    return null;
+  }
+
+  const attempts = normalizeWholeNumber(raw.attempts) ?? 0;
+  const maxAttempts = Math.max(1, normalizeWholeNumber(raw.max_attempts) ?? 5);
+  const summary = {
+    attempts: Math.min(attempts, maxAttempts),
+    max_attempts: maxAttempts,
+    active: raw.active === true,
+    requested_at: typeof raw.requested_at === 'string' ? raw.requested_at : null,
+    last_failed_at: typeof raw.last_failed_at === 'string' ? raw.last_failed_at : null,
+    last_gate_evidence_path:
+      typeof raw.last_gate_evidence_path === 'string' ? raw.last_gate_evidence_path : null,
+    last_failure_summary:
+      typeof raw.last_failure_summary === 'string' ? raw.last_failure_summary : null,
+    reviewer_message: typeof raw.reviewer_message === 'string' ? raw.reviewer_message : null,
+    exhausted_at: typeof raw.exhausted_at === 'string' ? raw.exhausted_at : null,
+  };
+
+  if (
+    !summary.active &&
+    summary.attempts === 0 &&
+    summary.last_failed_at == null &&
+    summary.exhausted_at == null
+  ) {
+    return null;
+  }
+
+  return summary;
+}
+
+function normalizeIntakeReviewSummary(value: unknown): FeatureIntakeReviewSummary | null {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const ambiguities = Array.isArray(record.ambiguities) ? record.ambiguities : [];
+  return {
+    status: typeof record.status === 'string' ? record.status : null,
+    questions_open: normalizeWholeNumber(record.questions_open) ?? 0,
+    questions_resolved: normalizeWholeNumber(record.questions_resolved) ?? 0,
+    ambiguity_count: ambiguities.length,
+  };
+}
+
+function readQuestionAmbiguityId(details: Record<string, unknown>): string | null {
+  return typeof details.ambiguity_id === 'string' ? details.ambiguity_id : null;
+}
+
+function readQuestionObligationIds(details: Record<string, unknown>): string[] {
+  const raw = Array.isArray(details.obligation_ids) ? details.obligation_ids : [];
+  return raw.filter((item): item is string => typeof item === 'string');
+}
+
 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;
+  // Feature surfaces are interactive-only even when older state artifacts still
+  // record the legacy deterministic mode.
+  return value === 'interactive' || value === 'deterministic' ? 'interactive' : 'interactive';
+}
+
+function isIdleCheckpoint(checkpoint: FeatureCheckpoint): boolean {
+  return (
+    checkpoint.validation_status === 'skipped' &&
+    checkpoint.files_changed.length === 0 &&
+    checkpoint.net_new_worktree_change === false
+  );
 }
 
 function normalizeFeatureCheckpoints(frontMatter: Record<string, unknown>): FeatureCheckpoint[] {
@@ -286,6 +852,17 @@ function normalizeFeatureCheckpoints(frontMatter: Record<string, unknown>): Feat
       record.severity === 'critical'
         ? record.severity
         : undefined;
+    const headSha = typeof record.head_sha === 'string' ? record.head_sha.trim() : '';
+    const workspaceFingerprint =
+      typeof record.workspace_fingerprint === 'string' ? record.workspace_fingerprint.trim() : '';
+    const duplicateOfCheckpointId =
+      typeof record.duplicate_of_checkpoint_id === 'string'
+        ? record.duplicate_of_checkpoint_id.trim()
+        : '';
+    const netNewWorktreeChange =
+      typeof record.net_new_worktree_change === 'boolean'
+        ? record.net_new_worktree_change
+        : undefined;
     checkpoints.push({
       checkpoint_id: checkpointId,
       timestamp,
@@ -294,6 +871,10 @@ function normalizeFeatureCheckpoints(frontMatter: Record<string, unknown>): Feat
       violations,
       severity,
       diff_snapshot: diffSnapshot,
+      head_sha: headSha || undefined,
+      workspace_fingerprint: workspaceFingerprint || undefined,
+      duplicate_of_checkpoint_id: duplicateOfCheckpointId || undefined,
+      net_new_worktree_change: netNewWorktreeChange,
     });
   }
 
@@ -345,6 +926,19 @@ function truncateNumber(value: number | null, digits = 2): number | null {
   return Math.round(value * factor) / factor;
 }
 
+function averageNumber(values: number[]): number | null {
+  if (values.length === 0) {
+    return null;
+  }
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function uniqueSorted(values: string[]): string[] {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0))).sort(
+    (left, right) => left.localeCompare(right),
+  );
+}
+
 function resolveRepoRelativePath(repoRoot: string, relativePath: string): string | null {
   const resolved = path.resolve(repoRoot, relativePath);
   const normalizedRoot = path.resolve(repoRoot);
@@ -379,6 +973,145 @@ async function readJsonFile<T>(filePath: string): Promise<T | null> {
   }
 }
 
+function normalizeQuestionRecord(value: unknown): FeatureQuestion | null {
+  const record = asRecord(value);
+  if (!record) {
+    return null;
+  }
+  const questionId = typeof record.question_id === 'string' ? record.question_id : null;
+  const prompt = typeof record.prompt === 'string' ? record.prompt : null;
+  const status =
+    record.status === 'open' ||
+    record.status === 'answered' ||
+    record.status === 'expired' ||
+    record.status === 'withdrawn'
+      ? record.status
+      : null;
+  if (!questionId || !prompt || !status) {
+    return null;
+  }
+  return {
+    feature_id: typeof record.feature_id === 'string' ? record.feature_id : undefined,
+    question_id: questionId,
+    status,
+    blocking: record.blocking !== false,
+    question_type:
+      typeof record.question_type === 'string' ? record.question_type : 'clarification',
+    role: typeof record.role === 'string' ? record.role : 'unknown',
+    phase: typeof record.phase === 'string' ? record.phase : 'unknown',
+    request_action:
+      typeof record.request_action === 'string' ? record.request_action : 'ask_user_input',
+    session_id: typeof record.session_id === 'string' ? record.session_id : undefined,
+    prompt,
+    details: asRecord(record.details) ?? {},
+    expected_answer:
+      record.expected_answer && typeof record.expected_answer === 'object'
+        ? (record.expected_answer as FeatureQuestion['expected_answer'])
+        : null,
+    created_at:
+      typeof record.created_at === 'string' ? record.created_at : new Date().toISOString(),
+    expires_at: typeof record.expires_at === 'string' ? record.expires_at : null,
+    answer:
+      typeof record.answer === 'string' || (record.answer && typeof record.answer === 'object')
+        ? (record.answer as FeatureQuestion['answer'])
+        : null,
+    answered_at: typeof record.answered_at === 'string' ? record.answered_at : null,
+    answered_by: typeof record.answered_by === 'string' ? record.answered_by : null,
+    resume_status: typeof record.resume_status === 'string' ? record.resume_status : null,
+    resume_phase: typeof record.resume_phase === 'string' ? record.resume_phase : null,
+    ambiguity_id: readQuestionAmbiguityId(asRecord(record.details) ?? {}),
+    obligation_ids: readQuestionObligationIds(asRecord(record.details) ?? {}),
+    intake_context: null,
+  };
+}
+
+function enrichQuestionRecord(
+  question: FeatureQuestion,
+  feature: FeatureSummary | null,
+): FeatureQuestion {
+  return {
+    ...question,
+    feature_id: feature?.feature_id ?? question.feature_id,
+    intake_context:
+      feature?.intake_status != null
+        ? {
+            status: feature.intake_status,
+            bootstrap_manifest_version: feature.bootstrap_manifest_version ?? null,
+            verified_manifest_version: feature.verified_manifest_version ?? null,
+            open_ambiguity_count: feature.open_ambiguity_count ?? 0,
+            last_verified_at: feature.last_verified_at ?? null,
+            promotion_basis: feature.promotion_basis ?? null,
+          }
+        : null,
+  };
+}
+
+function isOperatorReadyQuestion(
+  feature: FeatureSummary | null,
+  question: FeatureQuestion,
+): boolean {
+  const baselineReady =
+    question.status === 'open' &&
+    question.blocking &&
+    feature?.status === 'awaiting_input' &&
+    feature.open_question_id === question.question_id;
+  if (!baselineReady) {
+    return false;
+  }
+  const resumesIntoIntake =
+    question.resume_status === 'intake' ||
+    question.resume_phase === 'intake' ||
+    question.phase === 'intake';
+  if (!resumesIntoIntake) {
+    return true;
+  }
+  return feature.resume_status === 'intake' && feature.intake_status === 'awaiting_input';
+}
+
+function selectOperatorReadyOpenQuestions(
+  feature: FeatureSummary | null,
+  questions: FeatureQuestion[],
+): FeatureQuestion[] {
+  return questions.filter((question) => isOperatorReadyQuestion(feature, question));
+}
+
+export async function readFeatureQuestions(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  feature: FeatureSummary | null = null,
+): Promise<FeatureQuestion[]> {
+  const questionsPath = path.join(getFeatureRoot(featureId, repoRoot), 'questions.json');
+  const parsed = await readJsonFile<Record<string, unknown>>(questionsPath);
+  if (!parsed || !Array.isArray(parsed.items)) {
+    return [];
+  }
+  return parsed.items
+    .map((item) => normalizeQuestionRecord(item))
+    .filter((item): item is FeatureQuestion => item !== null)
+    .map((item) => enrichQuestionRecord({ ...item, feature_id: featureId }, feature))
+    .sort((left, right) => left.created_at.localeCompare(right.created_at));
+}
+
+export async function readPendingQuestions(repoRoot = AOP_ROOT): Promise<FeatureQuestion[]> {
+  const index = await readFeaturesIndex(repoRoot);
+  const featureIds = new Set<string>([
+    ...(index.active ?? []),
+    ...(index.blocked ?? []),
+    ...(index.merged ?? []),
+    ...(index.blocked_queue ?? []).map((entry) => entry.feature_id),
+  ]);
+  const questions = await Promise.all(
+    [...featureIds]
+      .sort((a, b) => a.localeCompare(b))
+      .map(async (featureId) => {
+        const feature = await readFeatureState(featureId, repoRoot);
+        const items = await readFeatureQuestions(featureId, repoRoot, feature);
+        return selectOperatorReadyOpenQuestions(feature, items);
+      }),
+  );
+  return questions.flat();
+}
+
 function normalizeRuntimeSession(value: unknown): RuntimeSession | undefined {
   const record = asRecord(value);
   if (!record) {
@@ -459,19 +1192,55 @@ function normalizeDepBlocked(index: FeaturesIndex): Array<{
     );
 }
 
-function normalizeFeatureSummary(
+function resolveActiveCollision(
   featureId: string,
-  frontMatter: Record<string, unknown>,
   index: FeaturesIndex,
-  repoRoot = AOP_ROOT,
-): FeatureSummary {
-  const status = typeof frontMatter.status === 'string' ? frontMatter.status : 'unknown';
-  const blockedQueue = Array.isArray(index.blocked_queue)
-    ? index.blocked_queue.map((entry) => entry.feature_id)
-    : [];
-  const phase = index.merged?.includes(featureId)
-    ? 'merged'
-    : index.blocked?.includes(featureId) || blockedQueue.includes(featureId)
+): FeatureSummary['collision'] {
+  const records = Array.isArray(index.collision_records) ? index.collision_records : [];
+  // Find the LATEST collision record for this feature to check current state.
+  // Older records may still be 'rejected' while the latest is already resolved.
+  const featureRecords = records
+    .filter((r) => r.feature_id === featureId)
+    .sort((a, b) => (b.detected_at ?? '').localeCompare(a.detected_at ?? ''));
+  const latest = featureRecords[0];
+  if (!latest) {
+    return null;
+  }
+  // Only report a collision if the most recent record is still unresolved.
+  if (latest.resolution !== 'rejected' && latest.resolution !== 'blocked') {
+    return null;
+  }
+  const record = latest;
+  const withIds = Array.isArray(record.with_feature_ids) ? record.with_feature_ids : [];
+  const filePaths: string[] = [];
+  if (record.collisions?.files) {
+    for (const entry of record.collisions.files) {
+      if (Array.isArray(entry.paths)) {
+        filePaths.push(...entry.paths);
+      }
+    }
+  }
+  return {
+    with_feature_ids: withIds,
+    collision_fingerprint: record.collision_fingerprint ?? '',
+    file_paths: filePaths,
+    detected_at: record.detected_at ?? '',
+  };
+}
+
+function normalizeFeatureSummary(
+  featureId: string,
+  frontMatter: Record<string, unknown>,
+  index: FeaturesIndex,
+  repoRoot = AOP_ROOT,
+): FeatureSummary {
+  const status = typeof frontMatter.status === 'string' ? frontMatter.status : 'unknown';
+  const blockedQueue = Array.isArray(index.blocked_queue)
+    ? index.blocked_queue.map((entry) => entry.feature_id)
+    : [];
+  const phase = index.merged?.includes(featureId)
+    ? 'merged'
+    : index.blocked?.includes(featureId) || blockedQueue.includes(featureId)
       ? 'blocked'
       : (STATUS_TO_PHASE[status] ?? (index.active?.includes(featureId) ? 'planning' : 'unknown'));
   const branchRaw =
@@ -484,6 +1253,10 @@ function normalizeFeatureSummary(
   const gates =
     rawGates && typeof rawGates === 'object'
       ? {
+          plan:
+            typeof (rawGates as Record<string, unknown>).plan === 'string'
+              ? ((rawGates as Record<string, unknown>).plan as string)
+              : undefined,
           fast:
             typeof (rawGates as Record<string, unknown>).fast === 'string'
               ? ((rawGates as Record<string, unknown>).fast as string)
@@ -526,6 +1299,13 @@ function normalizeFeatureSummary(
       : typeof revisionOfRaw === 'string'
         ? Number.parseInt(revisionOfRaw, 10)
         : null;
+  const humanInput =
+    frontMatter.human_input && typeof frontMatter.human_input === 'object'
+      ? (frontMatter.human_input as Record<string, unknown>)
+      : null;
+  const intakeSummary = normalizeFeatureIntakeSummary(frontMatter);
+  const mergeRepairSummary = normalizeMergeRepairSummary(frontMatter);
+  const recovery = normalizeFeatureRecoverySummary(frontMatter);
   return {
     id: featureId,
     feature_id: featureId,
@@ -551,13 +1331,35 @@ function normalizeFeatureSummary(
         : path.join(repoRoot, '.worktrees', featureId),
     last_updated:
       typeof frontMatter.last_updated === 'string' ? frontMatter.last_updated : undefined,
+    phase_entered_at:
+      typeof frontMatter.phase_entered_at === 'string' ? frontMatter.phase_entered_at : undefined,
     status_reason:
       typeof frontMatter.status_reason === 'string' ? frontMatter.status_reason : undefined,
+    recovery,
     activity_state: inferActivityState(frontMatter, phase),
+    open_question_id:
+      typeof humanInput?.open_question_id === 'string' ? humanInput.open_question_id : null,
+    open_question_count:
+      typeof humanInput?.open_question_count === 'number'
+        ? humanInput.open_question_count
+        : undefined,
+    awaiting_since:
+      typeof humanInput?.awaiting_since === 'string' ? humanInput.awaiting_since : null,
+    requested_by_role:
+      typeof humanInput?.requested_by_role === 'string' ? humanInput.requested_by_role : null,
+    resume_status: typeof humanInput?.resume_status === 'string' ? humanInput.resume_status : null,
+    intake_status: intakeSummary?.status,
+    bootstrap_manifest_version: intakeSummary?.bootstrap_manifest_version ?? null,
+    verified_manifest_version: intakeSummary?.verified_manifest_version ?? null,
+    open_ambiguity_count: intakeSummary?.open_ambiguity_count ?? 0,
+    last_verified_at: intakeSummary?.last_verified_at ?? null,
+    promotion_basis: intakeSummary?.promotion_basis ?? null,
+    merge_repair: mergeRepairSummary,
     activity_last_event_at:
       typeof frontMatter.activity_last_event_at === 'string'
         ? frontMatter.activity_last_event_at
         : undefined,
+    last_meaningful_change_at: lastMeaningfulChange(frontMatter),
     activity_detected_via:
       typeof frontMatter.activity_detected_via === 'string'
         ? (frontMatter.activity_detected_via as FeatureSummary['activity_detected_via'])
@@ -566,6 +1368,7 @@ function normalizeFeatureSummary(
       frontMatter.pr && typeof frontMatter.pr === 'object'
         ? (frontMatter.pr as FeatureSummary['pr'])
         : null,
+    collision: resolveActiveCollision(featureId, index),
   };
 }
 
@@ -646,6 +1449,9 @@ export async function readFeaturesIndex(repoRoot = AOP_ROOT): Promise<FeaturesIn
     if (Array.isArray(parsed.dep_blocked)) {
       normalized.dep_blocked = parsed.dep_blocked as FeaturesIndex['dep_blocked'];
     }
+    if (Array.isArray(parsed.collision_records)) {
+      normalized.collision_records = parsed.collision_records as FeaturesIndex['collision_records'];
+    }
     const runtimeSessions = normalizeRuntimeSession(parsed.runtime_sessions);
     if (runtimeSessions) {
       normalized.runtime_sessions = runtimeSessions;
@@ -708,6 +1514,14 @@ export async function readFeaturePlan(
   }
 }
 
+export async function readFeatureIntakeReview(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureIntakeReviewSummary | null> {
+  const reviewPath = path.join(getFeatureRoot(featureId, repoRoot), 'intake.review.json');
+  return normalizeIntakeReviewSummary(await readJsonFile<Record<string, unknown>>(reviewPath));
+}
+
 export async function readFeatureCost(
   featureId: string,
   repoRoot = AOP_ROOT,
@@ -1091,7 +1905,7 @@ function parseStateLogBody(body: string): FeatureLogEntry[] {
 
   const entries: FeatureLogEntry[] = [];
   for (const line of lines) {
-    const parsed = line.match(/^\[(.+?)\]\s*(.+)$/);
+    const parsed = line.match(/^\[(.+?)]\s*(.+)$/);
     if (parsed) {
       entries.push({
         timestamp: parsed[1],
@@ -1128,7 +1942,7 @@ function parseDecisionEntries(raw: string): AgentLogEntry[] {
     if (trimmed.length === 0 || trimmed.startsWith('#')) {
       continue;
     }
-    const match = trimmed.match(/^-?\s*([0-9TZ:.-]{10,})\s+\[([^\]]+)\]\s+([\s\S]+)$/);
+    const match = trimmed.match(/^-?\s*([0-9TZ:.-]{10,})\s+\[([^\]]+)]\s+([\s\S]+)$/);
     if (match) {
       const timestampRaw = match[1];
       const actor = match[2].trim();
@@ -1217,7 +2031,9 @@ 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;
+  return value === 'planner' || value === 'builder' || value === 'qa' || value === 'reconciler'
+    ? value
+    : null;
 }
 
 export async function listRawLogFiles(
@@ -1282,6 +2098,65 @@ export async function readRawLogFile(
   }
 }
 
+function normalizeLiveAgentOutputStatus(value: unknown): LiveAgentOutputSnapshot['status'] {
+  return value === 'running' || value === 'completed' || value === 'failed' ? value : 'idle';
+}
+
+function normalizeExecutionMode(value: unknown): LiveAgentOutputSnapshot['execution_mode'] | null {
+  return value === 'interactive' || value === 'deterministic' ? value : null;
+}
+
+export async function readLiveAgentOutputSnapshots(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: LiveAgentOutputReadOptions = {},
+): Promise<LiveAgentOutputSnapshot[]> {
+  const liveDir = path.join(getFeatureRoot(featureId, repoRoot), 'logs', 'live');
+  return await Promise.all(
+    TRACKED_AGENT_ROLES.map(async (role) => {
+      const metadataPath = path.join(liveDir, `${role}.json`);
+      const contentPath = path.join(liveDir, `${role}.txt`);
+      const [metadataRaw, content, contentStat] = await Promise.all([
+        readFile(metadataPath, 'utf8').catch(() => null),
+        readFile(contentPath, 'utf8').catch(() => ''),
+        stat(contentPath).catch(() => null),
+      ]);
+
+      let metadata: Record<string, unknown> = {};
+      if (metadataRaw) {
+        try {
+          const parsed = JSON.parse(metadataRaw) as unknown;
+          if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            metadata = parsed as Record<string, unknown>;
+          }
+        } catch {
+          metadata = {};
+        }
+      }
+
+      return {
+        role,
+        session_id: typeof metadata.session_id === 'string' ? metadata.session_id : null,
+        provider: typeof metadata.provider === 'string' ? metadata.provider : null,
+        model: typeof metadata.model === 'string' ? metadata.model : null,
+        execution_mode: normalizeExecutionMode(metadata.execution_mode),
+        status: normalizeLiveAgentOutputStatus(metadata.status),
+        started_at: typeof metadata.started_at === 'string' ? metadata.started_at : null,
+        ended_at: typeof metadata.ended_at === 'string' ? metadata.ended_at : null,
+        updated_at: contentStat?.mtime.toISOString() ?? null,
+        size_bytes: contentStat?.size ?? 0,
+        content: tailTextByLines(content, options.tailLines),
+      } satisfies LiveAgentOutputSnapshot;
+    }),
+  );
+}
+
+function summarizeLiveAgentOutputSnapshots(
+  snapshots: LiveAgentOutputSnapshot[],
+): LiveAgentOutputStatusSnapshot[] {
+  return snapshots.map(({ content: _content, ...snapshot }) => snapshot);
+}
+
 interface WorkerTimelineReadOptions {
   role?: string | null;
   valid?: 'all' | 'valid' | 'invalid';
@@ -1536,7 +2411,7 @@ export async function readInteractivePerformanceMetrics(
   const averageFilesChanged = checkpointCount > 0 ? filesChangedTotal / checkpointCount : null;
 
   return {
-    updated_at: typeof parsed.updated_at === 'string' ? parsed.updated_at : null,
+    updated_at: parsed.updated_at,
     checkpoint_count: checkpointCount,
     valid_count: validCount,
     invalid_count: invalidCount,
@@ -1595,28 +2470,109 @@ async function readFlakySuspects(repoRoot = AOP_ROOT): Promise<string[]> {
   return [];
 }
 
+const ORGANIZER_STATUS_FALLBACK: OrganizerStatusProjection = {
+  available: false,
+  generated_at: null,
+  ready_set: [],
+  deferred_set: [],
+  blocked_set: [],
+};
+
+export async function readOrganizerStatus(
+  repoRoot = AOP_ROOT,
+  instanceId?: string | null,
+): Promise<OrganizerStatusProjection> {
+  if (!instanceId) {
+    return ORGANIZER_STATUS_FALLBACK;
+  }
+  const artifactPath = path.join(
+    repoRoot,
+    '.aop',
+    'runtime',
+    instanceId,
+    'organizer-ordering.json',
+  );
+  const parsed = await readJsonFile<Record<string, unknown>>(artifactPath);
+  if (!parsed) {
+    return ORGANIZER_STATUS_FALLBACK;
+  }
+  const generatedAt = typeof parsed.generated_at === 'string' ? parsed.generated_at : null;
+  const readySet = Array.isArray(parsed.ready_set)
+    ? parsed.ready_set.filter((item): item is string => typeof item === 'string')
+    : [];
+  const deferredSet = Array.isArray(parsed.deferred_set)
+    ? parsed.deferred_set.flatMap((item) => {
+        if (
+          item !== null &&
+          typeof item === 'object' &&
+          typeof (item as Record<string, unknown>).feature_id === 'string' &&
+          Array.isArray((item as Record<string, unknown>).blocked_by) &&
+          typeof (item as Record<string, unknown>).reason === 'string'
+        ) {
+          const entry = item as Record<string, unknown>;
+          return [
+            {
+              feature_id: entry.feature_id as string,
+              blocked_by: (entry.blocked_by as unknown[]).filter(
+                (b): b is string => typeof b === 'string',
+              ),
+              reason: entry.reason as string,
+            },
+          ];
+        }
+        return [];
+      })
+    : [];
+  const blockedSet = Array.isArray(parsed.blocked_set)
+    ? parsed.blocked_set.flatMap((item) => {
+        if (
+          item !== null &&
+          typeof item === 'object' &&
+          typeof (item as Record<string, unknown>).feature_id === 'string' &&
+          typeof (item as Record<string, unknown>).reason === 'string'
+        ) {
+          const entry = item as Record<string, unknown>;
+          return [{ feature_id: entry.feature_id as string, reason: entry.reason as string }];
+        }
+        return [];
+      })
+    : [];
+  return {
+    available: true,
+    generated_at: generatedAt,
+    ready_set: readySet,
+    deferred_set: deferredSet,
+    blocked_set: blockedSet,
+  };
+}
+
 export async function readDashboardStatus(repoRoot = AOP_ROOT): Promise<DashboardStatusPayload> {
   const index = await readFeaturesIndex(repoRoot);
+  const budgetConfig = parseBudgetConfig(await readPolicyYaml(repoRoot));
   const allFeatureIds = new Set<string>([
     ...(index.active ?? []),
     ...(index.blocked ?? []),
     ...(index.merged ?? []),
     ...(index.blocked_queue ?? []).map((entry) => entry.feature_id),
   ]);
+  const dependencyBlockedIds = new Set(normalizeDepBlocked(index).map((entry) => entry.feature_id));
 
   const features: FeatureSummary[] = [];
+  let totalTokens = 0;
   let totalCostUsd = 0;
+  const nowMs = Date.now();
   for (const featureId of [...allFeatureIds].sort((a, b) => a.localeCompare(b))) {
+    let feature: FeatureSummary;
     const statePath = path.join(getFeatureRoot(featureId, repoRoot), 'state.md');
     try {
       const raw = await readFile(statePath, 'utf-8');
       const { frontMatter } = parseFrontMatter(raw);
-      features.push(normalizeFeatureSummary(featureId, frontMatter, index, repoRoot));
+      feature = normalizeFeatureSummary(featureId, frontMatter, index, repoRoot);
     } catch {
       const blockedQueue = Array.isArray(index.blocked_queue)
         ? index.blocked_queue.map((entry) => entry.feature_id)
         : [];
-      features.push({
+      feature = {
         id: featureId,
         feature_id: featureId,
         status: index.merged?.includes(featureId)
@@ -1634,30 +2590,1412 @@ export async function readDashboardStatus(repoRoot = AOP_ROOT): Promise<Dashboar
         branch: null,
         worktree_path: null,
         pr: null,
-      });
+      };
     }
 
     const cost = await readFeatureCost(featureId, repoRoot);
+    const enriched = enrichFeatureSummary(feature, {
+      cost,
+      budgetConfig,
+      dependencyBlocked: dependencyBlockedIds.has(featureId),
+      nowMs,
+    });
+    features.push(enriched);
     if (cost) {
+      totalTokens += cost.tokens_used;
       totalCostUsd += cost.estimated_cost_usd;
     }
   }
 
   const depBlocked = normalizeDepBlocked(index);
+  const pendingQuestions = await readPendingQuestions(repoRoot);
   return {
     index,
     features,
+    pending_questions: {
+      count: pendingQuestions.length,
+      items: pendingQuestions.slice(0, 12),
+    },
     runtime: index.runtime_sessions,
     lock_map: normalizeLockMap(index),
     dep_blocked: depBlocked,
     flaky_suspects: await readFlakySuspects(repoRoot),
     metrics: {
-      total_cost_today_usd: Number(totalCostUsd.toFixed(4)),
+      total_tokens_today: totalTokens,
+      total_cost_today_usd:
+        budgetConfig.token_cost_conversion != null ? Number(totalCostUsd.toFixed(4)) : null,
       merge_histogram_14d: buildMergeHistogram14d(features),
     },
   };
 }
 
+export async function readFeatureTriage(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureTriageDetail | null> {
+  const index = await readFeaturesIndex(repoRoot);
+  const feature = await readFeatureState(featureId, repoRoot);
+  if (!feature) {
+    return null;
+  }
+
+  const budgetConfig = parseBudgetConfig(await readPolicyYaml(repoRoot));
+  const [cost, reviewBrief, intakeReview] = await Promise.all([
+    readFeatureCost(featureId, repoRoot),
+    readFeatureReviewBrief(featureId, repoRoot),
+    readFeatureIntakeReview(featureId, repoRoot),
+  ]);
+  const dependencySummary =
+    normalizeDepBlocked(index).find((entry) => entry.feature_id === featureId)
+      ?.depends_on_unresolved ?? [];
+  const enriched = enrichFeatureSummary(feature, {
+    cost,
+    budgetConfig,
+    dependencyBlocked: dependencySummary.length > 0,
+  });
+  const questions = await readFeatureQuestions(featureId, repoRoot, enriched);
+
+  return {
+    feature: enriched,
+    why_attention: enriched.attention_reasons ?? [],
+    blocker_summary: summarizeBlocker(enriched, dependencySummary),
+    open_questions: selectOperatorReadyOpenQuestions(enriched, questions),
+    dependency_summary: dependencySummary,
+    usage: {
+      tokens_used: cost?.tokens_used ?? null,
+      budget_limit_tokens: budgetConfig.per_feature_limit_tokens,
+      derived_cost_usd:
+        budgetConfig.token_cost_conversion != null
+          ? deriveCostFromTokens(cost?.tokens_used ?? null, budgetConfig.token_cost_conversion)
+          : null,
+      budget_state: enriched.budget_state,
+    },
+    intake:
+      enriched.intake_status != null
+        ? {
+            summary: {
+              status: enriched.intake_status,
+              bootstrap_manifest_version: enriched.bootstrap_manifest_version ?? null,
+              verified_manifest_version: enriched.verified_manifest_version ?? null,
+              open_ambiguity_count: enriched.open_ambiguity_count ?? 0,
+              last_verified_at: enriched.last_verified_at ?? null,
+              promotion_basis: enriched.promotion_basis ?? null,
+            },
+            review: intakeReview,
+          }
+        : null,
+    review_snapshot:
+      reviewBrief?.generated_at || enriched.pr
+        ? {
+            pr_url: enriched.pr?.url ?? null,
+            ci_status: enriched.pr?.ci_status ?? null,
+            review_decision: enriched.pr?.review_decision ?? null,
+            merge_ready: enriched.pr?.merge_ready ?? null,
+          }
+        : undefined,
+  };
+}
+
+function parsePlanFiles(plan: Record<string, unknown> | null): string[] {
+  if (!plan) {
+    return [];
+  }
+  if (Array.isArray(plan.files)) {
+    return uniqueSorted(plan.files.filter((item): item is string => typeof item === 'string'));
+  }
+  if (!plan.files || typeof plan.files !== 'object') {
+    return [];
+  }
+  const files = plan.files as Record<string, unknown>;
+  return uniqueSorted([
+    ...(Array.isArray(files.create)
+      ? files.create.filter((item): item is string => typeof item === 'string')
+      : []),
+    ...(Array.isArray(files.modify)
+      ? files.modify.filter((item): item is string => typeof item === 'string')
+      : []),
+    ...(Array.isArray(files.delete)
+      ? files.delete.filter((item): item is string => typeof item === 'string')
+      : []),
+  ]);
+}
+
+export async function readFeatureFiles(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureFileIndex | null> {
+  const feature = await readFeatureState(featureId, repoRoot);
+  if (!feature) {
+    return null;
+  }
+  const [plan, diff, checkpoints] = await Promise.all([
+    readFeaturePlan(featureId, repoRoot),
+    readFeatureDiff(featureId, repoRoot),
+    readFeatureCheckpoints(featureId, repoRoot),
+  ]);
+  const planFiles = parsePlanFiles(plan);
+  const diffFiles = uniqueSorted(parseUnifiedDiff(diff).map((file) => file.filePath));
+  const checkpointFiles = uniqueSorted(
+    (checkpoints?.checkpoints ?? []).flatMap((checkpoint) => checkpoint.files_changed),
+  );
+
+  return {
+    feature_id: featureId,
+    plan_files: planFiles,
+    diff_files: diffFiles,
+    checkpoint_files: checkpointFiles,
+    all_files: uniqueSorted([...planFiles, ...diffFiles, ...checkpointFiles]),
+  };
+}
+
+async function buildFeatureCollisionRadar(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<CollisionRadarSnapshot | null> {
+  const [currentFiles, index] = await Promise.all([
+    readFeatureFiles(featureId, repoRoot),
+    readFeaturesIndex(repoRoot),
+  ]);
+
+  if (!currentFiles) {
+    return null;
+  }
+
+  const competingFeatures = index.active.filter((otherFeatureId) => otherFeatureId !== featureId);
+
+  const competingFileMaps = await Promise.all(
+    competingFeatures.map(async (otherFeatureId) => {
+      const files = await readFeatureFiles(otherFeatureId, repoRoot);
+      return [otherFeatureId, files?.all_files ?? []] as const;
+    }),
+  );
+
+  return buildCollisionRadar(currentFiles.all_files, Object.fromEntries(competingFileMaps));
+}
+
+export async function readGateHistory(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<GateHistoryEntry[]> {
+  const evidenceDir = path.join(getFeatureRoot(featureId, repoRoot), 'evidence');
+  try {
+    const files = (await readdir(evidenceDir))
+      .filter(
+        (name) =>
+          /^gate-(fast|full|merge)-/.test(name) || /^latest-(fast|full|merge)\.json$/.test(name),
+      )
+      .sort((left, right) => left.localeCompare(right));
+    const history: GateHistoryEntry[] = [];
+    for (const file of files) {
+      const parsed = await readJsonFile<Record<string, unknown>>(path.join(evidenceDir, file));
+      if (!parsed) {
+        continue;
+      }
+      const steps = Array.isArray(parsed.step_results) ? parsed.step_results : [];
+      const stepTimestamps = steps
+        .map((step) => asRecord(step))
+        .flatMap((step) => [
+          typeof step?.started_at === 'string' ? Date.parse(step.started_at) : Number.NaN,
+          typeof step?.finished_at === 'string' ? Date.parse(step.finished_at) : Number.NaN,
+        ])
+        .filter((value): value is number => Number.isFinite(value));
+      const durationMs =
+        stepTimestamps.length >= 2
+          ? Math.max(...stepTimestamps) - Math.min(...stepTimestamps)
+          : null;
+      history.push({
+        id: `${featureId}:${file}`,
+        file,
+        mode: typeof parsed.mode === 'string' ? parsed.mode : 'unknown',
+        profile: typeof parsed.profile === 'string' ? parsed.profile : null,
+        overall: typeof parsed.overall === 'string' ? parsed.overall : 'unknown',
+        finished_at: typeof parsed.finished_at === 'string' ? parsed.finished_at : null,
+        step_count: steps.length,
+        failing_step_count: steps.filter((step) => {
+          const record = asRecord(step);
+          return typeof record?.exit_code === 'number' && record.exit_code !== 0;
+        }).length,
+        duration_ms: durationMs,
+        steps: steps.map((step) => {
+          const record = asRecord(step);
+          const outputTail = Array.isArray(record?.output_tail)
+            ? record.output_tail.filter((item): item is string => typeof item === 'string')
+            : [];
+          return {
+            name: typeof record?.name === 'string' ? record.name : 'unknown',
+            status:
+              record?.status === 'pass' || record?.status === 'fail' ? record.status : 'unknown',
+            output_tail: outputTail,
+          };
+        }),
+      });
+    }
+    return history.sort((left, right) => {
+      const leftMs = left.finished_at ? Date.parse(left.finished_at) : Number.NaN;
+      const rightMs = right.finished_at ? Date.parse(right.finished_at) : Number.NaN;
+      const safeLeft = Number.isNaN(leftMs) ? 0 : leftMs;
+      const safeRight = Number.isNaN(rightMs) ? 0 : rightMs;
+      return safeRight - safeLeft;
+    });
+  } catch {
+    return [];
+  }
+}
+
+export async function readFeatureGenealogy(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureGenealogy | null> {
+  const feature = await readFeatureState(featureId, repoRoot);
+  if (!feature) {
+    return null;
+  }
+  const [plan, checkpointState] = await Promise.all([
+    readFeaturePlan(featureId, repoRoot),
+    readFeatureCheckpoints(featureId, repoRoot),
+  ]);
+  const statePath = path.join(getFeatureRoot(featureId, repoRoot), 'state.md');
+  const runNodes: FeatureGenealogyNode[] = await (async () => {
+    try {
+      const raw = await readFile(statePath, 'utf8');
+      const frontMatter = parseFrontMatter(raw).frontMatter;
+      const runHistory = Array.isArray(frontMatter.run_history) ? frontMatter.run_history : [];
+      return runHistory
+        .map<FeatureGenealogyNode | null>((entry, index) => {
+          const record = asRecord(entry);
+          if (!record || typeof record.run_id !== 'string') {
+            return null;
+          }
+          const endedAt = typeof record.ended_at === 'string' ? record.ended_at : null;
+          const startedAt = typeof record.started_at === 'string' ? record.started_at : null;
+          return {
+            id: `${featureId}:run:${index}`,
+            label: record.run_id,
+            kind: 'run',
+            timestamp: endedAt ?? startedAt,
+            status: typeof record.status === 'string' ? record.status : null,
+          } satisfies FeatureGenealogyNode;
+        })
+        .filter((entry): entry is FeatureGenealogyNode => entry != null);
+    } catch {
+      return [];
+    }
+  })();
+
+  const planVersion =
+    typeof plan?.plan_version === 'number'
+      ? plan.plan_version
+      : typeof plan?.plan_version === 'string'
+        ? Number.parseInt(plan.plan_version, 10)
+        : (feature.plan_version ?? null);
+  const revisionOf =
+    typeof plan?.revision_of === 'number'
+      ? plan.revision_of
+      : typeof plan?.revision_of === 'string'
+        ? Number.parseInt(plan.revision_of, 10)
+        : (feature.revision_of ?? null);
+  const planNodes: FeatureGenealogyNode[] = [];
+  if (revisionOf != null && Number.isFinite(revisionOf)) {
+    for (let version = 1; version <= revisionOf; version += 1) {
+      planNodes.push({
+        id: `${featureId}:plan:${version}`,
+        label: `Plan v${version}`,
+        kind: 'plan_revision',
+        timestamp: null,
+        status: version === revisionOf ? 'ancestor' : null,
+      });
+    }
+  }
+  if (planVersion != null && Number.isFinite(planVersion)) {
+    planNodes.push({
+      id: `${featureId}:plan:${planVersion}`,
+      label: `Plan v${planVersion}`,
+      kind: 'plan_revision',
+      timestamp: null,
+      status: feature.status,
+      note: feature.revision_reason ?? null,
+    });
+  }
+
+  const checkpointNodes = (checkpointState?.checkpoints ?? []).slice(0, 10).map((checkpoint) => ({
+    id: checkpoint.checkpoint_id,
+    label: checkpoint.checkpoint_id,
+    kind: 'checkpoint',
+    timestamp: checkpoint.timestamp,
+    status: checkpoint.validation_status,
+    note: checkpoint.severity ?? null,
+  })) satisfies FeatureGenealogyNode[];
+
+  return {
+    feature_id: featureId,
+    nodes: [
+      {
+        id: featureId,
+        label: featureId,
+        kind: 'feature',
+        timestamp: feature.last_updated ?? null,
+        status: feature.status,
+      },
+      ...planNodes,
+      ...checkpointNodes,
+      ...runNodes,
+    ],
+  };
+}
+
+function summarizeRolePerformance(
+  entries: WorkerEventEntry[],
+  role: string,
+): RolePerformanceSummary {
+  const matching = entries.filter((entry) => entry.role === role);
+  const elapsedValues = matching
+    .map((entry) => entry.elapsed_ms)
+    .filter((value): value is number => typeof value === 'number' && Number.isFinite(value));
+  const requestValues = matching
+    .map((entry) => entry.request_count)
+    .filter((value): value is number => Number.isFinite(value));
+  const providers = uniqueSorted(matching.map((entry) => entry.provider));
+  const models = uniqueSorted(matching.map((entry) => entry.model));
+  const lastEventAt = matching.length > 0 ? (matching[0]?.ts ?? null) : null;
+  return {
+    role,
+    total_events: matching.length,
+    valid_events: matching.filter((entry) => entry.valid).length,
+    invalid_events: matching.filter((entry) => !entry.valid).length,
+    avg_elapsed_ms: truncateNumber(averageNumber(elapsedValues), 1),
+    avg_requests: truncateNumber(averageNumber(requestValues), 2),
+    last_event_at: lastEventAt,
+    providers,
+    models,
+  };
+}
+
+function sumRoleMetric(
+  entries: WorkerEventEntry[],
+  selector: (entry: WorkerEventEntry) => number | undefined,
+): number {
+  return entries.reduce((sum, entry) => {
+    const value = selector(entry);
+    return typeof value === 'number' && Number.isFinite(value) ? sum + value : sum;
+  }, 0);
+}
+
+function selectPrimaryProviderModel(entries: WorkerEventEntry[]): {
+  provider: string | null;
+  model: string | null;
+} {
+  const aggregate = new Map<
+    string,
+    { provider: string; model: string; count: number; latest_ts: number }
+  >();
+
+  for (const entry of entries) {
+    const key = `${entry.provider}:${entry.model}`;
+    const existing = aggregate.get(key) ?? {
+      provider: entry.provider,
+      model: entry.model,
+      count: 0,
+      latest_ts: Number.NaN,
+    };
+    existing.count += 1;
+    const timestamp = Date.parse(entry.ts);
+    if (
+      !Number.isNaN(timestamp) &&
+      (Number.isNaN(existing.latest_ts) || timestamp > existing.latest_ts)
+    ) {
+      existing.latest_ts = timestamp;
+    }
+    aggregate.set(key, existing);
+  }
+
+  const selected = Array.from(aggregate.values()).sort((left, right) => {
+    if (right.count !== left.count) {
+      return right.count - left.count;
+    }
+    const leftTs = Number.isNaN(left.latest_ts) ? Number.NEGATIVE_INFINITY : left.latest_ts;
+    const rightTs = Number.isNaN(right.latest_ts) ? Number.NEGATIVE_INFINITY : right.latest_ts;
+    if (rightTs !== leftTs) {
+      return rightTs - leftTs;
+    }
+    return `${left.provider}/${left.model}`.localeCompare(`${right.provider}/${right.model}`);
+  })[0];
+
+  return selected
+    ? { provider: selected.provider, model: selected.model }
+    : { provider: null, model: null };
+}
+
+function createPerformanceMetric(
+  actual: number | null,
+  baselineAverage: number | null,
+  averageDigits = 1,
+): AgentRolePerformanceMetric {
+  const safeAverage = baselineAverage != null && baselineAverage > 0 ? baselineAverage : null;
+  return {
+    actual,
+    average: truncateNumber(baselineAverage, averageDigits),
+    ratio: actual != null && safeAverage != null ? truncateNumber(actual / safeAverage, 2) : null,
+  };
+}
+
+function summarizePerformanceCard(
+  metrics: AgentRolePerformanceCardData['metrics'],
+  sampleSize: number,
+): string {
+  if (sampleSize === 0) {
+    return 'Historical baseline unavailable for this provider and model.';
+  }
+
+  const comparableRatios = [
+    metrics.elapsed_ms.ratio,
+    metrics.request_count.ratio,
+    metrics.patch_count.ratio,
+    metrics.plan_submission_count.ratio,
+  ].filter((value): value is number => typeof value === 'number' && Number.isFinite(value));
+
+  if (comparableRatios.length === 0) {
+    return 'Historical baseline unavailable for this provider and model.';
+  }
+
+  if (
+    typeof metrics.elapsed_ms.ratio === 'number' &&
+    metrics.elapsed_ms.ratio > 1.5 &&
+    typeof metrics.request_count.ratio === 'number' &&
+    metrics.request_count.ratio > 1.5
+  ) {
+    return 'Running slower and making more requests than average.';
+  }
+
+  if (comparableRatios.some((value) => value > 2.5)) {
+    return 'Well above historical average.';
+  }
+
+  if (comparableRatios.some((value) => value > 1.5)) {
+    return 'Above historical average.';
+  }
+
+  if (comparableRatios.every((value) => value >= 0.75 && value <= 1.25)) {
+    return 'On track.';
+  }
+
+  if (comparableRatios.some((value) => value < 0.75)) {
+    return 'Ahead of historical average.';
+  }
+
+  return 'Mixed versus historical average.';
+}
+
+function computeHistoricalRoleMetricAverages(
+  entries: WorkerEventEntry[],
+  currentFeatureId: string,
+  role: TrackedAgentRole,
+  provider: string | null,
+  model: string | null,
+): {
+  sample_size: number;
+  elapsed_ms: number | null;
+  request_count: number | null;
+  patch_count: number | null;
+  plan_submission_count: number | null;
+} {
+  if (!provider || !model) {
+    return {
+      sample_size: 0,
+      elapsed_ms: null,
+      request_count: null,
+      patch_count: null,
+      plan_submission_count: null,
+    };
+  }
+
+  const perFeature = new Map<
+    string,
+    {
+      elapsed_ms: number;
+      request_count: number;
+      patch_count: number;
+      plan_submission_count: number;
+    }
+  >();
+
+  for (const entry of entries) {
+    if (
+      entry.role !== role ||
+      entry.provider !== provider ||
+      entry.model !== model ||
+      !entry.feature_id ||
+      entry.feature_id === currentFeatureId
+    ) {
+      continue;
+    }
+    const existing = perFeature.get(entry.feature_id) ?? {
+      elapsed_ms: 0,
+      request_count: 0,
+      patch_count: 0,
+      plan_submission_count: 0,
+    };
+    existing.elapsed_ms +=
+      typeof entry.elapsed_ms === 'number' && Number.isFinite(entry.elapsed_ms)
+        ? entry.elapsed_ms
+        : 0;
+    existing.request_count += Number.isFinite(entry.request_count) ? entry.request_count : 0;
+    existing.patch_count += Number.isFinite(entry.patch_count) ? entry.patch_count : 0;
+    existing.plan_submission_count += Number.isFinite(entry.plan_submission_count)
+      ? entry.plan_submission_count
+      : 0;
+    perFeature.set(entry.feature_id, existing);
+  }
+
+  const totals = Array.from(perFeature.values());
+  return {
+    sample_size: totals.length,
+    elapsed_ms: averageNumber(totals.map((item) => item.elapsed_ms)),
+    request_count: averageNumber(totals.map((item) => item.request_count)),
+    patch_count: averageNumber(totals.map((item) => item.patch_count)),
+    plan_submission_count: averageNumber(totals.map((item) => item.plan_submission_count)),
+  };
+}
+
+async function buildFeatureRolePerformanceCards(
+  feature: FeatureSummary,
+  repoRoot = AOP_ROOT,
+): Promise<AgentRolePerformanceCardData[]> {
+  const [featureEvents, allEvents] = await Promise.all([
+    readWorkerTimelineEntries(feature.feature_id, repoRoot, { limit: 200 }),
+    readAllWorkerEvents(repoRoot),
+  ]);
+
+  return TRACKED_AGENT_ROLES.flatMap((role) => {
+    const roleStatusMap = feature.role_status as unknown as Record<string, string> | undefined;
+    const roleStatus = roleStatusMap?.[role] ?? 'unknown';
+    if (roleStatus === 'ready' || roleStatus === 'unknown') {
+      return [];
+    }
+
+    const currentEntries = featureEvents.filter((entry) => entry.role === role);
+    const currentProviderModel = selectPrimaryProviderModel(currentEntries);
+    const historical = computeHistoricalRoleMetricAverages(
+      allEvents,
+      feature.feature_id,
+      role,
+      currentProviderModel.provider,
+      currentProviderModel.model,
+    );
+    const metrics = {
+      elapsed_ms: createPerformanceMetric(
+        currentEntries.length > 0 ? sumRoleMetric(currentEntries, (entry) => entry.elapsed_ms) : 0,
+        historical.elapsed_ms,
+        1,
+      ),
+      request_count: createPerformanceMetric(
+        currentEntries.length > 0
+          ? sumRoleMetric(currentEntries, (entry) => entry.request_count)
+          : 0,
+        historical.request_count,
+        1,
+      ),
+      patch_count: createPerformanceMetric(
+        currentEntries.length > 0 ? sumRoleMetric(currentEntries, (entry) => entry.patch_count) : 0,
+        historical.patch_count,
+        1,
+      ),
+      plan_submission_count: createPerformanceMetric(
+        currentEntries.length > 0
+          ? sumRoleMetric(currentEntries, (entry) => entry.plan_submission_count)
+          : 0,
+        historical.plan_submission_count,
+        1,
+      ),
+    };
+
+    return [
+      {
+        role,
+        role_status: roleStatus as 'ready' | 'running' | 'blocked' | 'done' | 'unknown',
+        provider: currentProviderModel.provider,
+        model: currentProviderModel.model,
+        total_events: currentEntries.length,
+        sample_size: historical.sample_size,
+        summary:
+          currentEntries.length === 0
+            ? 'No worker-event telemetry has been recorded yet.'
+            : summarizePerformanceCard(metrics, historical.sample_size),
+        metrics,
+      },
+    ];
+  });
+}
+
+export async function readFeatureWorkerEventSummary(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: WorkerTimelineReadOptions = {},
+): Promise<WorkerEventSummary> {
+  const entries = await readWorkerTimelineEntries(featureId, repoRoot, options);
+  const roles = uniqueSorted(entries.map((entry) => entry.role));
+  return {
+    entries,
+    by_role: roles.map((role) => summarizeRolePerformance(entries, role)),
+  };
+}
+
+export async function readMergeQueueSnapshot(
+  featureId?: string,
+  repoRoot = AOP_ROOT,
+): Promise<MergeQueueSnapshot> {
+  const payload = await readDashboardStatus(repoRoot);
+  const dependencyMap = new Map(
+    (payload.dep_blocked ?? []).map((entry) => [entry.feature_id, entry.depends_on_unresolved]),
+  );
+  const reverseDependencyMap = new Map<string, string[]>();
+  for (const [blockedFeatureId, blockers] of dependencyMap.entries()) {
+    for (const blocker of blockers) {
+      const existing = reverseDependencyMap.get(blocker) ?? [];
+      existing.push(blockedFeatureId);
+      reverseDependencyMap.set(blocker, existing);
+    }
+  }
+  const queueFeatures = payload.features
+    .filter((feature) => feature.phase === 'ready_to_merge')
+    .sort((left, right) => {
+      const leftMs = left.phase_entered_at ? Date.parse(left.phase_entered_at) : Number.NaN;
+      const rightMs = right.phase_entered_at ? Date.parse(right.phase_entered_at) : Number.NaN;
+      const safeLeft = Number.isNaN(leftMs) ? Number.MAX_SAFE_INTEGER : leftMs;
+      const safeRight = Number.isNaN(rightMs) ? Number.MAX_SAFE_INTEGER : rightMs;
+      if (safeLeft === safeRight) {
+        return left.feature_id.localeCompare(right.feature_id);
+      }
+      return safeLeft - safeRight;
+    });
+
+  const queue = queueFeatures.map((feature, index) => ({
+    feature_id: feature.feature_id,
+    position: index + 1,
+    total: queueFeatures.length,
+    status: feature.status,
+    phase_entered_at: feature.phase_entered_at ?? null,
+    merge_ready: feature.pr?.merge_ready === true,
+    ci_status: feature.pr?.ci_status ?? null,
+    pending_review_threads: feature.pr?.pending_review_threads ?? 0,
+    has_conflicts: feature.pr?.has_conflicts === true,
+    merge_score: feature.pr?.merge_score ?? null,
+    blocked_by: dependencyMap.get(feature.feature_id) ?? [],
+    blocks: reverseDependencyMap.get(feature.feature_id) ?? [],
+    estimated_merge_at:
+      index === 0 ? null : new Date(Date.now() + index * 15 * 60_000).toISOString(),
+    lock_holder: false,
+  })) satisfies MergeQueueEntry[];
+
+  return {
+    queue,
+    current_feature: featureId
+      ? (queue.find((entry) => entry.feature_id === featureId) ?? null)
+      : null,
+  };
+}
+
+export async function readProviderAnalyticsSnapshot(
+  repoRoot = AOP_ROOT,
+): Promise<ProviderAnalytics[]> {
+  const payload = await readDashboardStatus(repoRoot);
+  const allEvents = await readAllWorkerEvents(repoRoot);
+  const featureCost = new Map<string, number>();
+  for (const feature of payload.features) {
+    if (typeof feature.usage_tokens === 'number' && Number.isFinite(feature.usage_tokens)) {
+      featureCost.set(feature.feature_id, feature.usage_tokens);
+    }
+  }
+
+  const aggregate = new Map<
+    string,
+    {
+      provider: string;
+      model: string;
+      total_features: Set<string>;
+      token_features: Set<string>;
+      success_count: number;
+      retry_count_total: number;
+      duration_total: number;
+      duration_count: number;
+      token_total: number;
+    }
+  >();
+
+  for (const entry of allEvents) {
+    const key = `${entry.provider}:${entry.model}`;
+    const existing = aggregate.get(key) ?? {
+      provider: entry.provider,
+      model: entry.model,
+      total_features: new Set<string>(),
+      token_features: new Set<string>(),
+      success_count: 0,
+      retry_count_total: 0,
+      duration_total: 0,
+      duration_count: 0,
+      token_total: 0,
+    };
+    if (entry.feature_id) {
+      existing.total_features.add(entry.feature_id);
+      if (!existing.token_features.has(entry.feature_id)) {
+        existing.token_total += featureCost.get(entry.feature_id) ?? 0;
+        existing.token_features.add(entry.feature_id);
+      }
+    }
+    if (entry.valid) {
+      existing.success_count += 1;
+    }
+    existing.retry_count_total += Math.max(0, entry.request_count - 1);
+    if (typeof entry.elapsed_ms === 'number' && Number.isFinite(entry.elapsed_ms)) {
+      existing.duration_total += entry.elapsed_ms;
+      existing.duration_count += 1;
+    }
+    aggregate.set(key, existing);
+  }
+
+  return Array.from(aggregate.values())
+    .map((entry) => {
+      const totalFeatures = entry.total_features.size;
+      const avgDuration =
+        entry.duration_count > 0 ? entry.duration_total / entry.duration_count : 0;
+      const avgRetry = totalFeatures > 0 ? entry.retry_count_total / totalFeatures : 0;
+      return {
+        provider: entry.provider,
+        model: entry.model,
+        total_features: totalFeatures,
+        success_count: entry.success_count,
+        success_rate: totalFeatures > 0 ? entry.success_count / totalFeatures : 0,
+        avg_retry_count: truncateNumber(avgRetry, 2) ?? 0,
+        avg_duration_ms: truncateNumber(avgDuration, 1) ?? 0,
+        avg_tokens_used:
+          totalFeatures > 0 ? (truncateNumber(entry.token_total / totalFeatures, 1) ?? 0) : 0,
+        avg_cost_usd: 0,
+      } satisfies ProviderAnalytics;
+    })
+    .sort(
+      (left, right) =>
+        right.total_features - left.total_features || left.provider.localeCompare(right.provider),
+    );
+}
+
+function resolveUsageBaseline(
+  entries: WorkerEventEntry[],
+  providers: ProviderAnalytics[],
+): ProviderAnalytics | null {
+  const currentProviderModel = selectPrimaryProviderModel(entries);
+  if (!currentProviderModel.provider || !currentProviderModel.model) {
+    return null;
+  }
+  return (
+    providers.find(
+      (provider) =>
+        provider.provider === currentProviderModel.provider &&
+        provider.model === currentProviderModel.model,
+    ) ?? null
+  );
+}
+
+function normalizeRepoRelativePath(repoRoot: string, targetPath: string): string {
+  return path.relative(repoRoot, targetPath).replaceAll('\\', '/');
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function specFilePath(featureId: string, repoRoot = AOP_ROOT): string {
+  return path.join(getFeatureRoot(featureId, repoRoot), 'spec.md');
+}
+
+function bootstrapManifestPath(featureId: string, repoRoot = AOP_ROOT): string {
+  return path.join(getFeatureRoot(featureId, repoRoot), 'spec.manifest.bootstrap.json');
+}
+
+function verifiedManifestPath(featureId: string, repoRoot = AOP_ROOT): string {
+  return path.join(getFeatureRoot(featureId, repoRoot), 'spec.manifest.verified.json');
+}
+
+function intakeReviewPath(featureId: string, repoRoot = AOP_ROOT): string {
+  return path.join(getFeatureRoot(featureId, repoRoot), 'intake.review.json');
+}
+
+function planMarkdownPath(featureId: string, repoRoot = AOP_ROOT): string {
+  return path.join(getFeatureRoot(featureId, repoRoot), 'plan.md');
+}
+
+export type PlannerArtifactId = PlannerArtifactView['id'];
+
+function plannerArtifactPath(
+  featureId: string,
+  artifactId: PlannerArtifactId,
+  repoRoot = AOP_ROOT,
+): string {
+  if (artifactId === 'source_spec') {
+    return specFilePath(featureId, repoRoot);
+  }
+  if (artifactId === 'bootstrap_manifest') {
+    return bootstrapManifestPath(featureId, repoRoot);
+  }
+  if (artifactId === 'verified_manifest') {
+    return verifiedManifestPath(featureId, repoRoot);
+  }
+  if (artifactId === 'intake_review') {
+    return intakeReviewPath(featureId, repoRoot);
+  }
+  if (artifactId === 'plan_markdown') {
+    return planMarkdownPath(featureId, repoRoot);
+  }
+  return path.join(getFeatureRoot(featureId, repoRoot), 'plan.json');
+}
+
+async function readTextArtifact(
+  filePath: string,
+): Promise<{ raw: string; updatedAt: string | null } | null> {
+  try {
+    const [raw, fileStats] = await Promise.all([readFile(filePath, 'utf8'), stat(filePath)]);
+    return {
+      raw,
+      updatedAt: fileStats.mtime.toISOString(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function readJsonArtifact(
+  filePath: string,
+): Promise<{ parsed: Record<string, unknown>; raw: string; updatedAt: string | null } | null> {
+  const artifact = await readTextArtifact(filePath);
+  if (!artifact) {
+    return null;
+  }
+  try {
+    return {
+      parsed: JSON.parse(artifact.raw) as Record<string, unknown>,
+      raw: artifact.raw,
+      updatedAt: artifact.updatedAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function buildPlannerArtifactView(input: {
+  id: PlannerArtifactId;
+  label: PlannerArtifactView['label'];
+  format: PlannerArtifactView['format'];
+  repoRoot: string;
+  featureId: string;
+  path: string;
+  version: number | null;
+  updatedAt: string | null;
+  rawContent: string | null;
+  primary: boolean;
+  authorityLabel: string | null;
+  emptyState: string;
+}): PlannerArtifactView {
+  return {
+    id: input.id,
+    label: input.label,
+    format: input.format,
+    path: normalizeRepoRelativePath(input.repoRoot, input.path),
+    version: input.version,
+    updated_at: input.updatedAt,
+    raw_content: input.rawContent,
+    primary: input.primary,
+    authority_label: input.authorityLabel,
+    empty_state: input.emptyState,
+  };
+}
+
+export async function readPlannerArtifactRaw(
+  featureId: string,
+  artifactId: PlannerArtifactId,
+  repoRoot = AOP_ROOT,
+): Promise<{ content: string; path: string } | null> {
+  const absolutePath = plannerArtifactPath(featureId, artifactId, repoRoot);
+  const artifact = await readTextArtifact(absolutePath);
+  if (!artifact) {
+    return null;
+  }
+  return {
+    content: artifact.raw,
+    path: absolutePath,
+  };
+}
+
+function sortCheckpointsDescending(checkpoints: FeatureCheckpoint[]): FeatureCheckpoint[] {
+  return [...checkpoints].sort((left, right) => {
+    const leftMs = Date.parse(left.timestamp);
+    const rightMs = Date.parse(right.timestamp);
+    return (Number.isNaN(rightMs) ? 0 : rightMs) - (Number.isNaN(leftMs) ? 0 : leftMs);
+  });
+}
+
+function timestampInWindow(
+  timestamp: string | null | undefined,
+  startedAt: string,
+  endedAt: string | null,
+): boolean {
+  if (typeof timestamp !== 'string') {
+    return false;
+  }
+  const valueMs = Date.parse(timestamp);
+  const startedMs = Date.parse(startedAt);
+  const endedMs = endedAt ? Date.parse(endedAt) : Number.POSITIVE_INFINITY;
+  if (Number.isNaN(valueMs) || Number.isNaN(startedMs)) {
+    return false;
+  }
+  return (
+    valueMs >= startedMs && valueMs <= (Number.isNaN(endedMs) ? Number.POSITIVE_INFINITY : endedMs)
+  );
+}
+
+function parseRunHistory(frontMatter: Record<string, unknown>): Array<{
+  run_id: string;
+  started_at: string;
+  ended_at: string | null;
+  status: FeatureRunHistoryEntry['status'];
+}> {
+  const rawHistory = Array.isArray(frontMatter.run_history) ? frontMatter.run_history : [];
+  return rawHistory
+    .map((entry) => {
+      const record = asRecord(entry);
+      if (!record || typeof record.run_id !== 'string' || typeof record.started_at !== 'string') {
+        return null;
+      }
+      const rawStatus = record.status;
+      const status =
+        rawStatus === 'active' ||
+        rawStatus === 'completed' ||
+        rawStatus === 'failed' ||
+        rawStatus === 'timeout' ||
+        rawStatus === 'interrupted'
+          ? rawStatus
+          : 'interrupted';
+      return {
+        run_id: record.run_id,
+        started_at: record.started_at,
+        ended_at: typeof record.ended_at === 'string' ? record.ended_at : null,
+        status,
+      };
+    })
+    .filter(
+      (
+        entry,
+      ): entry is {
+        run_id: string;
+        started_at: string;
+        ended_at: string | null;
+        status: FeatureRunHistoryEntry['status'];
+      } => entry != null,
+    )
+    .sort((left, right) => Date.parse(right.started_at) - Date.parse(left.started_at));
+}
+
+export async function readFeatureSpec(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: { includeMarkdown?: boolean } = {},
+): Promise<FeatureSpecSummary | null> {
+  const includeMarkdown = options.includeMarkdown ?? true;
+  const fullPath = specFilePath(featureId, repoRoot);
+  try {
+    const [stats, markdown] = await Promise.all([
+      stat(fullPath),
+      includeMarkdown ? readFile(fullPath, 'utf8') : Promise.resolve(null),
+    ]);
+    return summarizeFeatureSpec(
+      normalizeRepoRelativePath(repoRoot, fullPath),
+      markdown,
+      stats.mtime.toISOString(),
+    );
+  } catch {
+    return null;
+  }
+}
+
+export async function readPlannerLifecycle(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<PlannerLifecycleSummary | null> {
+  const [feature, bootstrapArtifact, verifiedArtifact, plan, questions, specArtifact] =
+    await Promise.all([
+      readFeatureState(featureId, repoRoot),
+      readJsonArtifact(bootstrapManifestPath(featureId, repoRoot)),
+      readJsonArtifact(verifiedManifestPath(featureId, repoRoot)),
+      readFeaturePlan(featureId, repoRoot),
+      readFeatureQuestions(featureId, repoRoot),
+      readTextArtifact(specFilePath(featureId, repoRoot)),
+    ]);
+  if (!feature) {
+    return null;
+  }
+  return buildPlannerLifecycleSummary({
+    feature,
+    intakeSummary:
+      feature.intake_status != null
+        ? {
+            status: feature.intake_status,
+            bootstrap_manifest_version: feature.bootstrap_manifest_version ?? null,
+            verified_manifest_version: feature.verified_manifest_version ?? null,
+            open_ambiguity_count: feature.open_ambiguity_count ?? 0,
+            last_verified_at: feature.last_verified_at ?? null,
+            promotion_basis: feature.promotion_basis ?? null,
+          }
+        : null,
+    hasSpec: specArtifact != null,
+    bootstrapManifest: normalizeBootstrapManifestRecord(bootstrapArtifact?.parsed ?? null),
+    verifiedManifest: normalizeVerifiedManifestRecord(verifiedArtifact?.parsed ?? null),
+    acceptedPlan: normalizeAcceptedPlanRecord(plan),
+    questions,
+  });
+}
+
+export async function readFeatureIntakeWorkspace(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureIntakeWorkspace | null> {
+  const [feature, bootstrapArtifact, verifiedArtifact, intakeReviewArtifact, spec, questions] =
+    await Promise.all([
+      readFeatureState(featureId, repoRoot),
+      readJsonArtifact(bootstrapManifestPath(featureId, repoRoot)),
+      readJsonArtifact(verifiedManifestPath(featureId, repoRoot)),
+      readJsonArtifact(intakeReviewPath(featureId, repoRoot)),
+      readFeatureSpec(featureId, repoRoot, { includeMarkdown: true }),
+      readFeatureQuestions(featureId, repoRoot),
+    ]);
+  if (!feature) {
+    return null;
+  }
+
+  const intakeSummary: FeatureIntakeSummary | null =
+    feature.intake_status != null
+      ? {
+          status: feature.intake_status,
+          bootstrap_manifest_version: feature.bootstrap_manifest_version ?? null,
+          verified_manifest_version: feature.verified_manifest_version ?? null,
+          open_ambiguity_count: feature.open_ambiguity_count ?? 0,
+          last_verified_at: feature.last_verified_at ?? null,
+          promotion_basis: feature.promotion_basis ?? null,
+        }
+      : null;
+  const intakeReview = normalizeIntakeReviewRecord(intakeReviewArtifact?.parsed ?? null);
+  const intakeReviewSummary: FeatureIntakeReviewSummary | null = intakeReview
+    ? {
+        status: intakeReview.status,
+        questions_open: intakeReview.questions_open,
+        questions_resolved: intakeReview.questions_resolved,
+        ambiguity_count: intakeReview.ambiguities.length,
+      }
+    : null;
+  const bootstrapManifest = normalizeBootstrapManifestRecord(bootstrapArtifact?.parsed ?? null);
+  const verifiedManifest = normalizeVerifiedManifestRecord(verifiedArtifact?.parsed ?? null);
+  const artifacts: PlannerArtifactView[] = [
+    buildPlannerArtifactView({
+      id: 'source_spec',
+      label: 'Source Spec',
+      format: 'markdown',
+      repoRoot,
+      featureId,
+      path: specFilePath(featureId, repoRoot),
+      version: null,
+      updatedAt: spec?.last_updated ?? null,
+      rawContent: spec?.markdown ?? null,
+      primary: verifiedManifest == null,
+      authorityLabel: verifiedManifest == null ? 'Primary input' : 'Reference input',
+      emptyState: 'No source spec is available for this feature.',
+    }),
+    buildPlannerArtifactView({
+      id: 'bootstrap_manifest',
+      label: 'Bootstrap Manifest',
+      format: 'json',
+      repoRoot,
+      featureId,
+      path: bootstrapManifestPath(featureId, repoRoot),
+      version: bootstrapManifest?.manifest_version ?? null,
+      updatedAt: bootstrapArtifact?.updatedAt ?? null,
+      rawContent:
+        bootstrapArtifact?.parsed != null
+          ? JSON.stringify(bootstrapArtifact.parsed, null, 2)
+          : null,
+      primary: verifiedManifest == null,
+      authorityLabel:
+        verifiedManifest == null ? 'Current intake contract' : 'Original intake proposal',
+      emptyState: 'Bootstrap manifest has not been generated yet.',
+    }),
+    buildPlannerArtifactView({
+      id: 'verified_manifest',
+      label: 'Verified Manifest',
+      format: 'json',
+      repoRoot,
+      featureId,
+      path: verifiedManifestPath(featureId, repoRoot),
+      version: verifiedManifest?.manifest_version ?? null,
+      updatedAt: verifiedArtifact?.updatedAt ?? null,
+      rawContent:
+        verifiedArtifact?.parsed != null ? JSON.stringify(verifiedArtifact.parsed, null, 2) : null,
+      primary: verifiedManifest != null,
+      authorityLabel: verifiedManifest != null ? 'Contract of record' : 'Pending verification',
+      emptyState: 'Verified manifest has not been promoted yet.',
+    }),
+    buildPlannerArtifactView({
+      id: 'intake_review',
+      label: 'Intake Review',
+      format: 'json',
+      repoRoot,
+      featureId,
+      path: intakeReviewPath(featureId, repoRoot),
+      version: intakeReview?.version ?? null,
+      updatedAt: intakeReviewArtifact?.updatedAt ?? intakeReview?.last_updated_at ?? null,
+      rawContent:
+        intakeReviewArtifact?.parsed != null
+          ? JSON.stringify(intakeReviewArtifact.parsed, null, 2)
+          : null,
+      primary: false,
+      authorityLabel: 'Review record',
+      emptyState: 'No intake review artifact has been recorded yet.',
+    }),
+  ];
+
+  return buildFeatureIntakeWorkspace({
+    feature,
+    intakeSummary,
+    intakeReviewSummary,
+    bootstrapManifest,
+    verifiedManifest,
+    intakeReview,
+    questions,
+    artifacts,
+  });
+}
+
+export async function readFeaturePlanningWorkspace(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeaturePlanningWorkspace | null> {
+  const [feature, verifiedArtifact, planArtifact, planMarkdownArtifact, questions] =
+    await Promise.all([
+      readFeatureState(featureId, repoRoot),
+      readJsonArtifact(verifiedManifestPath(featureId, repoRoot)),
+      readJsonArtifact(plannerArtifactPath(featureId, 'plan_json', repoRoot)),
+      readTextArtifact(planMarkdownPath(featureId, repoRoot)),
+      readFeatureQuestions(featureId, repoRoot),
+    ]);
+  if (!feature) {
+    return null;
+  }
+  const intakeSummary: FeatureIntakeSummary | null =
+    feature.intake_status != null
+      ? {
+          status: feature.intake_status,
+          bootstrap_manifest_version: feature.bootstrap_manifest_version ?? null,
+          verified_manifest_version: feature.verified_manifest_version ?? null,
+          open_ambiguity_count: feature.open_ambiguity_count ?? 0,
+          last_verified_at: feature.last_verified_at ?? null,
+          promotion_basis: feature.promotion_basis ?? null,
+        }
+      : null;
+  const verifiedManifest = normalizeVerifiedManifestRecord(verifiedArtifact?.parsed ?? null);
+  const acceptedPlan = normalizeAcceptedPlanRecord(planArtifact?.parsed ?? null);
+  const artifacts: PlannerArtifactView[] = [
+    buildPlannerArtifactView({
+      id: 'verified_manifest',
+      label: 'Verified Manifest',
+      format: 'json',
+      repoRoot,
+      featureId,
+      path: verifiedManifestPath(featureId, repoRoot),
+      version: verifiedManifest?.manifest_version ?? null,
+      updatedAt: verifiedArtifact?.updatedAt ?? null,
+      rawContent:
+        verifiedArtifact?.parsed != null ? JSON.stringify(verifiedArtifact.parsed, null, 2) : null,
+      primary: true,
+      authorityLabel: 'Contract of record',
+      emptyState: 'Verified manifest has not been promoted yet.',
+    }),
+    buildPlannerArtifactView({
+      id: 'plan_markdown',
+      label: 'Plan Markdown',
+      format: 'markdown',
+      repoRoot,
+      featureId,
+      path: planMarkdownPath(featureId, repoRoot),
+      version: acceptedPlan?.plan_version ?? null,
+      updatedAt: planMarkdownArtifact?.updatedAt ?? null,
+      rawContent: planMarkdownArtifact?.raw ?? null,
+      primary: acceptedPlan != null,
+      authorityLabel: acceptedPlan != null ? 'Planner baseline' : 'Planning scratchpad',
+      emptyState: 'No plan markdown has been recorded yet.',
+    }),
+    buildPlannerArtifactView({
+      id: 'plan_json',
+      label: 'Plan JSON',
+      format: 'json',
+      repoRoot,
+      featureId,
+      path: plannerArtifactPath(featureId, 'plan_json', repoRoot),
+      version: acceptedPlan?.plan_version ?? null,
+      updatedAt: planArtifact?.updatedAt ?? null,
+      rawContent:
+        planArtifact?.parsed != null ? JSON.stringify(planArtifact.parsed, null, 2) : null,
+      primary: acceptedPlan != null,
+      authorityLabel: acceptedPlan != null ? 'Accepted execution contract' : 'No accepted plan yet',
+      emptyState: 'No accepted execution plan has been submitted yet.',
+    }),
+  ];
+
+  return buildFeaturePlanningWorkspace({
+    feature,
+    intakeSummary,
+    verifiedManifest,
+    acceptedPlan,
+    plannerQuestions: questions,
+    artifacts,
+  });
+}
+
+export async function readFeaturePlanProgress(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureDetail['plan_progress']> {
+  const [feature, plan, checkpointState, gateEvidence, qaTestIndex] = await Promise.all([
+    readFeatureState(featureId, repoRoot),
+    readFeaturePlan(featureId, repoRoot),
+    readFeatureCheckpoints(featureId, repoRoot),
+    readLatestGateEvidence(featureId, repoRoot),
+    readFeatureQaTestIndex(featureId, repoRoot),
+  ]);
+  if (!feature) {
+    return null;
+  }
+  return buildPlanProgressSummary({
+    feature,
+    plan,
+    checkpoints: sortCheckpointsDescending(checkpointState?.checkpoints ?? []),
+    gateEvidence,
+    qaTestIndex,
+  });
+}
+
+export async function readFeatureCheckpointsPage(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+  options: { cursor?: string | null; limit?: number; includeIdle?: boolean } = {},
+): Promise<FeatureCheckpointsPage | null> {
+  const checkpointState = await readFeatureCheckpoints(featureId, repoRoot);
+  if (!checkpointState) {
+    return null;
+  }
+  const checkpoints = sortCheckpointsDescending(checkpointState.checkpoints);
+  const visibleCheckpoints =
+    options.includeIdle === false
+      ? checkpoints.filter((checkpoint) => !isIdleCheckpoint(checkpoint))
+      : checkpoints;
+  const limit = Math.min(Math.max(options.limit ?? 20, 1), 100);
+  const parsedCursor = Number.parseInt(options.cursor ?? '0', 10);
+  const offset = Number.isNaN(parsedCursor) ? 0 : Math.max(0, parsedCursor);
+  const items = visibleCheckpoints.slice(offset, offset + limit);
+  return {
+    items,
+    total_count: visibleCheckpoints.length,
+    suppressed_count: checkpoints.length - visibleCheckpoints.length,
+    cursor: String(offset),
+    next_cursor: offset + limit < visibleCheckpoints.length ? String(offset + limit) : null,
+    prev_cursor: offset > 0 ? String(Math.max(0, offset - limit)) : null,
+    limit,
+  };
+}
+
+export async function readFeatureRunHistory(
+  featureId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureRunHistoryEntry[]> {
+  const [featureState, evidence, checkpointState, rawLogs] = await Promise.all([
+    readFile(path.join(getFeatureRoot(featureId, repoRoot), 'state.md'), 'utf8').catch(() => null),
+    listEvidenceArtifacts(featureId, repoRoot),
+    readFeatureCheckpoints(featureId, repoRoot),
+    listRawLogFiles(featureId, repoRoot, { limit: 200 }),
+  ]);
+  if (!featureState) {
+    return [];
+  }
+  const frontMatter = parseFrontMatter(featureState).frontMatter;
+  const runHistory = parseRunHistory(frontMatter);
+  return Promise.all(
+    runHistory.map(async (run) => {
+      const evidenceCount = evidence.filter((artifact) =>
+        timestampInWindow(artifact.updated_at, run.started_at, run.ended_at),
+      ).length;
+      const checkpointCount = (checkpointState?.checkpoints ?? []).filter((checkpoint) =>
+        timestampInWindow(checkpoint.timestamp, run.started_at, run.ended_at),
+      ).length;
+      const rawLogCount = rawLogs.filter((log) =>
+        timestampInWindow(log.timestamp, run.started_at, run.ended_at),
+      ).length;
+      const hasEvents = await pathExists(
+        path.join(repoRoot, '.aop', 'runtime', 'worker-events', `${run.run_id}.jsonl`),
+      );
+      const hasOperations = await pathExists(
+        path.join(repoRoot, '.aop', 'runtime', 'operation-ledger', `${run.run_id}.json`),
+      );
+      return {
+        ...run,
+        evidence_count: evidenceCount,
+        checkpoint_count: checkpointCount,
+        raw_log_count: rawLogCount,
+        has_events: hasEvents,
+        has_operations: hasOperations,
+      } satisfies FeatureRunHistoryEntry;
+    }),
+  );
+}
+
+export async function readFeatureRunHistoryDetail(
+  featureId: string,
+  runId: string,
+  repoRoot = AOP_ROOT,
+): Promise<FeatureRunHistoryDetail | null> {
+  const [runs, evidence, checkpointState, rawLogs, feature, plan, gateHistory] = await Promise.all([
+    readFeatureRunHistory(featureId, repoRoot),
+    listEvidenceArtifacts(featureId, repoRoot),
+    readFeatureCheckpoints(featureId, repoRoot),
+    listRawLogFiles(featureId, repoRoot, { limit: 200 }),
+    readFeatureState(featureId, repoRoot),
+    readFeaturePlan(featureId, repoRoot),
+    readGateHistory(featureId, repoRoot),
+  ]);
+  const run = runs.find((entry) => entry.run_id === runId);
+  if (!run || !feature) {
+    return null;
+  }
+  const revisionEvents = buildRevisionSummary({
+    feature,
+    plan,
+    checkpoints: sortCheckpointsDescending(checkpointState?.checkpoints ?? []),
+    gateHistory,
+  }).filter((entry) => timestampInWindow(entry.timestamp, run.started_at, run.ended_at));
+  return {
+    run,
+    evidence: evidence.filter((artifact) =>
+      timestampInWindow(artifact.updated_at, run.started_at, run.ended_at),
+    ),
+    checkpoints: sortCheckpointsDescending(
+      (checkpointState?.checkpoints ?? []).filter((checkpoint) =>
+        timestampInWindow(checkpoint.timestamp, run.started_at, run.ended_at),
+      ),
+    ),
+    raw_logs: rawLogs.filter((log) =>
+      timestampInWindow(log.timestamp, run.started_at, run.ended_at),
+    ),
+    revision_events: revisionEvents,
+  };
+}
+
 export async function readFeatureDetail(
   featureId: string,
   repoRoot = AOP_ROOT,
@@ -1668,18 +4006,128 @@ export async function readFeatureDetail(
   }
 
   const checkpointState = await readFeatureCheckpoints(featureId, repoRoot);
+  const budgetConfig = parseBudgetConfig(await readPolicyYaml(repoRoot));
+  const cost = await readFeatureCost(featureId, repoRoot);
+  const enrichedFeature = enrichFeatureSummary(feature, {
+    cost,
+    budgetConfig,
+    dependencyBlocked: false,
+  });
+
+  const [
+    plan,
+    diff,
+    evidence,
+    gateEvidence,
+    qaTestIndex,
+    reviewBrief,
+    logEntries,
+    collisionRadar,
+    rolePerformance,
+    workerSummary,
+    liveOutputSnapshots,
+    genealogy,
+    gateHistory,
+    mergeQueue,
+    providerAnalytics,
+    spec,
+    intakeReview,
+  ] = await Promise.all([
+    readFeaturePlan(featureId, repoRoot),
+    readFeatureDiff(featureId, repoRoot),
+    listEvidenceArtifacts(featureId, repoRoot),
+    readLatestGateEvidence(featureId, repoRoot),
+    readFeatureQaTestIndex(featureId, repoRoot),
+    readFeatureReviewBrief(featureId, repoRoot),
+    readDecisionLogEntries(featureId, repoRoot),
+    buildFeatureCollisionRadar(featureId, repoRoot),
+    buildFeatureRolePerformanceCards(enrichedFeature, repoRoot),
+    readFeatureWorkerEventSummary(featureId, repoRoot, { limit: 200 }),
+    readLiveAgentOutputSnapshots(featureId, repoRoot),
+    readFeatureGenealogy(featureId, repoRoot),
+    readGateHistory(featureId, repoRoot),
+    readMergeQueueSnapshot(featureId, repoRoot),
+    readProviderAnalyticsSnapshot(repoRoot),
+    readFeatureSpec(featureId, repoRoot, { includeMarkdown: false }),
+    readFeatureIntakeReview(featureId, repoRoot),
+  ]);
+  const questions = await readFeatureQuestions(featureId, repoRoot, enrichedFeature);
+
+  const usageBurn = buildUsageBurnProjection(
+    cost,
+    workerSummary.entries,
+    resolveUsageBaseline(workerSummary.entries, providerAnalytics),
+    budgetConfig.per_feature_limit_tokens,
+    budgetConfig.token_cost_conversion,
+    enrichedFeature.phase ?? 'unknown',
+  );
+  const checkpoints = sortCheckpointsDescending(checkpointState?.checkpoints ?? []);
+  const planProgress = buildPlanProgressSummary({
+    feature: enrichedFeature,
+    plan,
+    checkpoints,
+    gateEvidence,
+    qaTestIndex,
+  });
+  const verificationSummary = buildVerificationSummary({
+    feature: enrichedFeature,
+    gateEvidence,
+    qaTestIndex,
+    usageBurn,
+  });
+  const revisionSummary = buildRevisionSummary({
+    feature: enrichedFeature,
+    plan,
+    checkpoints,
+    gateHistory,
+  });
+  const actionableRisks = buildActionableRisks(plan, enrichedFeature);
 
   return {
-    feature,
-    plan: await readFeaturePlan(featureId, repoRoot),
-    diff: await readFeatureDiff(featureId, repoRoot),
-    evidence: await listEvidenceArtifacts(featureId, repoRoot),
-    gate_evidence: await readLatestGateEvidence(featureId, repoRoot),
-    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 ?? [],
+    feature: enrichedFeature,
+    plan,
+    diff,
+    evidence,
+    spec,
+    plan_progress: planProgress,
+    verification_summary: verificationSummary,
+    revision_summary: revisionSummary,
+    actionable_risks: actionableRisks,
+    gate_evidence: gateEvidence,
+    cost,
+    budget_limit_tokens: budgetConfig.per_feature_limit_tokens,
+    qa_test_index: qaTestIndex,
+    review_brief: reviewBrief,
+    log_entries: logEntries.slice(0, 50),
+    execution_mode: checkpointState?.execution_mode ?? 'interactive',
+    checkpoints,
+    collision_radar: collisionRadar,
+    role_performance: rolePerformance,
+    usage_burn: usageBurn,
+    genealogy,
+    gate_history: gateHistory,
+    merge_queue: mergeQueue,
+    worker_summary: workerSummary,
+    live_output_snapshots: summarizeLiveAgentOutputSnapshots(liveOutputSnapshots),
+    provider_analytics: providerAnalytics,
+    token_cost_conversion: budgetConfig.token_cost_conversion,
+    questions: questions.filter(
+      (question) =>
+        question.status !== 'open' || isOperatorReadyQuestion(enrichedFeature, question),
+    ),
+    intake:
+      enrichedFeature.intake_status != null
+        ? {
+            summary: {
+              status: enrichedFeature.intake_status,
+              bootstrap_manifest_version: enrichedFeature.bootstrap_manifest_version ?? null,
+              verified_manifest_version: enrichedFeature.verified_manifest_version ?? null,
+              open_ambiguity_count: enrichedFeature.open_ambiguity_count ?? 0,
+              last_verified_at: enrichedFeature.last_verified_at ?? null,
+              promotion_basis: enrichedFeature.promotion_basis ?? null,
+            },
+            review: intakeReview,
+          }
+        : null,
   };
 }