helixevo 0.7.0 → 0.8.0

package/dashboard/app/topology/client.tsx

@@ -56,6 +56,12 @@ function toneForChange(changeType: string): 'blue' | 'green' | 'purple' | 'yello
   return 'neutral'
 }
 
+function toneForOptimizeStatus(status: TopologyDashboardSummary['optimizeStatus']['status']): 'green' | 'yellow' | 'neutral' {
+  if (status === 'healthy') return 'green'
+  if (status === 'partial' || status === 'failed') return 'yellow'
+  return 'neutral'
+}
+
 function consoleTone(state: RunState): 'neutral' | 'green' | 'red' | 'yellow' {
   if (state === 'success') return 'green'
   if (state === 'error') return 'red'
@@ -247,6 +253,7 @@ export default function TopologyClient({
           { label: `${dashboard.summary.open} open reviews`, tone: dashboard.summary.open > 0 ? 'yellow' : 'green' },
           { label: `${dashboard.execution.prepared} prepared`, tone: dashboard.execution.prepared > 0 ? 'blue' : 'neutral' },
           { label: `${dashboard.execution.applied} applied`, tone: dashboard.execution.applied > 0 ? 'green' : 'neutral' },
+          { label: `optimize: ${dashboard.optimizeStatus.status}`, tone: toneForOptimizeStatus(dashboard.optimizeStatus.status) },
           { label: `${proof.summary.reviewOpen} proof review`, tone: proof.summary.reviewOpen > 0 ? 'yellow' : proof.summary.effective > 0 ? 'green' : 'neutral' },
           { label: formatMode(dashboard.governance.activeMode), tone: toneForMode(dashboard.governance.activeMode) },
           { label: dashboard.governance.source === 'operator-selected' ? 'operator-steered' : 'derived mode', tone: dashboard.governance.source === 'operator-selected' ? 'purple' : 'neutral' },
@@ -258,9 +265,15 @@ export default function TopologyClient({
               <div className="hero-note-title">{formatMode(dashboard.governance.activeMode)}</div>
               <div className="hero-note-copy">{dashboard.governance.profile.explanation}</div>
               <div style={{ marginTop: 8, display: 'flex', gap: 6, flexWrap: 'wrap' }}>
+                <span className={`badge badge-${dashboard.optimizeStatus.status === 'healthy' ? 'green' : dashboard.optimizeStatus.status === 'idle' ? 'gray' : 'yellow'}`}>optimize {dashboard.optimizeStatus.status}</span>
                 <span className="badge badge-gray">{proof.summary.effective} effective records</span>
                 <Link href="/proof" className="badge badge-gray" style={{ textDecoration: 'none' }}>open proof</Link>
               </div>
+              {dashboard.optimizeStatus.status !== 'idle' ? (
+                <div style={{ marginTop: 10, fontSize: 12, color: 'var(--text-dim)', lineHeight: 1.6 }}>
+                  {dashboard.optimizeStatus.summary}
+                </div>
+              ) : null}
             </div>
             <div style={{ display: 'grid', gap: 10 }}>
               <div style={{ display: 'flex', gap: 10, flexWrap: 'wrap', justifyContent: 'flex-end' }}>
@@ -284,6 +297,32 @@ export default function TopologyClient({
         <MetricCard label="Snapshots" value={dashboard.execution.snapshots} sublabel="before/after state preserved for reviewed execution" tone="purple" icon="◎" />
       </div>
 
+      <SectionFrame
+        eyebrow="Latest optimize run"
+        title="Full vs partial structural refresh is now explicit"
+        description="Queue refresh and conflict enrichment are tracked separately so a degraded optimize run can still expose a real review queue without pretending the full enrichment pass succeeded."
+        tone={toneForOptimizeStatus(dashboard.optimizeStatus.status)}
+      >
+        <div style={{ display: 'grid', gap: 12 }}>
+          <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
+            <span className={`badge badge-${dashboard.optimizeStatus.status === 'healthy' ? 'green' : dashboard.optimizeStatus.status === 'idle' ? 'gray' : 'yellow'}`}>{dashboard.optimizeStatus.status}</span>
+            <span className="badge badge-gray">queue {dashboard.optimizeStatus.queue.total} total • {dashboard.optimizeStatus.queue.open} open</span>
+            <span className="badge badge-gray">created {dashboard.optimizeStatus.queue.created} • updated {dashboard.optimizeStatus.queue.updated}</span>
+            <span className="badge badge-gray">enrichment {dashboard.optimizeStatus.enrichment.resolved} resolved • {dashboard.optimizeStatus.enrichment.failed} failed • {dashboard.optimizeStatus.enrichment.skipped} skipped</span>
+            {dashboard.optimizeStatus.ranAt ? <span className="badge badge-gray">ran {formatDate(dashboard.optimizeStatus.ranAt)}</span> : null}
+          </div>
+          <div className="signal-text">{dashboard.optimizeStatus.summary}</div>
+          {dashboard.optimizeStatus.nextStep ? <div className="signal-text">→ {dashboard.optimizeStatus.nextStep}</div> : null}
+          {dashboard.optimizeStatus.notices.length > 0 ? (
+            <div style={{ display: 'grid', gap: 4 }}>
+              {dashboard.optimizeStatus.notices.slice(0, 3).map((notice, index) => (
+                <div key={`${dashboard.optimizeStatus.status}-${index}`} className="signal-text">• {notice}</div>
+              ))}
+            </div>
+          ) : null}
+        </div>
+      </SectionFrame>
+
       <SectionFrame
         eyebrow="Execution pipeline"
         title="Accepted review can now become prepared and applied structure"

package/dashboard/lib/data.ts

@@ -512,10 +512,94 @@ export interface CoEvolutionDashboardSummary {
   recentTopologyDecisions: ResolvedTopologyReviewCandidate[]
 }
 
+export type TopologyOptimizeStatusKind = 'idle' | 'healthy' | 'partial' | 'failed'
+export type TopologyOptimizeFailureKind = 'auth' | 'timeout' | 'spawn' | 'llm' | 'unknown'
+
+export interface TopologyOptimizeStatus {
+  command: 'graph-optimize'
+  status: TopologyOptimizeStatusKind
+  ranAt?: string
+  summary: string
+  nextStep?: string
+  notices: string[]
+  queue: {
+    total: number
+    open: number
+    created: number
+    updated: number
+  }
+  enrichment: {
+    attempted: number
+    resolved: number
+    failed: number
+    skipped: number
+    degraded: boolean
+    failureKind?: TopologyOptimizeFailureKind
+    warning?: string
+  }
+}
+
+export type LLMProviderId = 'claude-code' | 'codex' | 'ollama'
+export type LLMFallbackPolicy = 'disabled' | 'on-failure'
+export type LLMProviderHealthStatus = 'healthy' | 'degraded' | 'unavailable' | 'unknown'
+export type LLMProviderFailureKind = 'auth' | 'timeout' | 'spawn' | 'network' | 'not-installed' | 'not-configured' | 'model-missing' | 'unknown'
+export type LLMCapability = 'chat' | 'json' | 'judge' | 'web-search'
+
+export interface LLMProviderSnapshot {
+  provider: LLMProviderId
+  configured: boolean
+  enabled: boolean
+  installed: boolean
+  available: boolean
+  loggedIn?: boolean
+  authMethod?: string
+  apiProvider?: string
+  status: LLMProviderHealthStatus
+  model?: string
+  judgeModel?: string
+  summary: string
+  nextStep?: string
+  failureKind?: LLMProviderFailureKind
+  warning?: string
+  notices: string[]
+  lastCheckedAt?: string
+  lastSelectedAt?: string
+  lastUsedAt?: string
+  lastSucceededAt?: string
+  lastFailedAt?: string
+  lastFailureMessage?: string
+}
+
+export interface LLMExecutionRecord {
+  capability: LLMCapability
+  scope: 'shared' | 'claude-only'
+  selectionMode: 'default' | 'explicit'
+  selectedProvider: LLMProviderId
+  attemptedProviders: LLMProviderId[]
+  usedProvider?: LLMProviderId
+  fallbackUsed: boolean
+  success: boolean
+  ranAt: string
+  summary: string
+  nextStep?: string
+  failureKind?: LLMProviderFailureKind
+  warning?: string
+}
+
+export interface LLMRuntimeState {
+  updatedAt: string
+  defaultProvider: LLMProviderId
+  fallbackPolicy: LLMFallbackPolicy
+  fallbackOrder: LLMProviderId[]
+  lastExecution?: LLMExecutionRecord
+  providers: Record<LLMProviderId, LLMProviderSnapshot>
+}
+
 export interface TopologyDashboardSummary {
   governance: ActiveGovernanceSummary
   summary: CoEvolutionDashboardSummary['topologyReviews']
   execution: CoEvolutionDashboardSummary['topologyExecution']
+  optimizeStatus: TopologyOptimizeStatus
   backlog: ResolvedTopologyReviewCandidate[]
   recentDecisions: ResolvedTopologyReviewCandidate[]
   acceptedReady: ResolvedTopologyReviewCandidate[]
@@ -1407,15 +1491,108 @@ export function getTopologyReviewSummary() {
   }
 }
 
+const DEFAULT_TOPOLOGY_OPTIMIZE_STATUS: TopologyOptimizeStatus = {
+  command: 'graph-optimize',
+  status: 'idle',
+  summary: 'No optimize run recorded yet.',
+  notices: [],
+  queue: {
+    total: 0,
+    open: 0,
+    created: 0,
+    updated: 0,
+  },
+  enrichment: {
+    attempted: 0,
+    resolved: 0,
+    failed: 0,
+    skipped: 0,
+    degraded: false,
+  },
+}
+
+export function loadTopologyOptimizeStatus(): TopologyOptimizeStatus {
+  return readJson<TopologyOptimizeStatus>('topology-optimize-status.json', DEFAULT_TOPOLOGY_OPTIMIZE_STATUS)
+}
+
+const DEFAULT_LLM_RUNTIME_STATE: LLMRuntimeState = {
+  updatedAt: new Date(0).toISOString(),
+  defaultProvider: 'claude-code',
+  fallbackPolicy: 'disabled',
+  fallbackOrder: [],
+  providers: {
+    'claude-code': {
+      provider: 'claude-code',
+      configured: true,
+      enabled: true,
+      installed: false,
+      available: false,
+      status: 'unknown',
+      model: 'sonnet',
+      judgeModel: 'sonnet',
+      summary: 'No Claude provider health has been recorded yet.',
+      notices: [],
+    },
+    codex: {
+      provider: 'codex',
+      configured: false,
+      enabled: false,
+      installed: false,
+      available: false,
+      status: 'unknown',
+      model: 'gpt-5-codex',
+      judgeModel: 'gpt-5-codex',
+      summary: 'No Codex provider health has been recorded yet.',
+      notices: [],
+    },
+    ollama: {
+      provider: 'ollama',
+      configured: false,
+      enabled: false,
+      installed: false,
+      available: false,
+      status: 'unknown',
+      model: 'qwen3-coder:latest',
+      judgeModel: 'qwen3-coder:latest',
+      summary: 'No Ollama provider health has been recorded yet.',
+      notices: [],
+    },
+  },
+}
+
+export function loadLlmRuntimeState(): LLMRuntimeState {
+  const state = readJson<LLMRuntimeState>('llm-runtime-state.json', DEFAULT_LLM_RUNTIME_STATE)
+  return {
+    ...DEFAULT_LLM_RUNTIME_STATE,
+    ...state,
+    providers: {
+      'claude-code': {
+        ...DEFAULT_LLM_RUNTIME_STATE.providers['claude-code'],
+        ...(state.providers?.['claude-code'] ?? {}),
+      },
+      codex: {
+        ...DEFAULT_LLM_RUNTIME_STATE.providers.codex,
+        ...(state.providers?.codex ?? {}),
+      },
+      ollama: {
+        ...DEFAULT_LLM_RUNTIME_STATE.providers.ollama,
+        ...(state.providers?.ollama ?? {}),
+      },
+    },
+  }
+}
+
 export function loadTopologyDashboardSummary(): TopologyDashboardSummary {
   const governance = getActiveGovernanceSummary()
   const summary = getTopologyReviewSummary()
   const execution = getTopologyExecutionSummary()
+  const optimizeStatus = loadTopologyOptimizeStatus()
   const candidates = loadResolvedTopologyReviewCandidates()
   return {
     governance,
     summary,
     execution,
+    optimizeStatus,
     backlog: summary.backlog,
     recentDecisions: summary.recentDecisions,
     acceptedReady: execution.acceptedReady,

package/dashboard/lib/release-spotlight.ts

@@ -1,17 +1,17 @@
 export const CURRENT_RELEASE_SPOTLIGHT = {
-  version: '0.7.0',
-  title: 'What changed in 0.7.0',
+  version: '0.8.0',
+  title: 'What changed in 0.8.0',
   summary:
-    'This release turns Prove into a first-class operator stage: HelixEvo now unifies bounded outcome attribution across interventions, semantic adoption, topology execution, transfer, and legacy evolution impact.',
+    'This grouped release hardens HelixEvo’s actuation layer and makes provider control explicit: optimize/reporting is more truthful under degraded conditions, Claude Code stays the default provider, and Codex plus Ollama become optional backends for supported shared paths.',
   bullets: [
-    'HelixEvo now ships a dedicated Proof route and proof review API instead of treating metrics alone as the full prove surface.',
-    'Overview, Co-Evolution, Ontology, and Topology now expose proof visibility and direct handoffs into bounded outcome review.',
-    'The operator loop now lands Prove on /proof, keeping navigation, handoffs, Commands, and Guide aligned with the shipped product.',
-    'Proof remains deliberately bounded: measuring, mixed, regressed, and insufficient-evidence states stay visible instead of being overclaimed as certainty.',
+    'HelixEvo now preserves useful topology review refreshes even when conflict enrichment degrades, and it records the difference explicitly instead of hiding it behind brittle failure.',
+    'Provider control is now first-class: status and Overview show default provider, degraded state, last execution truth, and fallback usage instead of treating backend execution as a hidden monolith.',
+    'Claude Code remains the default provider, while GPT Codex and Ollama are available as optional providers for shared prompt-in / text-out operations.',
+    'Claude-backed web search and research remain explicitly Claude-scoped, preserving capability truth instead of pretending full provider symmetry where it does not exist yet.',
   ],
   nextActions: [
-    { label: 'Open proof control', href: '/proof', tone: 'blue' as const },
-    { label: 'Inspect co-evolution', href: '/coevolution', tone: 'purple' as const },
-    { label: 'Read proof + metrics', href: '/guide#metrics', tone: 'green' as const },
+    { label: 'Inspect backend truth', href: '/commands', tone: 'blue' as const },
+    { label: 'Review topology state', href: '/topology', tone: 'purple' as const },
+    { label: 'Read provider guide', href: '/guide#config', tone: 'green' as const },
   ],
 } as const