agentic-orchestrator 0.1.28 → 0.2.0

package/packages/web-dashboard/src/lib/types.ts

@@ -35,6 +35,45 @@ export interface WorkerEventEntry {
   run_id?: string;
 }
 
+export interface RolePerformanceSummary {
+  role: string;
+  total_events: number;
+  valid_events: number;
+  invalid_events: number;
+  avg_elapsed_ms: number | null;
+  avg_requests: number | null;
+  last_event_at: string | null;
+  providers: string[];
+  models: string[];
+}
+
+export interface AgentRolePerformanceMetric {
+  actual: number | null;
+  average: number | null;
+  ratio: number | null;
+}
+
+export interface AgentRolePerformanceCardData {
+  role: 'planner' | 'builder' | 'qa' | 'reconciler';
+  role_status: RoleStatus;
+  provider: string | null;
+  model: string | null;
+  total_events: number;
+  sample_size: number;
+  summary: string;
+  metrics: {
+    elapsed_ms: AgentRolePerformanceMetric;
+    request_count: AgentRolePerformanceMetric;
+    patch_count: AgentRolePerformanceMetric;
+    plan_submission_count: AgentRolePerformanceMetric;
+  };
+}
+
+export interface WorkerEventSummary {
+  entries: WorkerEventEntry[];
+  by_role: RolePerformanceSummary[];
+}
+
 export type FeatureExecutionMode = 'deterministic' | 'interactive';
 
 export interface FeatureCheckpoint {
@@ -45,6 +84,10 @@ export interface FeatureCheckpoint {
   violations: string[];
   severity?: 'info' | 'warning' | 'error' | 'critical';
   diff_snapshot: string;
+  head_sha?: string;
+  workspace_fingerprint?: string;
+  duplicate_of_checkpoint_id?: string;
+  net_new_worktree_change?: boolean;
 }
 
 export interface FeatureCheckpointDiff {
@@ -128,16 +171,111 @@ export interface FileDiffPayload {
 
 export interface RawLogFileMeta {
   filename: string;
-  role: 'planner' | 'builder' | 'qa';
+  role: 'planner' | 'builder' | 'qa' | 'reconciler';
   timestamp: string;
   size_bytes: number;
 }
 
+export interface LiveAgentOutputSnapshot {
+  role: 'planner' | 'builder' | 'qa' | 'reconciler';
+  session_id: string | null;
+  provider: string | null;
+  model: string | null;
+  execution_mode: 'interactive' | 'deterministic' | null;
+  status: 'idle' | 'running' | 'completed' | 'failed';
+  started_at: string | null;
+  ended_at: string | null;
+  updated_at: string | null;
+  size_bytes: number;
+  content: string;
+}
+
+export type LiveAgentOutputStatusSnapshot = Omit<LiveAgentOutputSnapshot, 'content'>;
+
+export type UsageAvailability = 'reported' | 'estimated' | 'unavailable';
+
+export interface RoleUsageBreakdown {
+  role: string;
+  provider: string;
+  model: string;
+  status: UsageAvailability;
+  input_tokens: number | null;
+  output_tokens: number | null;
+  total_tokens: number | null;
+  estimated_cost_usd: number | null;
+  invocation_count: number;
+}
+
+export interface FeatureUsageSummary {
+  feature_id: string;
+  aggregate_tokens: number;
+  aggregate_estimated_cost_usd: number;
+  aggregate_status: UsageAvailability;
+  by_role: RoleUsageBreakdown[];
+  last_updated: string;
+}
+
 export interface CostSummary {
   feature_id: string;
   tokens_used: number;
   estimated_cost_usd: number;
   recorded_at: string | null;
+  by_role?: RoleUsageBreakdown[];
+  aggregate_status?: UsageAvailability | null;
+}
+
+export type FeatureBudgetState = 'normal' | 'warning' | 'critical' | 'exceeded' | 'unknown';
+
+export interface TokenCostConversion {
+  usd_per_1k_tokens: number;
+}
+
+export interface DashboardActionState {
+  enabled: boolean;
+  authorized: boolean;
+  reason: string | null;
+}
+
+export type DashboardFeatureActionKey =
+  | 'run_merge_gate'
+  | 'approve'
+  | 'deny'
+  | 'request_changes'
+  | 'retry'
+  | 'resume'
+  | 'send_message'
+  | 'conflict_resolve'
+  | 'conflict_abort';
+
+export type ConflictResolutionStrategy = 'accept_ours' | 'accept_theirs' | 'manual';
+
+export interface ConflictFileEntry {
+  path: string;
+  resolution_strategy: ConflictResolutionStrategy | null;
+  resolved: boolean;
+  ours_content: string | null;
+  theirs_content: string | null;
+  merged_content: string | null;
+}
+
+export interface FeatureConflictSummary {
+  type: 'mainline_divergence';
+  merge_base: string;
+  mainline_head: string;
+  worktree_head: string;
+  conflicting_files: string[];
+  resolution_status: 'pending' | 'in_progress' | 'resolved';
+  detected_at: string;
+  queue_position: number | null;
+  reconciler_active: boolean;
+  reconciler_active_feature_id: string | null;
+}
+
+export interface ReconcilerQueueSnapshot {
+  active_feature_id: string | null;
+  session_id: string | null;
+  queue: Array<{ feature_id: string; queue_position: number; conflicting_files_count: number }>;
+  idle: boolean;
 }
 
 export interface QaTestIndexItem {
@@ -180,7 +318,108 @@ export interface ProviderAnalytics {
   success_rate: number;
   avg_retry_count: number;
   avg_duration_ms: number;
+  avg_tokens_used: number;
   avg_cost_usd: number;
+  role?: string;
+}
+
+export interface FeatureFileIndex {
+  feature_id: string;
+  plan_files: string[];
+  diff_files: string[];
+  checkpoint_files: string[];
+  all_files: string[];
+}
+
+export interface CollisionEntry {
+  path: string;
+  depth: number;
+  competing_features: string[];
+  risk: 'high' | 'medium' | 'low';
+}
+
+export interface CollisionRadarSnapshot {
+  this_feature_files: string[];
+  entries: CollisionEntry[];
+  high_count: number;
+  medium_count: number;
+  low_count: number;
+}
+
+export interface GateHistoryEntry {
+  id: string;
+  file: string;
+  mode: string;
+  profile: string | null;
+  overall: string;
+  finished_at: string | null;
+  step_count: number;
+  failing_step_count: number;
+  duration_ms: number | null;
+  steps: Array<{
+    name: string;
+    status: 'pass' | 'fail' | 'unknown';
+    output_tail: string[];
+  }>;
+}
+
+export interface FeatureGenealogyNode {
+  id: string;
+  label: string;
+  kind: 'feature' | 'plan_revision' | 'checkpoint' | 'run';
+  timestamp: string | null;
+  status?: string | null;
+  note?: string | null;
+}
+
+export interface FeatureGenealogy {
+  feature_id: string;
+  nodes: FeatureGenealogyNode[];
+}
+
+export interface MergeQueueEntry {
+  feature_id: string;
+  position: number;
+  total: number;
+  status: string;
+  phase_entered_at: string | null;
+  merge_ready: boolean;
+  ci_status: string | null;
+  pending_review_threads: number;
+  has_conflicts: boolean;
+  merge_score: number | null;
+  blocked_by: string[];
+  blocks: string[];
+  estimated_merge_at: string | null;
+  lock_holder: boolean;
+}
+
+export interface MergeQueueSnapshot {
+  queue: MergeQueueEntry[];
+  current_feature: MergeQueueEntry | null;
+}
+
+export interface UsageBurnPoint {
+  timestamp: string;
+  tokens_used: number;
+}
+
+export interface UsageBurnProjection {
+  current_tokens_used: number;
+  projected_final_tokens: number;
+  projected_completion_at: string | null;
+  budget_limit_tokens: number | null;
+  will_exceed_budget: boolean;
+  confidence: 'high' | 'medium' | 'low';
+  usage_points: UsageBurnPoint[];
+  historical_ratio: number | null;
+  derived_usd?: {
+    current_estimated_usd: number;
+    projected_final_estimated_usd: number;
+    usd_per_1k_tokens: number;
+  } | null;
+  last_updated_at: string | null;
+  source_label?: string | null;
 }
 
 export interface FeedEvent {
@@ -222,11 +461,77 @@ export interface RuntimeSession {
   orchestrator_epoch?: number;
 }
 
+export interface FeatureIntakeSummary {
+  status: 'not_started' | 'in_progress' | 'awaiting_input' | 'verified';
+  bootstrap_manifest_version: number | null;
+  verified_manifest_version: number | null;
+  open_ambiguity_count: number;
+  last_verified_at: string | null;
+  promotion_basis: string | null;
+}
+
+export interface FeatureIntakeReviewSummary {
+  status: string | null;
+  questions_open: number;
+  questions_resolved: number;
+  ambiguity_count: number;
+}
+
+export interface MergeRepairSummary {
+  attempts: number;
+  max_attempts: number;
+  active: boolean;
+  requested_at: string | null;
+  last_failed_at: string | null;
+  last_gate_evidence_path: string | null;
+  last_failure_summary: string | null;
+  reviewer_message: string | null;
+  exhausted_at: string | null;
+}
+
+export interface FeatureQuestion {
+  feature_id?: string;
+  question_id: string;
+  status: 'open' | 'answered' | 'expired' | 'withdrawn';
+  blocking: boolean;
+  question_type: string;
+  role: string;
+  phase: string;
+  request_action: string;
+  session_id?: string;
+  prompt: string;
+  details: Record<string, unknown>;
+  expected_answer: {
+    kind: string;
+    choices?: string[];
+    schema?: Record<string, unknown>;
+  } | null;
+  created_at: string;
+  expires_at: string | null;
+  answer: string | Record<string, unknown> | null;
+  answered_at: string | null;
+  answered_by: string | null;
+  resume_status: string | null;
+  resume_phase: string | null;
+  ambiguity_id?: string | null;
+  obligation_ids?: string[];
+  intake_context?: FeatureIntakeSummary | null;
+}
+
 export interface FeatureSummary {
   id: string;
   feature_id: string;
   status: string;
-  phase?: 'planning' | 'building' | 'qa' | 'ready_to_merge' | 'merged' | 'blocked' | 'unknown';
+  phase?:
+    | 'intake'
+    | 'planning'
+    | 'building'
+    | 'qa'
+    | 'ready_to_merge'
+    | 'merged'
+    | 'blocked'
+    | 'awaiting_input'
+    | 'unknown';
   plan_version?: number;
   revision_of?: number | null;
   revision_reason?: string | null;
@@ -236,6 +541,7 @@ export interface FeatureSummary {
   last_retry_at?: string | null;
   locks_held?: string[];
   gates?: {
+    plan?: string;
     fast?: string;
     full?: string;
     merge?: string;
@@ -244,10 +550,39 @@ export interface FeatureSummary {
   branch?: string | null;
   worktree_path?: string | null;
   last_updated?: string;
+  phase_entered_at?: string;
   status_reason?: string;
+  recovery?: {
+    state: 'retrying' | 'awaiting_operator';
+    cause?: string | null;
+    role?: string | null;
+    resume_phase?: string | null;
+    attempt?: number | null;
+    run_id?: string | null;
+    started_at?: string | null;
+    last_attempt_at?: string | null;
+  } | null;
   activity_state?: 'active' | 'idle' | 'waiting_input' | 'blocked' | 'exited' | 'unknown';
   activity_last_event_at?: string;
   activity_detected_via?: 'jsonl' | 'ledger' | 'process' | 'unknown';
+  attention_reasons?: string[];
+  waiting_input_count?: number;
+  open_question_id?: string | null;
+  open_question_count?: number;
+  awaiting_since?: string | null;
+  requested_by_role?: string | null;
+  resume_status?: string | null;
+  intake_status?: FeatureIntakeSummary['status'];
+  bootstrap_manifest_version?: number | null;
+  verified_manifest_version?: number | null;
+  open_ambiguity_count?: number;
+  last_verified_at?: string | null;
+  promotion_basis?: string | null;
+  merge_repair?: MergeRepairSummary | null;
+  last_meaningful_change_at?: string;
+  usage_tokens?: number | null;
+  budget_state?: FeatureBudgetState;
+  client_status_label?: string;
   pr?: {
     number?: number;
     url?: string;
@@ -258,6 +593,13 @@ export interface FeatureSummary {
     has_conflicts?: boolean;
     merge_score?: number;
   } | null;
+  conflict_summary?: FeatureConflictSummary | null;
+  collision?: {
+    with_feature_ids: string[];
+    collision_fingerprint: string;
+    file_paths: string[];
+    detected_at: string;
+  } | null;
 }
 
 export interface FeatureLogEntry {
@@ -279,6 +621,19 @@ export interface FeaturesIndex {
   lock_leases?: Record<string, { holder: string; lease_expires_at: string; stale?: boolean }>;
   dep_blocked?: Array<{ feature_id: string; depends_on_unresolved: string[] }>;
   runtime_sessions?: RuntimeSession;
+  collision_records?: Array<{
+    collision_id: string;
+    feature_id: string;
+    with_feature_ids?: string[];
+    detected_at?: string;
+    collision_fingerprint?: string;
+    collisions?: {
+      files?: Array<{ with_feature_id: string; paths: string[] }>;
+      areas?: Array<{ with_feature_id: string; areas: string[] }>;
+      contracts?: Array<{ with_feature_id: string; paths: string[] }>;
+    };
+    resolution?: string;
+  }>;
 }
 
 export interface SSEEvent {
@@ -294,26 +649,399 @@ export interface EvidenceArtifact {
   updated_at: string;
 }
 
+export interface FeatureSpecSummary {
+  title?: string | null;
+  path?: string | null;
+  markdown?: string | null;
+  last_updated?: string | null;
+}
+
+export type PlannerSubphase = 'intake' | 'planning' | 'post_planning';
+
+export interface PlanLifecycleStep {
+  id: 'source_spec' | 'bootstrap_manifest' | 'verified_manifest' | 'accepted_plan' | 'execution';
+  label: string;
+  status: 'complete' | 'current' | 'blocked' | 'pending';
+  detail: string;
+}
+
+export interface ManifestArtifactSummary {
+  version: number | null;
+  generated_at: string | null;
+  obligation_count: number;
+  ambiguity_count?: number;
+  verification_basis?: string | null;
+  confidence: {
+    high: number;
+    medium: number;
+    low: number;
+  };
+}
+
+export interface PlannerLifecycleSummary {
+  current_subphase: PlannerSubphase;
+  current_owner: 'planner' | 'operator' | 'system' | null;
+  last_updated_at: string | null;
+  banner_state:
+    | 'waiting_on_intake_clarification'
+    | 'intake_in_progress'
+    | 'ready_for_execution_planning'
+    | 'execution_planning_in_progress'
+    | 'accepted_plan_current'
+    | 'accepted_plan_stale';
+  lifecycle_steps: PlanLifecycleStep[];
+  next_action: string;
+  primary_detail: string;
+}
+
+export interface PlannerArtifactView {
+  id:
+    | 'source_spec'
+    | 'bootstrap_manifest'
+    | 'verified_manifest'
+    | 'intake_review'
+    | 'plan_markdown'
+    | 'plan_json';
+  label: string;
+  format: 'markdown' | 'json';
+  path: string | null;
+  version: number | null;
+  updated_at: string | null;
+  raw_content: string | null;
+  primary: boolean;
+  authority_label: string | null;
+  empty_state: string;
+}
+
+export interface IntakeAmbiguitySummary {
+  id: string;
+  summary: string;
+  status: 'open' | 'resolved';
+  obligation_ids: string[];
+  blocking: boolean;
+  linked_open_question_id: string | null;
+}
+
+export interface FeatureIntakeWorkspace {
+  lifecycle: PlannerLifecycleSummary;
+  summary: FeatureIntakeSummary | null;
+  review: FeatureIntakeReviewSummary | null;
+  bootstrap_manifest: ManifestArtifactSummary | null;
+  verified_manifest: ManifestArtifactSummary | null;
+  open_ambiguities: IntakeAmbiguitySummary[];
+  resolved_ambiguities: IntakeAmbiguitySummary[];
+  promotion_readiness: {
+    ready: boolean;
+    blocker_reasons: string[];
+    verified_manifest_exists: boolean;
+    open_questions_remaining: boolean;
+    unresolved_ambiguities_remaining: boolean;
+  };
+  manifest_delta: {
+    ambiguities_resolved: number;
+    ambiguities_open: number;
+    obligations_added: number;
+    obligations_removed: number;
+    confidence_upgrades: number;
+    confidence_downgrades: number;
+  };
+  open_questions: FeatureQuestion[];
+  general_questions: FeatureQuestion[];
+  artifacts: PlannerArtifactView[];
+}
+
+export interface FeaturePlanningWorkspace {
+  lifecycle: PlannerLifecycleSummary;
+  intake_handoff: {
+    verified_manifest_version: number | null;
+    promotion_basis: string | null;
+    last_verified_at: string | null;
+    open_ambiguity_count: number;
+  } | null;
+  status: 'not_started' | 'ready_to_plan' | 'in_progress' | 'accepted' | 'stale' | 'blocked';
+  accepted_plan_version: number | null;
+  accepted_at: string | null;
+  gate_profile: string | null;
+  task_count: number;
+  risk_count: number;
+  current_focus: string | null;
+  current_focus_detail: string | null;
+  next_tasks: PlanProgressTaskSummary[];
+  blocked_tasks: PlanProgressTaskSummary[];
+  file_scope: {
+    create: number;
+    modify: number;
+    delete: number;
+    sample_paths: string[];
+  };
+  trace_coverage: {
+    total_obligations: number;
+    mapped: number;
+    unmapped: number;
+    deferred: number;
+    out_of_scope: number;
+    missing_verification_intent: number;
+    unmapped_ids: string[];
+  };
+  trace_contract: {
+    valid: boolean;
+    missing_obligation_ids: string[];
+    unknown_obligation_ids: string[];
+    duplicate_obligation_ids: string[];
+    invalid_mappings: string[];
+    invalid_mapping_details: Array<{
+      obligation_id: string;
+      reason: 'missing_planned_paths' | 'planned_paths_outside_plan_files';
+      planned_paths: string[];
+    }>;
+  } | null;
+  freshness: {
+    source_verified_manifest_version: number | null;
+    current_verified_manifest_version: number | null;
+    stale: boolean;
+    reason: string | null;
+  };
+  accepted_plan_summary: {
+    summary: string | null;
+    acceptance_criteria: string[];
+    scoped_files: string[];
+    risks: string[];
+    owners: string[];
+    tasks: PlanProgressTaskSummary[];
+  } | null;
+  empty_plan_reason: string | null;
+  artifacts: PlannerArtifactView[];
+}
+
+export type FeatureVerificationReadiness = 'ready' | 'at_risk' | 'blocked' | 'unknown';
+
+export type FeatureVerificationSource =
+  | 'gate'
+  | 'qa'
+  | 'review'
+  | 'dependency'
+  | 'runtime'
+  | 'plan'
+  | 'budget'
+  | 'collision';
+
+export interface FeatureVerificationBlocker {
+  id: string;
+  label: string;
+  severity: 'high' | 'medium' | 'low';
+  source: FeatureVerificationSource;
+  detail: string;
+  artifact_ref?: string | null;
+}
+
+export interface FeatureVerificationItem {
+  id: string;
+  label: string;
+  status: 'verified' | 'at_risk' | 'unverified';
+  source: FeatureVerificationSource;
+  detail: string;
+  artifact_ref?: string | null;
+  last_evidence_at: string | null;
+}
+
+export interface FeatureVerificationSummary {
+  last_evaluated_at: string | null;
+  readiness: FeatureVerificationReadiness;
+  blockers: FeatureVerificationBlocker[];
+  verified_requirements: number;
+  at_risk_requirements: number;
+  unverified_requirements: number;
+  items: FeatureVerificationItem[];
+}
+
+export interface PlanProgressTaskSummary {
+  id?: string | null;
+  title: string;
+  status: 'pending' | 'in_progress' | 'blocked' | 'completed';
+  owner_role?: 'planner' | 'builder' | 'qa' | 'reconciler' | 'orchestrator' | null;
+  started_at?: string | null;
+  last_updated?: string | null;
+  blocked_by?: string[];
+}
+
+export interface PlanProgressSummary {
+  total_tasks: number;
+  completed_tasks: number;
+  in_progress_tasks: number;
+  pending_tasks: number;
+  blocked_tasks: number;
+  percent_complete: number;
+  current_task?: PlanProgressTaskSummary | null;
+  next_tasks: PlanProgressTaskSummary[];
+  completed_recently: Array<{
+    id?: string | null;
+    title: string;
+    completed_at?: string | null;
+  }>;
+  estimated: boolean;
+  source: 'explicit' | 'derived' | 'mixed';
+  last_updated_at: string | null;
+}
+
+export interface RevisionSummaryEntry {
+  id: string;
+  timestamp: string | null;
+  type: 'plan_update' | 'checkpoint' | 'review_event' | 'gate_run' | 'merge_event';
+  headline: string;
+  detail: string;
+  file_count?: number | null;
+  artifacts?: string[];
+  jump_to?: 'intake' | 'planning' | 'changes' | 'gates_qa' | 'history' | 'review';
+}
+
+export interface ActionableRiskItem {
+  id: string;
+  severity: 'high' | 'medium' | 'low';
+  statement: string;
+  impact: string;
+  mitigation: string;
+  owner_role?: 'planner' | 'builder' | 'qa' | 'reconciler' | 'orchestrator' | null;
+  freshness: 'fresh' | 'stale' | 'derived' | 'unknown';
+  derived: boolean;
+}
+
+export interface FeatureCheckpointsPage {
+  items: FeatureCheckpoint[];
+  total_count: number;
+  suppressed_count?: number;
+  cursor: string | null;
+  next_cursor: string | null;
+  prev_cursor: string | null;
+  limit: number;
+}
+
+export interface FeatureRunHistoryEntry {
+  run_id: string;
+  started_at: string;
+  ended_at: string | null;
+  status: 'active' | 'completed' | 'failed' | 'timeout' | 'interrupted';
+  evidence_count: number;
+  checkpoint_count: number;
+  raw_log_count: number;
+  has_events: boolean;
+  has_operations: boolean;
+}
+
+export interface FeatureRunHistoryDetail {
+  run: FeatureRunHistoryEntry;
+  evidence: EvidenceArtifact[];
+  checkpoints: FeatureCheckpoint[];
+  raw_logs: RawLogFileMeta[];
+  revision_events: RevisionSummaryEntry[];
+}
+
 export interface FeatureDetail {
   feature: FeatureSummary;
   plan: Record<string, unknown> | null;
   diff: string;
   evidence: EvidenceArtifact[];
+  actions?: Partial<Record<DashboardFeatureActionKey, DashboardActionState>>;
+  spec?: FeatureSpecSummary | null;
+  plan_progress?: PlanProgressSummary | null;
+  verification_summary?: FeatureVerificationSummary | null;
+  revision_summary?: RevisionSummaryEntry[];
+  actionable_risks?: ActionableRiskItem[];
   gate_evidence?: GateRunEvidence | null;
   cost?: CostSummary | null;
+  budget_limit_tokens?: number | null;
   qa_test_index?: QaTestIndex | null;
   review_brief?: ReviewBrief | null;
   log_entries?: AgentLogEntry[];
   execution_mode?: FeatureExecutionMode | null;
   checkpoints?: FeatureCheckpoint[];
+  collision_radar?: CollisionRadarSnapshot | null;
+  role_performance?: AgentRolePerformanceCardData[];
+  usage_burn?: UsageBurnProjection | null;
+  genealogy?: FeatureGenealogy | null;
+  gate_history?: GateHistoryEntry[];
+  merge_queue?: MergeQueueSnapshot | null;
+  worker_summary?: WorkerEventSummary | null;
+  live_output_snapshots?: LiveAgentOutputStatusSnapshot[];
+  provider_analytics?: ProviderAnalytics[];
+  token_cost_conversion?: TokenCostConversion | null;
+  questions?: FeatureQuestion[];
+  intake?: {
+    summary: FeatureIntakeSummary;
+    review: FeatureIntakeReviewSummary | null;
+  } | null;
+  conflict_summary?: FeatureConflictSummary | null;
+}
+
+export interface FeatureTriageDetail {
+  feature: FeatureSummary;
+  why_attention: string[];
+  blocker_summary?: string | null;
+  open_questions?: FeatureQuestion[];
+  dependency_summary?: string[];
+  review_snapshot?: {
+    pr_url?: string | null;
+    ci_status?: string | null;
+    review_decision?: string | null;
+    merge_ready?: boolean | null;
+  };
+  usage?: {
+    tokens_used?: number | null;
+    budget_limit_tokens?: number | null;
+    derived_cost_usd?: number | null;
+    budget_state?: FeatureBudgetState;
+    availability?: UsageAvailability | null;
+    by_role?: RoleUsageBreakdown[];
+  };
+  intake?: {
+    summary: FeatureIntakeSummary;
+    review: FeatureIntakeReviewSummary | null;
+  } | null;
+  actions?: Partial<Record<DashboardFeatureActionKey, DashboardActionState>>;
+}
+
+export interface ProjectListEntry {
+  name: string;
+  label?: string | null;
+  environment?: string | null;
+  owner?: string | null;
+  sort_order?: number | null;
+  pinned?: boolean;
+}
+
+export interface OrganizerDeferredSummary {
+  feature_id: string;
+  blocked_by: string[];
+  reason: string;
+}
+
+export interface OrganizerBlockedSummary {
+  feature_id: string;
+  reason: string;
+}
+
+export interface OrganizerStatusProjection {
+  available: boolean;
+  generated_at: string | null;
+  ready_set: string[];
+  deferred_set: OrganizerDeferredSummary[];
+  blocked_set: OrganizerBlockedSummary[];
 }
 
 export interface DashboardStatusPayload {
   index: FeaturesIndex;
   features: FeatureSummary[];
+  pending_questions?: {
+    count: number;
+    items: FeatureQuestion[];
+  };
   runtime?: RuntimeSession;
   lock_map?: LockLease[];
   dep_blocked?: Array<{ feature_id: string; depends_on_unresolved: string[] }>;
   flaky_suspects?: string[];
-  metrics?: { total_cost_today_usd?: number; merge_histogram_14d?: number[] };
+  metrics?: {
+    total_tokens_today?: number;
+    total_cost_today_usd?: number | null;
+    merge_histogram_14d?: number[];
+  };
+  organizer?: OrganizerStatusProjection;
 }