agentic-orchestrator 0.1.25 → 0.1.26

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

@@ -16,6 +16,8 @@ export type QuickFilterKey =
   | 'ready_to_merge'
   | 'ci_failing';
 
+type PhaseFilterValue = Exclude<FeatureSummary['phase'], undefined>;
+
 export interface DashboardFilterState {
   searchText: string;
   phases: FeatureSummary['phase'][];
@@ -25,6 +27,45 @@ export interface DashboardFilterState {
   quickFilter: QuickFilterKey | null;
 }
 
+export type DashboardViewMode = 'board' | 'list';
+
+export interface DashboardRouteState {
+  project: string;
+  featureId: string | null;
+  viewMode: DashboardViewMode;
+  filters: DashboardFilterState;
+}
+
+export interface QuickLaunchAffordanceState {
+  available: boolean;
+  enabled: boolean;
+  authorized: boolean;
+}
+
+export interface ColumnFeatureIds {
+  phase: FeatureSummary['phase'];
+  featureIds: string[];
+}
+
+const PHASE_VALUES: PhaseFilterValue[] = [
+  'planning',
+  'building',
+  'qa',
+  'ready_to_merge',
+  'merged',
+  'blocked',
+  'unknown',
+];
+
+const ACTIVITY_VALUES: NonNullable<FeatureSummary['activity_state']>[] = [
+  'active',
+  'idle',
+  'waiting_input',
+  'blocked',
+  'exited',
+  'unknown',
+];
+
 export interface DashboardSummaryCounts {
   active: number;
   blocked: number;
@@ -33,6 +74,13 @@ export interface DashboardSummaryCounts {
   ciFailing: number;
 }
 
+export interface SparklinePoint {
+  x: number;
+  y: number;
+  value: number;
+  index: number;
+}
+
 export interface ParsedDiffLine {
   raw: string;
   type: 'add' | 'del' | 'context' | 'meta';
@@ -66,6 +114,262 @@ export function createDefaultFilters(): DashboardFilterState {
   };
 }
 
+function parseListParam(value: string | null): string[] {
+  if (!value) {
+    return [];
+  }
+  return value
+    .split(',')
+    .map((item) => item.trim())
+    .filter((item) => item.length > 0);
+}
+
+function parseBooleanFlag(value: string | null): boolean {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes';
+}
+
+function isQuickFilterKey(value: string): value is QuickFilterKey {
+  return (
+    value === 'active' ||
+    value === 'blocked' ||
+    value === 'awaiting_input' ||
+    value === 'ready_to_merge' ||
+    value === 'ci_failing'
+  );
+}
+
+export function parseFiltersFromSearchParams(params: URLSearchParams): DashboardFilterState {
+  const filters = createDefaultFilters();
+  filters.searchText = params.get('q') ?? '';
+
+  const phases = parseListParam(params.get('phase')).filter((item): item is PhaseFilterValue =>
+    PHASE_VALUES.includes(item as PhaseFilterValue),
+  );
+  const activities = parseListParam(params.get('activity')).filter(
+    (item): item is NonNullable<FeatureSummary['activity_state']> =>
+      ACTIVITY_VALUES.includes(item as NonNullable<FeatureSummary['activity_state']>),
+  );
+
+  filters.phases = phases as FeatureSummary['phase'][];
+  filters.activities = activities;
+  filters.gateFailuresOnly = parseBooleanFlag(params.get('gate_failures'));
+  filters.ciFailuresOnly = parseBooleanFlag(params.get('ci_not_success'));
+
+  const quick = params.get('quick');
+  if (quick && isQuickFilterKey(quick)) {
+    filters.quickFilter = quick;
+  }
+
+  return filters;
+}
+
+export function applyFiltersToSearchParams(
+  params: URLSearchParams,
+  filters: DashboardFilterState,
+): void {
+  const searchText = filters.searchText.trim();
+  if (searchText.length > 0) {
+    params.set('q', searchText);
+  } else {
+    params.delete('q');
+  }
+
+  if (filters.phases.length > 0) {
+    params.set('phase', filters.phases.join(','));
+  } else {
+    params.delete('phase');
+  }
+
+  if (filters.activities.length > 0) {
+    params.set('activity', filters.activities.join(','));
+  } else {
+    params.delete('activity');
+  }
+
+  if (filters.gateFailuresOnly) {
+    params.set('gate_failures', '1');
+  } else {
+    params.delete('gate_failures');
+  }
+
+  if (filters.ciFailuresOnly) {
+    params.set('ci_not_success', '1');
+  } else {
+    params.delete('ci_not_success');
+  }
+
+  if (filters.quickFilter) {
+    params.set('quick', filters.quickFilter);
+  } else {
+    params.delete('quick');
+  }
+}
+
+function parseFeatureId(value: string | null): string | null {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+export function parseDashboardRouteState(params: URLSearchParams): DashboardRouteState {
+  return {
+    project: params.get('project') ?? '',
+    featureId: parseFeatureId(params.get('feature')),
+    viewMode: params.get('view') === 'list' ? 'list' : 'board',
+    filters: parseFiltersFromSearchParams(params),
+  };
+}
+
+export function applyDashboardRouteState(
+  params: URLSearchParams,
+  state: DashboardRouteState,
+): void {
+  const project = state.project.trim();
+  const featureId = state.featureId?.trim() ?? '';
+
+  if (project.length > 0) {
+    params.set('project', project);
+  } else {
+    params.delete('project');
+  }
+
+  if (featureId.length > 0) {
+    params.set('feature', featureId);
+  } else {
+    params.delete('feature');
+  }
+
+  if (state.viewMode === 'list') {
+    params.set('view', 'list');
+  } else {
+    params.delete('view');
+  }
+
+  applyFiltersToSearchParams(params, state.filters);
+}
+
+export function buildDashboardFeatureHref(featureId: string, project: string): string {
+  const params = new URLSearchParams();
+  const nextFeature = featureId.trim();
+  const nextProject = project.trim();
+
+  if (nextProject.length > 0) {
+    params.set('project', nextProject);
+  }
+  if (nextFeature.length > 0) {
+    params.set('feature', nextFeature);
+  }
+
+  const query = params.toString();
+  return query.length > 0 ? `/?${query}` : '/';
+}
+
+export function buildFeatureFocusHref(featureId: string, project: string): string {
+  const encodedFeatureId = encodeURIComponent(featureId.trim());
+  const params = new URLSearchParams();
+  const nextProject = project.trim();
+  if (nextProject.length > 0) {
+    params.set('project', nextProject);
+  }
+  const query = params.toString();
+  return query.length > 0
+    ? `/feature/${encodedFeatureId}?${query}`
+    : `/feature/${encodedFeatureId}`;
+}
+
+export function isQuickLaunchAffordanceVisible(state: QuickLaunchAffordanceState): boolean {
+  return state.available && state.enabled && state.authorized;
+}
+
+function findCurrentColumnIndex(
+  columnFeatureIds: ColumnFeatureIds[],
+  focusedFeatureId: string | null,
+): number {
+  if (focusedFeatureId) {
+    const focusedIndex = columnFeatureIds.findIndex((column) =>
+      column.featureIds.includes(focusedFeatureId),
+    );
+    if (focusedIndex >= 0) {
+      return focusedIndex;
+    }
+  }
+  return columnFeatureIds.findIndex((column) => column.featureIds.length > 0);
+}
+
+export function getNextFocusedFeatureId(
+  columnFeatureIds: ColumnFeatureIds[],
+  focusedFeatureId: string | null,
+  key: 'ArrowUp' | 'ArrowDown' | 'ArrowLeft' | 'ArrowRight',
+): string | null {
+  if (columnFeatureIds.length === 0) {
+    return null;
+  }
+
+  const currentColumnIndex = findCurrentColumnIndex(columnFeatureIds, focusedFeatureId);
+  if (currentColumnIndex < 0) {
+    return null;
+  }
+
+  const currentColumn = columnFeatureIds[currentColumnIndex];
+  if (currentColumn.featureIds.length === 0) {
+    return null;
+  }
+
+  const existingRow = focusedFeatureId ? currentColumn.featureIds.indexOf(focusedFeatureId) : -1;
+  const currentRow = Math.max(0, existingRow);
+  const currentFeatureId = currentColumn.featureIds[currentRow] ?? null;
+
+  if (key === 'ArrowUp' || key === 'ArrowDown') {
+    const offset = key === 'ArrowUp' ? -1 : 1;
+    const nextRow = Math.min(currentColumn.featureIds.length - 1, Math.max(0, currentRow + offset));
+    return currentColumn.featureIds[nextRow] ?? currentFeatureId;
+  }
+
+  const direction = key === 'ArrowLeft' ? -1 : 1;
+  let cursor = currentColumnIndex;
+  while (cursor >= 0 && cursor < columnFeatureIds.length) {
+    cursor += direction;
+    if (cursor < 0 || cursor >= columnFeatureIds.length) {
+      break;
+    }
+    const candidate = columnFeatureIds[cursor];
+    if (candidate.featureIds.length === 0) {
+      continue;
+    }
+    const nextRow = Math.min(currentRow, candidate.featureIds.length - 1);
+    return candidate.featureIds[nextRow] ?? currentFeatureId;
+  }
+
+  return currentFeatureId;
+}
+
+export function sparklinePath(values: number[], width: number, height: number): string {
+  const points = sparklinePoints(values, width, height);
+  return points
+    .map((point, index) => `${index === 0 ? 'M' : 'L'}${point.x.toFixed(2)} ${point.y.toFixed(2)}`)
+    .join(' ');
+}
+
+export function sparklinePoints(values: number[], width: number, height: number): SparklinePoint[] {
+  if (values.length === 0) {
+    return [];
+  }
+  const max = Math.max(1, ...values);
+  const step = values.length > 1 ? width / (values.length - 1) : width;
+  return values.map((value, index) => ({
+    x: index * step,
+    y: height - (value / max) * height,
+    value,
+    index,
+  }));
+}
+
 export function applyQuickFilter(key: QuickFilterKey): DashboardFilterState {
   const next = createDefaultFilters();
   next.quickFilter = key;

package/packages/web-dashboard/src/lib/live-feed.ts

@@ -0,0 +1,218 @@
+import type { DashboardStatusPayload, FeedEvent, FeatureSummary, LockLease } from '@/lib/types.js';
+
+const FEED_DEDUP_WINDOW_MS = 10_000;
+const FEED_MAX_EVENTS = 100;
+
+export interface LiveFeedState {
+  events: FeedEvent[];
+  paused: boolean;
+}
+
+export type LiveFeedAction = { type: 'toggle_pause' } | { type: 'clear' };
+
+function gateHasFailure(feature: FeatureSummary): boolean {
+  const gates = feature.gates;
+  if (!gates || typeof gates !== 'object') {
+    return false;
+  }
+  return [gates.fast, gates.full, gates.merge].some((value) => {
+    if (typeof value !== 'string') {
+      return false;
+    }
+    const normalized = value.toLowerCase();
+    return normalized === 'fail' || normalized === 'failed' || normalized === 'error';
+  });
+}
+
+function lockMapByResource(locks: LockLease[] | undefined): Map<string, LockLease> {
+  const map = new Map<string, LockLease>();
+  for (const lock of locks ?? []) {
+    map.set(lock.resource, lock);
+  }
+  return map;
+}
+
+function buildEvent(
+  index: number,
+  timestamp: string,
+  featureId: string,
+  type: FeedEvent['type'],
+  message: string,
+  severity: FeedEvent['severity'],
+): FeedEvent {
+  return {
+    id: `${type}:${featureId}:${Date.parse(timestamp)}:${index}`,
+    timestamp,
+    feature_id: featureId,
+    type,
+    message,
+    severity,
+  };
+}
+
+function eventSignature(event: FeedEvent): string {
+  return `${event.feature_id}:${event.type}:${event.message}`;
+}
+
+export function deriveFeedEventsFromSnapshotDiff(
+  previous: DashboardStatusPayload | null,
+  next: DashboardStatusPayload,
+  nowIso = new Date().toISOString(),
+): FeedEvent[] {
+  if (!previous) {
+    return [];
+  }
+
+  const events: FeedEvent[] = [];
+  const prevById = new Map(previous.features.map((feature) => [feature.feature_id, feature]));
+  const nextById = new Map(next.features.map((feature) => [feature.feature_id, feature]));
+  const allFeatureIds = new Set([...prevById.keys(), ...nextById.keys()]);
+  let index = 0;
+
+  for (const featureId of allFeatureIds) {
+    const prevFeature = prevById.get(featureId);
+    const nextFeature = nextById.get(featureId);
+    if (!prevFeature || !nextFeature) {
+      continue;
+    }
+
+    if (prevFeature.phase !== nextFeature.phase) {
+      const severity: FeedEvent['severity'] =
+        nextFeature.phase === 'blocked'
+          ? 'error'
+          : nextFeature.phase === 'merged'
+            ? 'success'
+            : 'info';
+      events.push(
+        buildEvent(
+          index++,
+          nowIso,
+          featureId,
+          'phase_change',
+          `${featureId} moved ${prevFeature.phase ?? 'unknown'} -> ${nextFeature.phase ?? 'unknown'}`,
+          severity,
+        ),
+      );
+    }
+
+    if (JSON.stringify(prevFeature.gates ?? {}) !== JSON.stringify(nextFeature.gates ?? {})) {
+      events.push(
+        buildEvent(
+          index++,
+          nowIso,
+          featureId,
+          'gate_update',
+          `${featureId} gate status updated`,
+          gateHasFailure(nextFeature) ? 'warning' : 'info',
+        ),
+      );
+    }
+
+    if (prevFeature.activity_state !== nextFeature.activity_state) {
+      events.push(
+        buildEvent(
+          index++,
+          nowIso,
+          featureId,
+          'activity_change',
+          `${featureId} activity ${prevFeature.activity_state ?? 'unknown'} -> ${nextFeature.activity_state ?? 'unknown'}`,
+          nextFeature.activity_state === 'blocked' ? 'warning' : 'info',
+        ),
+      );
+    }
+
+    const prevPr = prevFeature.pr ?? null;
+    const nextPr = nextFeature.pr ?? null;
+    if (JSON.stringify(prevPr) !== JSON.stringify(nextPr)) {
+      const ciStatus =
+        nextPr && typeof nextPr.ci_status === 'string' ? `CI ${nextPr.ci_status}` : 'PR updated';
+      events.push(
+        buildEvent(index++, nowIso, featureId, 'pr_update', `${featureId} ${ciStatus}`, 'info'),
+      );
+    }
+  }
+
+  const prevLocks = lockMapByResource(previous.lock_map);
+  const nextLocks = lockMapByResource(next.lock_map);
+  const allResources = new Set([...prevLocks.keys(), ...nextLocks.keys()]);
+  for (const resource of allResources) {
+    const prevLock = prevLocks.get(resource);
+    const nextLock = nextLocks.get(resource);
+    if (!nextLock || !prevLock) {
+      continue;
+    }
+    if (
+      prevLock.holder !== nextLock.holder ||
+      prevLock.is_stale !== nextLock.is_stale ||
+      prevLock.expires_at !== nextLock.expires_at
+    ) {
+      events.push(
+        buildEvent(
+          index++,
+          nowIso,
+          nextLock.holder ?? 'system',
+          'lock_change',
+          `${resource} lock holder ${prevLock.holder ?? 'none'} -> ${nextLock.holder ?? 'none'}`,
+          nextLock.is_stale ? 'warning' : 'info',
+        ),
+      );
+    }
+  }
+
+  return events;
+}
+
+export function appendFeedEvents(existing: FeedEvent[], incoming: FeedEvent[]): FeedEvent[] {
+  if (incoming.length === 0) {
+    return existing;
+  }
+
+  const latestSeenBySignature = new Map<string, number>();
+  for (const event of existing) {
+    const parsed = Date.parse(event.timestamp);
+    if (Number.isNaN(parsed)) {
+      continue;
+    }
+    const signature = eventSignature(event);
+    const current = latestSeenBySignature.get(signature) ?? Number.MIN_SAFE_INTEGER;
+    if (parsed > current) {
+      latestSeenBySignature.set(signature, parsed);
+    }
+  }
+
+  const accepted: FeedEvent[] = [];
+  for (const event of incoming) {
+    const signature = eventSignature(event);
+    const eventTs = Date.parse(event.timestamp);
+    if (Number.isNaN(eventTs)) {
+      accepted.push(event);
+      continue;
+    }
+    const latestTs = latestSeenBySignature.get(signature);
+    if (latestTs != null && eventTs - latestTs < FEED_DEDUP_WINDOW_MS) {
+      continue;
+    }
+    latestSeenBySignature.set(signature, eventTs);
+    accepted.push(event);
+  }
+
+  if (accepted.length === 0) {
+    return existing;
+  }
+
+  return [...accepted.reverse(), ...existing].slice(0, FEED_MAX_EVENTS);
+}
+
+export function reduceLiveFeedState(state: LiveFeedState, action: LiveFeedAction): LiveFeedState {
+  if (action.type === 'toggle_pause') {
+    return {
+      ...state,
+      paused: !state.paused,
+    };
+  }
+
+  return {
+    ...state,
+    events: [],
+  };
+}

package/packages/web-dashboard/src/lib/policy-reader.ts

@@ -0,0 +1,22 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+
+export async function readPolicyYaml(repoRoot: string): Promise<Record<string, unknown> | null> {
+  const candidates = [
+    path.join(repoRoot, 'config', 'agentic', 'orchestrator', 'policy.yaml'),
+    path.join(repoRoot, 'agentic', 'orchestrator', 'policy.yaml'),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const raw = await readFile(candidate, 'utf-8');
+      const parsed = YAML.parse(raw) as Record<string, unknown>;
+      if (parsed && typeof parsed === 'object') {
+        return parsed;
+      }
+    } catch {
+      // continue to next path
+    }
+  }
+  return null;
+}

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

@@ -1,9 +1,111 @@
+export type RoleStatus = 'ready' | 'running' | 'blocked' | 'done' | 'unknown';
+
+export interface AgentPipelineStatus {
+  planner: RoleStatus;
+  builder: RoleStatus;
+  qa: RoleStatus;
+}
+
+export interface CostSummary {
+  feature_id: string;
+  tokens_used: number;
+  estimated_cost_usd: number;
+  recorded_at: string | null;
+}
+
+export interface QaTestIndexItem {
+  path: string;
+  status: 'pending' | 'running' | 'passed' | 'failed' | 'waived';
+  required_tests: string[];
+  last_run_at?: string;
+}
+
+export interface QaTestIndex {
+  feature_id: string;
+  version: number;
+  items: QaTestIndexItem[];
+}
+
+export interface LockLease {
+  resource: string;
+  holder: string | null;
+  expires_at: string | null;
+  is_stale: boolean;
+}
+
+export interface ReviewBrief {
+  intent_summary: string;
+  scope_summary: string;
+  contract_risk_summary: string;
+  feasibility_score?: number;
+  feasibility_breakdown?: Record<string, number>;
+  gate_matrix: Record<string, string>;
+  unresolved_questions: string[];
+  evidence_refs: string[];
+  generated_at: string;
+}
+
+export interface ProviderAnalytics {
+  provider: string;
+  model: string;
+  total_features: number;
+  success_count: number;
+  success_rate: number;
+  avg_retry_count: number;
+  avg_duration_ms: number;
+  avg_cost_usd: number;
+}
+
+export interface FeedEvent {
+  id: string;
+  timestamp: string;
+  feature_id: string;
+  type: 'phase_change' | 'gate_update' | 'activity_change' | 'pr_update' | 'lock_change';
+  message: string;
+  severity: 'info' | 'success' | 'warning' | 'error';
+}
+
+export interface GateStepResult {
+  name: string;
+  command: string;
+  status: 'pass' | 'fail' | 'unknown';
+  exit_code: number | null;
+  duration_ms: number | null;
+  log_path?: string | null;
+  output_tail?: string[];
+}
+
+export interface GateRunEvidence {
+  mode: string;
+  profile?: string | null;
+  overall: string;
+  finished_at?: string | null;
+  steps: GateStepResult[];
+  raw?: Record<string, unknown>;
+}
+
+export interface RuntimeSession {
+  run_id?: string;
+  owner_instance_id?: string;
+  provider?: string | null;
+  model?: string | null;
+  started_at?: string | null;
+  last_heartbeat_at?: string | null;
+  lease_expires_at?: string | null;
+  orchestrator_epoch?: number;
+}
+
 export interface FeatureSummary {
   id: string;
   feature_id: string;
   status: string;
   phase?: 'planning' | 'building' | 'qa' | 'ready_to_merge' | 'merged' | 'blocked' | 'unknown';
   plan_version?: number;
+  revision_of?: number | null;
+  revision_reason?: string | null;
+  role_status?: AgentPipelineStatus;
+  gate_retry_count?: number;
+  last_retry_at?: string | null;
   locks_held?: string[];
   gates?: {
     fast?: string;
@@ -46,6 +148,9 @@ export interface FeaturesIndex {
   blocked: string[];
   merged: string[];
   blocked_queue?: Array<{ feature_id: string; detected_at: string; collision_fingerprint: string }>;
+  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;
 }
 
 export interface SSEEvent {
@@ -66,9 +171,18 @@ export interface FeatureDetail {
   plan: Record<string, unknown> | null;
   diff: string;
   evidence: EvidenceArtifact[];
+  gate_evidence?: GateRunEvidence | null;
+  cost?: CostSummary | null;
+  qa_test_index?: QaTestIndex | null;
+  review_brief?: ReviewBrief | null;
 }
 
 export interface DashboardStatusPayload {
   index: FeaturesIndex;
   features: FeatureSummary[];
+  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[] };
 }