Spaces:

GaryLeckey
/

aureon-os

Running

aureon-os / frontend /src /services /aureonAutonomousFrontend.ts

Deploy Aureon OS (deploy/selfhost stack: nginx edge + fusion API x2 + console + HNC organ + redis + postgres; paper mode) (part 18)

f568a4f verified 2 days ago

Raw History Blame Contribute Delete

18 kB

export interface SaaSInventorySummary {
  surface_count?: number;
  frontend_surface_count?: number;
  supabase_function_count?: number;
  legacy_dashboard_count?: number;
  generated_accounting_html_count?: number;
  orphaned_frontend_count?: number;
  security_blocker_count?: number;
  uncalled_supabase_function_count?: number;
  missing_supabase_function_call_count?: number;
}

export interface SaaSInventorySurface {
  id: string;
  path: string;
  name: string;
  kind: string;
  domain: string;
  purpose: string;
  owner_subsystem: string;
  wiring_status: string;
  safety_class: string;
  auth_requirement: string;
  missing_next_step?: string;
  called_apis?: string[];
}

export interface SaaSInventoryManifest {
  status?: string;
  generated_at?: string;
  summary?: SaaSInventorySummary;
  counts?: Record<string, Record<string, number>>;
  gaps?: Record<string, unknown>;
  surfaces?: SaaSInventorySurface[];
}

export interface FrontendScreenPlan {
  id: string;
  title: string;
  domain: string;
  goal: string;
  source_surface_count: number;
  canonical_sources: string[];
  migrated_components: string[];
  embedded_legacy_surfaces: string[];
  backend_functions: string[];
  generated_outputs: string[];
  safety_notes: string[];
  missing_capabilities: string[];
}

export interface FrontendUnificationManifest {
  status?: string;
  generated_at?: string;
  summary?: {
    screen_count?: number;
    migration_action_count?: number;
    missing_screen_capability_count?: number;
    source_surface_count?: number;
    security_blocker_count?: number;
    frontend_surface_count?: number;
    supabase_function_count?: number;
  };
  canonical_screens?: FrontendScreenPlan[];
  migration_actions?: Array<Record<string, unknown>>;
  duplicate_dashboard_groups?: Array<Record<string, unknown>>;
  safety_contract?: Record<string, boolean>;
  observation_loop?: Record<string, unknown>;
}

export interface OrganismDomainPulse {
  id: string;
  label: string;
  domain: string;
  status: string;
  freshness: string;
  source_path: string;
  generated_at?: string;
  age_seconds?: number;
  summary?: Record<string, unknown>;
  metrics?: Record<string, unknown>;
  blind_spots?: string[];
  display_state?: string;
  next_action?: string;
}

export interface OrganismBlindSpot {
  id: string;
  severity: string;
  domain: string;
  issue: string;
  evidence?: Record<string, unknown>;
  next_action?: string;
}

export interface OrganismRuntimeManifest {
  status?: string;
  generated_at?: string;
  mode?: string;
  summary?: {
    domain_count?: number;
    blind_spot_count?: number;
    high_blind_spot_count?: number;
    fresh_domain_count?: number;
    stale_domain_count?: number;
    missing_domain_count?: number;
    attention_domain_count?: number;
    refresh_count?: number;
    failed_refresh_count?: number;
    runtime_feed_status?: string;
    frontend_public_manifest_count?: number;
  };
  safety?: Record<string, unknown>;
  domains?: OrganismDomainPulse[];
  blind_spots?: OrganismBlindSpot[];
  data_freshness?: Record<string, unknown>;
  refresh_results?: Array<Record<string, unknown>>;
  real_time_feeds?: Record<string, unknown>;
  status_lines?: string[];
  next_actions?: string[];
}

export interface FrontendEvolutionWorkOrder {
  id: string;
  title: string;
  source_path: string;
  source_kind: string;
  source_domain: string;
  target_screen: string;
  target_title: string;
  priority: number;
  status: string;
  capability_summary: string;
  evidence?: Record<string, unknown>;
  data_contract?: Record<string, unknown>;
  frontend_action?: string;
  safety_boundary?: string;
  acceptance_tests?: string[];
  next_action?: string;
}

export interface FrontendEvolutionQueueManifest {
  status?: string;
  generated_at?: string;
  summary?: {
    queue_count?: number;
    ready_adapter_count?: number;
    blocked_count?: number;
    archive_candidate_count?: number;
    generated_output_link_count?: number;
    target_screen_count?: number;
    highest_priority?: number;
  };
  work_orders?: FrontendEvolutionWorkOrder[];
  counts?: Record<string, Record<string, number>>;
  safety_contract?: Record<string, boolean>;
  notes?: string[];
}

export interface CapabilityMode {
  id: string;
  title: string;
  domain: string;
  authority_level: string;
  status: string;
  autonomous_allowed: boolean;
  triggers?: string[];
  systems?: string[];
  data_sources?: string[];
  hnc_checks?: string[];
  safe_actions?: string[];
  blocked_actions?: string[];
  frontend_contract?: Record<string, unknown>;
  next_action?: string;
}

export interface PresentationIntent {
  id: string;
  title: string;
  display_mode: string;
  target_screen: string;
  priority: number;
  status: string;
  reason: string;
  source_paths?: string[];
  generated_artifact_contract?: Record<string, unknown>;
  hnc_evidence?: Record<string, unknown>;
  next_action?: string;
}

export interface CapabilitySwitchboardManifest {
  status?: string;
  generated_at?: string;
  goal?: string;
  summary?: {
    capability_count?: number;
    autonomous_capability_count?: number;
    blocked_capability_count?: number;
    presentation_intent_count?: number;
    blocker_count?: number;
    frontend_work_order_count?: number;
    ready_adapter_count?: number;
    security_blocker_count?: number;
    runtime_feed_status?: string;
    canonical_screen_count?: number;
  };
  capability_modes?: CapabilityMode[];
  presentation_intents?: PresentationIntent[];
  route_map?: Record<string, unknown>;
  hnc_control_contract?: Record<string, unknown>;
  safety_contract?: Record<string, boolean>;
  blockers?: Array<Record<string, unknown>>;
  notes?: string[];
}

export interface UnifiedFrontendState {
  loadedAt: string;
  inventorySource: string;
  planSource: string;
  organismSource: string;
  evolutionSource: string;
  switchboardSource: string;
  inventory: SaaSInventoryManifest;
  plan: FrontendUnificationManifest;
  organism: OrganismRuntimeManifest;
  evolution: FrontendEvolutionQueueManifest;
  switchboard: CapabilitySwitchboardManifest;
  errors: string[];
}

const emptyInventory: SaaSInventoryManifest = {
  status: "manifest_missing",
  summary: {
    surface_count: 0,
    frontend_surface_count: 0,
    supabase_function_count: 0,
    security_blocker_count: 0,
    orphaned_frontend_count: 0,
  },
  counts: {},
  gaps: {},
  surfaces: [],
};

const fallbackPlan: FrontendUnificationManifest = {
  status: "manifest_missing",
  summary: {
    screen_count: 7,
    migration_action_count: 0,
    missing_screen_capability_count: 7,
    source_surface_count: 0,
    security_blocker_count: 0,
    frontend_surface_count: 0,
    supabase_function_count: 0,
  },
  canonical_screens: [
    {
      id: "overview",
      title: "Overview",
      domain: "operator",
      goal: "Show organism state, active goals, ThoughtBus health, blockers, and what Aureon is doing now.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: [],
      missing_capabilities: ["Generate aureon_frontend_unification_plan.json."],
    },
    {
      id: "trading",
      title: "Trading",
      domain: "trading",
      goal: "Observe dynamic margin, positions, risk, live/sim status, and decision audit.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: ["live orders remain behind runtime trading gates"],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
    {
      id: "accounting",
      title: "Accounting",
      domain: "accounting",
      goal: "Show company accounts status, evidence, generated packs, and manual filing checklist.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: ["Companies House and HMRC submission remain manual"],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
    {
      id: "research",
      title: "Research",
      domain: "research",
      goal: "Show vault sources, research reports, source ingestion, and knowledge coverage.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: [],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
    {
      id: "saas_security",
      title: "SaaS Security",
      domain: "saas_security",
      goal: "Show auth, tenant isolation, authorized attack-lab findings, fixes, and release gates.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: ["production deployment requires release-gate evidence"],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
    {
      id: "self_improvement",
      title: "Self-Improvement",
      domain: "autonomy",
      goal: "Show audits, benchmarks, queued fixes, retest loop, and restart/apply handoff.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: ["code apply/restart approval when required"],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
    {
      id: "admin",
      title: "Admin",
      domain: "admin",
      goal: "Show env checks, integrations, credentials status, safety gates, and manual-only actions.",
      source_surface_count: 0,
      canonical_sources: [],
      migrated_components: [],
      embedded_legacy_surfaces: [],
      backend_functions: [],
      generated_outputs: [],
      safety_notes: ["credential values stay hidden"],
      missing_capabilities: ["Generate the SaaS inventory."],
    },
  ],
  migration_actions: [],
  duplicate_dashboard_groups: [],
  safety_contract: {
    human_observes_aureon_works: true,
    live_trading_requires_existing_runtime_gates: true,
    official_filing_and_payments_manual_only: true,
    credentials_status_visible_secret_values_hidden: true,
    security_blockers_visible: true,
    legacy_dashboards_preserved_until_migrated: true,
  },
};

const emptyOrganism: OrganismRuntimeManifest = {
  status: "manifest_missing",
  mode: "safe_observation",
  summary: {
    domain_count: 0,
    blind_spot_count: 1,
    high_blind_spot_count: 1,
    fresh_domain_count: 0,
    stale_domain_count: 0,
    missing_domain_count: 1,
    attention_domain_count: 0,
    refresh_count: 0,
    failed_refresh_count: 0,
    runtime_feed_status: "unknown",
    frontend_public_manifest_count: 0,
  },
  safety: {
    observer_only: true,
    live_orders_allowed: false,
    official_filing_allowed: false,
    payments_allowed: false,
    external_mutations_allowed: false,
  },
  domains: [],
  blind_spots: [
    {
      id: "organism_runtime_status.missing",
      severity: "high",
      domain: "runtime",
      issue: "Organism runtime status manifest is not mounted in frontend/public.",
      next_action: "Run python -m aureon.autonomous.aureon_organism_runtime_observer --refresh-core.",
    },
  ],
  status_lines: ["Organism pulse manifest missing."],
  next_actions: ["Run python -m aureon.autonomous.aureon_organism_runtime_observer --refresh-core."],
};

const emptyEvolution: FrontendEvolutionQueueManifest = {
  status: "manifest_missing",
  summary: {
    queue_count: 0,
    ready_adapter_count: 0,
    blocked_count: 0,
    archive_candidate_count: 0,
    generated_output_link_count: 0,
    target_screen_count: 0,
    highest_priority: 0,
  },
  work_orders: [],
  counts: {},
  safety_contract: {
    proposal_only: true,
    legacy_systems_not_executed: true,
    read_only_frontend_adapters_first: true,
    no_live_trading: true,
    no_official_filing: true,
    no_payments: true,
    secret_values_hidden: true,
    apply_requires_explicit_handoff: true,
  },
  notes: ["Frontend evolution queue manifest is missing."],
};

const emptySwitchboard: CapabilitySwitchboardManifest = {
  status: "manifest_missing",
  goal: "Select the safest available Aureon capability and presentation surface.",
  summary: {
    capability_count: 0,
    autonomous_capability_count: 0,
    blocked_capability_count: 1,
    presentation_intent_count: 0,
    blocker_count: 1,
    frontend_work_order_count: 0,
    ready_adapter_count: 0,
    security_blocker_count: 0,
    runtime_feed_status: "unknown",
    canonical_screen_count: 0,
  },
  capability_modes: [],
  presentation_intents: [],
  route_map: {},
  hnc_control_contract: {
    anti_hallucination_gates: ["source_evidence_required", "safe_authority_boundary_checked"],
  },
  safety_contract: {
    llm_can_select_capability: true,
    llm_can_create_presentation_intents: true,
    llm_can_place_direct_live_orders: false,
    llm_can_file_hmrc_or_companies_house: false,
    llm_can_make_payments: false,
    llm_can_attack_third_party_targets: false,
    secret_values_hidden: true,
  },
  blockers: [
    {
      id: "capability_switchboard.missing",
      severity: "high",
      reason: "Capability switchboard manifest is not mounted in frontend/public.",
    },
  ],
  notes: ["Capability switchboard manifest is missing."],
};

async function fetchJson<T>(url: string): Promise<T | null> {
  try {
    const response = await fetch(url, { cache: "no-store" });
    if (!response.ok) return null;
    return (await response.json()) as T;
  } catch {
    return null;
  }
}

// Where the live-rendered manifests come from. Default "" keeps the dev
// behaviour (static files in frontend/public). The production build sets
// VITE_AUREON_MANIFEST_BASE=/api/manifests so the gateway renders them live
// through the nginx /api proxy. Manifests the gateway doesn't serve fall back
// to the static path automatically (fetchJson returns null on 404).
const MANIFEST_BASE = ((import.meta.env.VITE_AUREON_MANIFEST_BASE as string | undefined) ?? "").replace(/\/$/, "");

async function fetchManifest<T>(filename: string): Promise<{ data: T | null; source: string }> {
  if (MANIFEST_BASE) {
    const liveUrl = `${MANIFEST_BASE}/${filename}`;
    const live = await fetchJson<T>(liveUrl);
    if (live) return { data: live, source: liveUrl };
  }
  const staticUrl = `/${filename}`;
  return { data: await fetchJson<T>(staticUrl), source: staticUrl };
}

export async function loadUnifiedFrontendState(): Promise<UnifiedFrontendState> {
  const errors: string[] = [];
  const [inventoryRes, planRes, organismRes, evolutionRes, switchboardRes] = await Promise.all([
    fetchManifest<SaaSInventoryManifest>("aureon_saas_system_inventory.json"),
    fetchManifest<FrontendUnificationManifest>("aureon_frontend_unification_plan.json"),
    fetchManifest<OrganismRuntimeManifest>("aureon_organism_runtime_status.json"),
    fetchManifest<FrontendEvolutionQueueManifest>("aureon_frontend_evolution_queue.json"),
    fetchManifest<CapabilitySwitchboardManifest>("aureon_autonomous_capability_switchboard.json"),
  ]);
  const inventory = inventoryRes.data;
  const plan = planRes.data;
  const organism = organismRes.data;
  const evolution = evolutionRes.data;
  const switchboard = switchboardRes.data;

  if (!inventory) errors.push("SaaS inventory manifest is not mounted in frontend/public.");
  if (!plan) errors.push("Frontend unification manifest is not mounted in frontend/public.");
  if (!organism) errors.push("Organism runtime status manifest is not mounted in frontend/public.");
  if (!evolution) errors.push("Frontend evolution queue manifest is not mounted in frontend/public.");
  if (!switchboard) errors.push("Autonomous capability switchboard manifest is not mounted in frontend/public.");

  return {
    loadedAt: new Date().toISOString(),
    inventorySource: inventory ? inventoryRes.source : "fallback",
    planSource: plan ? planRes.source : "fallback",
    organismSource: organism ? organismRes.source : "fallback",
    evolutionSource: evolution ? evolutionRes.source : "fallback",
    switchboardSource: switchboard ? switchboardRes.source : "fallback",
    inventory: inventory || emptyInventory,
    plan: plan || fallbackPlan,
    organism: organism || emptyOrganism,
    evolution: evolution || emptyEvolution,
    switchboard: switchboard || emptySwitchboard,
    errors,
  };
}

export function surfaceCountByDomain(inventory: SaaSInventoryManifest): Record<string, number> {
  return inventory.counts?.by_domain || {};
}

export function surfacesForScreen(inventory: SaaSInventoryManifest, screen: FrontendScreenPlan): SaaSInventorySurface[] {
  const keywords = [screen.id, screen.domain, ...screen.title.toLowerCase().split(/\s+/)];
  return (inventory.surfaces || [])
    .filter((surface) => {
      const haystack = `${surface.path} ${surface.domain} ${surface.kind} ${surface.purpose}`.toLowerCase();
      return surface.domain === screen.domain || keywords.some((keyword) => keyword && haystack.includes(keyword));
    })
    .slice(0, 12);
}

	export interface SaaSInventorySummary {
	surface_count?: number;
	frontend_surface_count?: number;
	supabase_function_count?: number;
	legacy_dashboard_count?: number;
	generated_accounting_html_count?: number;
	orphaned_frontend_count?: number;
	security_blocker_count?: number;
	uncalled_supabase_function_count?: number;
	missing_supabase_function_call_count?: number;
	}

	export interface SaaSInventorySurface {
	id: string;
	path: string;
	name: string;
	kind: string;
	domain: string;
	purpose: string;
	owner_subsystem: string;
	wiring_status: string;
	safety_class: string;
	auth_requirement: string;
	missing_next_step?: string;
	called_apis?: string[];
	}

	export interface SaaSInventoryManifest {
	status?: string;
	generated_at?: string;
	summary?: SaaSInventorySummary;
	counts?: Record<string, Record<string, number>>;
	gaps?: Record<string, unknown>;
	surfaces?: SaaSInventorySurface[];
	}

	export interface FrontendScreenPlan {
	id: string;
	title: string;
	domain: string;
	goal: string;
	source_surface_count: number;
	canonical_sources: string[];
	migrated_components: string[];
	embedded_legacy_surfaces: string[];
	backend_functions: string[];
	generated_outputs: string[];
	safety_notes: string[];
	missing_capabilities: string[];
	}

	export interface FrontendUnificationManifest {
	status?: string;
	generated_at?: string;
	summary?: {
	screen_count?: number;
	migration_action_count?: number;
	missing_screen_capability_count?: number;
	source_surface_count?: number;
	security_blocker_count?: number;
	frontend_surface_count?: number;
	supabase_function_count?: number;
	};
	canonical_screens?: FrontendScreenPlan[];
	migration_actions?: Array<Record<string, unknown>>;
	duplicate_dashboard_groups?: Array<Record<string, unknown>>;
	safety_contract?: Record<string, boolean>;
	observation_loop?: Record<string, unknown>;
	}

	export interface OrganismDomainPulse {
	id: string;
	label: string;
	domain: string;
	status: string;
	freshness: string;
	source_path: string;
	generated_at?: string;
	age_seconds?: number;
	summary?: Record<string, unknown>;
	metrics?: Record<string, unknown>;
	blind_spots?: string[];
	display_state?: string;
	next_action?: string;
	}

	export interface OrganismBlindSpot {
	id: string;
	severity: string;
	domain: string;
	issue: string;
	evidence?: Record<string, unknown>;
	next_action?: string;
	}

	export interface OrganismRuntimeManifest {
	status?: string;
	generated_at?: string;
	mode?: string;
	summary?: {
	domain_count?: number;
	blind_spot_count?: number;
	high_blind_spot_count?: number;
	fresh_domain_count?: number;
	stale_domain_count?: number;
	missing_domain_count?: number;
	attention_domain_count?: number;
	refresh_count?: number;
	failed_refresh_count?: number;
	runtime_feed_status?: string;
	frontend_public_manifest_count?: number;
	};
	safety?: Record<string, unknown>;
	domains?: OrganismDomainPulse[];
	blind_spots?: OrganismBlindSpot[];
	data_freshness?: Record<string, unknown>;
	refresh_results?: Array<Record<string, unknown>>;
	real_time_feeds?: Record<string, unknown>;
	status_lines?: string[];
	next_actions?: string[];
	}

	export interface FrontendEvolutionWorkOrder {
	id: string;
	title: string;
	source_path: string;
	source_kind: string;
	source_domain: string;
	target_screen: string;
	target_title: string;
	priority: number;
	status: string;
	capability_summary: string;
	evidence?: Record<string, unknown>;
	data_contract?: Record<string, unknown>;
	frontend_action?: string;
	safety_boundary?: string;
	acceptance_tests?: string[];
	next_action?: string;
	}

	export interface FrontendEvolutionQueueManifest {
	status?: string;
	generated_at?: string;
	summary?: {
	queue_count?: number;
	ready_adapter_count?: number;
	blocked_count?: number;
	archive_candidate_count?: number;
	generated_output_link_count?: number;
	target_screen_count?: number;
	highest_priority?: number;
	};
	work_orders?: FrontendEvolutionWorkOrder[];
	counts?: Record<string, Record<string, number>>;
	safety_contract?: Record<string, boolean>;
	notes?: string[];
	}

	export interface CapabilityMode {
	id: string;
	title: string;
	domain: string;
	authority_level: string;
	status: string;
	autonomous_allowed: boolean;
	triggers?: string[];
	systems?: string[];
	data_sources?: string[];
	hnc_checks?: string[];
	safe_actions?: string[];
	blocked_actions?: string[];
	frontend_contract?: Record<string, unknown>;
	next_action?: string;
	}

	export interface PresentationIntent {
	id: string;
	title: string;
	display_mode: string;
	target_screen: string;
	priority: number;
	status: string;
	reason: string;
	source_paths?: string[];
	generated_artifact_contract?: Record<string, unknown>;
	hnc_evidence?: Record<string, unknown>;
	next_action?: string;
	}

	export interface CapabilitySwitchboardManifest {
	status?: string;
	generated_at?: string;
	goal?: string;
	summary?: {
	capability_count?: number;
	autonomous_capability_count?: number;
	blocked_capability_count?: number;
	presentation_intent_count?: number;
	blocker_count?: number;
	frontend_work_order_count?: number;
	ready_adapter_count?: number;
	security_blocker_count?: number;
	runtime_feed_status?: string;
	canonical_screen_count?: number;
	};
	capability_modes?: CapabilityMode[];
	presentation_intents?: PresentationIntent[];
	route_map?: Record<string, unknown>;
	hnc_control_contract?: Record<string, unknown>;
	safety_contract?: Record<string, boolean>;
	blockers?: Array<Record<string, unknown>>;
	notes?: string[];
	}

	export interface UnifiedFrontendState {
	loadedAt: string;
	inventorySource: string;
	planSource: string;
	organismSource: string;
	evolutionSource: string;
	switchboardSource: string;
	inventory: SaaSInventoryManifest;
	plan: FrontendUnificationManifest;
	organism: OrganismRuntimeManifest;
	evolution: FrontendEvolutionQueueManifest;
	switchboard: CapabilitySwitchboardManifest;
	errors: string[];
	}

	const emptyInventory: SaaSInventoryManifest = {
	status: "manifest_missing",
	summary: {
	surface_count: 0,
	frontend_surface_count: 0,
	supabase_function_count: 0,
	security_blocker_count: 0,
	orphaned_frontend_count: 0,
	},
	counts: {},
	gaps: {},
	surfaces: [],
	};

	const fallbackPlan: FrontendUnificationManifest = {
	status: "manifest_missing",
	summary: {
	screen_count: 7,
	migration_action_count: 0,
	missing_screen_capability_count: 7,
	source_surface_count: 0,
	security_blocker_count: 0,
	frontend_surface_count: 0,
	supabase_function_count: 0,
	},
	canonical_screens: [
	{
	id: "overview",
	title: "Overview",
	domain: "operator",
	goal: "Show organism state, active goals, ThoughtBus health, blockers, and what Aureon is doing now.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: [],
	missing_capabilities: ["Generate aureon_frontend_unification_plan.json."],
	},
	{
	id: "trading",
	title: "Trading",
	domain: "trading",
	goal: "Observe dynamic margin, positions, risk, live/sim status, and decision audit.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: ["live orders remain behind runtime trading gates"],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	{
	id: "accounting",
	title: "Accounting",
	domain: "accounting",
	goal: "Show company accounts status, evidence, generated packs, and manual filing checklist.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: ["Companies House and HMRC submission remain manual"],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	{
	id: "research",
	title: "Research",
	domain: "research",
	goal: "Show vault sources, research reports, source ingestion, and knowledge coverage.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: [],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	{
	id: "saas_security",
	title: "SaaS Security",
	domain: "saas_security",
	goal: "Show auth, tenant isolation, authorized attack-lab findings, fixes, and release gates.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: ["production deployment requires release-gate evidence"],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	{
	id: "self_improvement",
	title: "Self-Improvement",
	domain: "autonomy",
	goal: "Show audits, benchmarks, queued fixes, retest loop, and restart/apply handoff.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: ["code apply/restart approval when required"],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	{
	id: "admin",
	title: "Admin",
	domain: "admin",
	goal: "Show env checks, integrations, credentials status, safety gates, and manual-only actions.",
	source_surface_count: 0,
	canonical_sources: [],
	migrated_components: [],
	embedded_legacy_surfaces: [],
	backend_functions: [],
	generated_outputs: [],
	safety_notes: ["credential values stay hidden"],
	missing_capabilities: ["Generate the SaaS inventory."],
	},
	],
	migration_actions: [],
	duplicate_dashboard_groups: [],
	safety_contract: {
	human_observes_aureon_works: true,
	live_trading_requires_existing_runtime_gates: true,
	official_filing_and_payments_manual_only: true,
	credentials_status_visible_secret_values_hidden: true,
	security_blockers_visible: true,
	legacy_dashboards_preserved_until_migrated: true,
	},
	};

	const emptyOrganism: OrganismRuntimeManifest = {
	status: "manifest_missing",
	mode: "safe_observation",
	summary: {
	domain_count: 0,
	blind_spot_count: 1,
	high_blind_spot_count: 1,
	fresh_domain_count: 0,
	stale_domain_count: 0,
	missing_domain_count: 1,
	attention_domain_count: 0,
	refresh_count: 0,
	failed_refresh_count: 0,
	runtime_feed_status: "unknown",
	frontend_public_manifest_count: 0,
	},
	safety: {
	observer_only: true,
	live_orders_allowed: false,
	official_filing_allowed: false,
	payments_allowed: false,
	external_mutations_allowed: false,
	},
	domains: [],
	blind_spots: [
	{
	id: "organism_runtime_status.missing",
	severity: "high",
	domain: "runtime",
	issue: "Organism runtime status manifest is not mounted in frontend/public.",
	next_action: "Run python -m aureon.autonomous.aureon_organism_runtime_observer --refresh-core.",
	},
	],
	status_lines: ["Organism pulse manifest missing."],
	next_actions: ["Run python -m aureon.autonomous.aureon_organism_runtime_observer --refresh-core."],
	};

	const emptyEvolution: FrontendEvolutionQueueManifest = {
	status: "manifest_missing",
	summary: {
	queue_count: 0,
	ready_adapter_count: 0,
	blocked_count: 0,
	archive_candidate_count: 0,
	generated_output_link_count: 0,
	target_screen_count: 0,
	highest_priority: 0,
	},
	work_orders: [],
	counts: {},
	safety_contract: {
	proposal_only: true,
	legacy_systems_not_executed: true,
	read_only_frontend_adapters_first: true,
	no_live_trading: true,
	no_official_filing: true,
	no_payments: true,
	secret_values_hidden: true,
	apply_requires_explicit_handoff: true,
	},
	notes: ["Frontend evolution queue manifest is missing."],
	};

	const emptySwitchboard: CapabilitySwitchboardManifest = {
	status: "manifest_missing",
	goal: "Select the safest available Aureon capability and presentation surface.",
	summary: {
	capability_count: 0,
	autonomous_capability_count: 0,
	blocked_capability_count: 1,
	presentation_intent_count: 0,
	blocker_count: 1,
	frontend_work_order_count: 0,
	ready_adapter_count: 0,
	security_blocker_count: 0,
	runtime_feed_status: "unknown",
	canonical_screen_count: 0,
	},
	capability_modes: [],
	presentation_intents: [],
	route_map: {},
	hnc_control_contract: {
	anti_hallucination_gates: ["source_evidence_required", "safe_authority_boundary_checked"],
	},
	safety_contract: {
	llm_can_select_capability: true,
	llm_can_create_presentation_intents: true,
	llm_can_place_direct_live_orders: false,
	llm_can_file_hmrc_or_companies_house: false,
	llm_can_make_payments: false,
	llm_can_attack_third_party_targets: false,
	secret_values_hidden: true,
	},
	blockers: [
	{
	id: "capability_switchboard.missing",
	severity: "high",
	reason: "Capability switchboard manifest is not mounted in frontend/public.",
	},
	],
	notes: ["Capability switchboard manifest is missing."],
	};

	async function fetchJson<T>(url: string): Promise<T \| null> {
	try {
	const response = await fetch(url, { cache: "no-store" });
	if (!response.ok) return null;
	return (await response.json()) as T;
	} catch {
	return null;
	}
	}

	// Where the live-rendered manifests come from. Default "" keeps the dev
	// behaviour (static files in frontend/public). The production build sets
	// VITE_AUREON_MANIFEST_BASE=/api/manifests so the gateway renders them live
	// through the nginx /api proxy. Manifests the gateway doesn't serve fall back
	// to the static path automatically (fetchJson returns null on 404).
	const MANIFEST_BASE = ((import.meta.env.VITE_AUREON_MANIFEST_BASE as string \| undefined) ?? "").replace(/\/$/, "");

	async function fetchManifest<T>(filename: string): Promise<{ data: T \| null; source: string }> {
	if (MANIFEST_BASE) {
	const liveUrl = `${MANIFEST_BASE}/${filename}`;
	const live = await fetchJson<T>(liveUrl);
	if (live) return { data: live, source: liveUrl };
	}
	const staticUrl = `/${filename}`;
	return { data: await fetchJson<T>(staticUrl), source: staticUrl };
	}

	export async function loadUnifiedFrontendState(): Promise<UnifiedFrontendState> {
	const errors: string[] = [];
	const [inventoryRes, planRes, organismRes, evolutionRes, switchboardRes] = await Promise.all([
	fetchManifest<SaaSInventoryManifest>("aureon_saas_system_inventory.json"),
	fetchManifest<FrontendUnificationManifest>("aureon_frontend_unification_plan.json"),
	fetchManifest<OrganismRuntimeManifest>("aureon_organism_runtime_status.json"),
	fetchManifest<FrontendEvolutionQueueManifest>("aureon_frontend_evolution_queue.json"),
	fetchManifest<CapabilitySwitchboardManifest>("aureon_autonomous_capability_switchboard.json"),
	]);
	const inventory = inventoryRes.data;
	const plan = planRes.data;
	const organism = organismRes.data;
	const evolution = evolutionRes.data;
	const switchboard = switchboardRes.data;

	if (!inventory) errors.push("SaaS inventory manifest is not mounted in frontend/public.");
	if (!plan) errors.push("Frontend unification manifest is not mounted in frontend/public.");
	if (!organism) errors.push("Organism runtime status manifest is not mounted in frontend/public.");
	if (!evolution) errors.push("Frontend evolution queue manifest is not mounted in frontend/public.");
	if (!switchboard) errors.push("Autonomous capability switchboard manifest is not mounted in frontend/public.");

	return {
	loadedAt: new Date().toISOString(),
	inventorySource: inventory ? inventoryRes.source : "fallback",
	planSource: plan ? planRes.source : "fallback",
	organismSource: organism ? organismRes.source : "fallback",
	evolutionSource: evolution ? evolutionRes.source : "fallback",
	switchboardSource: switchboard ? switchboardRes.source : "fallback",
	inventory: inventory \|\| emptyInventory,
	plan: plan \|\| fallbackPlan,
	organism: organism \|\| emptyOrganism,
	evolution: evolution \|\| emptyEvolution,
	switchboard: switchboard \|\| emptySwitchboard,
	errors,
	};
	}

	export function surfaceCountByDomain(inventory: SaaSInventoryManifest): Record<string, number> {
	return inventory.counts?.by_domain \|\| {};
	}

	export function surfacesForScreen(inventory: SaaSInventoryManifest, screen: FrontendScreenPlan): SaaSInventorySurface[] {
	const keywords = [screen.id, screen.domain, ...screen.title.toLowerCase().split(/\s+/)];
	return (inventory.surfaces \|\| [])
	.filter((surface) => {
	const haystack = `${surface.path} ${surface.domain} ${surface.kind} ${surface.purpose}`.toLowerCase();
	return surface.domain === screen.domain \|\| keywords.some((keyword) => keyword && haystack.includes(keyword));
	})
	.slice(0, 12);
	}