helixevo 0.2.24 → 0.2.26

package/dashboard/app/api/run/route.ts

@@ -3,7 +3,6 @@ import { spawn, type ChildProcess } from 'child_process'
 
 export const dynamic = 'force-dynamic'
 
-// Allowed commands — whitelist to prevent arbitrary execution
 const ALLOWED_COMMANDS: Record<string, { cmd: string; args: string[]; timeout: number }> = {
   'status':         { cmd: 'helixevo', args: ['status'],                           timeout: 15000 },
   'health':         { cmd: 'helixevo', args: ['health', '--verbose'],              timeout: 120000 },
@@ -19,93 +18,103 @@ const ALLOWED_COMMANDS: Record<string, { cmd: string; args: string[]; timeout: n
   'report':         { cmd: 'helixevo', args: ['report', '--days', '7'],            timeout: 30000 },
 }
 
-// Track the currently running process so it can be stopped
 let activeProcess: ChildProcess | null = null
 let activeCommand: string | null = null
 
+// POST — stream output via SSE
 export async function POST(request: Request) {
   const body = await request.json()
   const { command } = body as { command: string }
 
   const entry = ALLOWED_COMMANDS[command]
   if (!entry) {
-    return NextResponse.json({
-      success: false,
-      error: `Unknown command: ${command}`,
-    }, { status: 400 })
+    return NextResponse.json({ success: false, error: `Unknown command: ${command}` }, { status: 400 })
   }
 
-  // Kill any existing process before starting a new one
+  // Kill any existing process
   if (activeProcess && !activeProcess.killed) {
     activeProcess.kill('SIGTERM')
     activeProcess = null
     activeCommand = null
   }
 
-  return new Promise<Response>((resolve) => {
-    let output = ''
-    let timedOut = false
-
-    const child = spawn(entry.cmd, entry.args, {
-      env: { ...process.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-
-    activeProcess = child
-    activeCommand = command
-
-    const timeout = setTimeout(() => {
-      timedOut = true
-      child.kill('SIGTERM')
-    }, entry.timeout)
-
-    child.stdout?.on('data', (data: Buffer) => {
-      output += data.toString()
-    })
-
-    child.stderr?.on('data', (data: Buffer) => {
-      output += data.toString()
-    })
-
-    child.on('close', (code, signal) => {
-      clearTimeout(timeout)
-      activeProcess = null
-      activeCommand = null
-
-      if (signal === 'SIGTERM' && !timedOut) {
-        // Stopped by user
-        resolve(NextResponse.json({
-          success: false,
-          stopped: true,
-          output: output + '\n\n[Stopped by user]',
-        }))
-      } else if (timedOut) {
-        resolve(NextResponse.json({
-          success: false,
-          output: output + '\n\n[Timed out]',
-        }, { status: 500 }))
-      } else {
-        resolve(NextResponse.json({
-          success: code === 0,
-          command: `${entry.cmd} ${entry.args.join(' ')}`,
-          output: output || 'No output',
-        }, code === 0 ? {} : { status: 500 }))
+  const encoder = new TextEncoder()
+  let timedOut = false
+
+  const stream = new ReadableStream({
+    start(controller) {
+      const child = spawn(entry.cmd, entry.args, {
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      activeProcess = child
+      activeCommand = command
+
+      const timeout = setTimeout(() => {
+        timedOut = true
+        child.kill('SIGTERM')
+      }, entry.timeout)
+
+      const send = (event: string, data: string) => {
+        try {
+          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`))
+        } catch {}
       }
-    })
-
-    child.on('error', (err) => {
-      clearTimeout(timeout)
-      activeProcess = null
-      activeCommand = null
-      resolve(NextResponse.json({
-        success: false,
-        output: err.message,
-      }, { status: 500 }))
-    })
+
+      child.stdout?.on('data', (chunk: Buffer) => {
+        send('output', chunk.toString())
+      })
+
+      child.stderr?.on('data', (chunk: Buffer) => {
+        send('output', chunk.toString())
+      })
+
+      child.on('close', (code, signal) => {
+        clearTimeout(timeout)
+        activeProcess = null
+        activeCommand = null
+
+        if (signal === 'SIGTERM' && !timedOut) {
+          send('done', JSON.stringify({ success: false, stopped: true }))
+        } else if (timedOut) {
+          send('done', JSON.stringify({ success: false, timedOut: true }))
+        } else {
+          send('done', JSON.stringify({ success: code === 0 }))
+        }
+
+        try { controller.close() } catch {}
+      })
+
+      child.on('error', (err) => {
+        clearTimeout(timeout)
+        activeProcess = null
+        activeCommand = null
+        send('output', `Error: ${err.message}`)
+        send('done', JSON.stringify({ success: false }))
+        try { controller.close() } catch {}
+      })
+    },
+
+    cancel() {
+      if (activeProcess && !activeProcess.killed) {
+        activeProcess.kill('SIGTERM')
+        activeProcess = null
+        activeCommand = null
+      }
+    },
+  })
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
   })
 }
 
-// DELETE = stop the running command
+// DELETE = stop
 export async function DELETE() {
   if (activeProcess && !activeProcess.killed) {
     const cmd = activeCommand
@@ -117,7 +126,7 @@ export async function DELETE() {
   return NextResponse.json({ stopped: false, message: 'No running command' })
 }
 
-// GET = check if something is running
+// GET = check status
 export async function GET() {
   return NextResponse.json({
     running: activeProcess !== null && !activeProcess.killed,

package/dashboard/app/research/client.tsx

@@ -59,12 +59,13 @@ const PIPELINE_STEPS = [
 
 export default function ResearchClient({ buffer, projects }: Props) {
   const [runState, setRunState] = useState<RunState>('idle')
-  const [output, setOutput] = useState<string | null>(null)
+  const [output, setOutput] = useState<string>('')
   const abortRef = useRef<AbortController | null>(null)
+  const outputRef = useRef<HTMLPreElement | null>(null)
 
   const handleRun = async () => {
     setRunState('running')
-    setOutput(null)
+    setOutput('')
     const controller = new AbortController()
     abortRef.current = controller
 
@@ -75,21 +76,58 @@ export default function ResearchClient({ buffer, projects }: Props) {
         body: JSON.stringify({ command: 'research' }),
         signal: controller.signal,
       })
-      const data = await res.json()
-      if (data.stopped) {
-        setOutput(data.output ?? 'Stopped')
-        setRunState('stopped')
-      } else {
-        setOutput(data.output ?? data.error ?? 'No output')
-        setRunState(data.success ? 'success' : 'error')
+
+      if (!res.body) {
+        setOutput('No response body')
+        setRunState('error')
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let sseBuffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        sseBuffer += decoder.decode(value, { stream: true })
+        const events = sseBuffer.split('\n\n')
+        sseBuffer = events.pop() ?? ''
+
+        for (const event of events) {
+          const lines = event.split('\n')
+          let eventType = ''
+          let eventData = ''
+          for (const line of lines) {
+            if (line.startsWith('event: ')) eventType = line.slice(7)
+            if (line.startsWith('data: ')) eventData = line.slice(6)
+          }
+          if (eventType === 'output' && eventData) {
+            try {
+              const text = JSON.parse(eventData) as string
+              setOutput(prev => prev + text)
+              setTimeout(() => {
+                if (outputRef.current) outputRef.current.scrollTop = outputRef.current.scrollHeight
+              }, 10)
+            } catch {}
+          }
+          if (eventType === 'done' && eventData) {
+            try {
+              const result = JSON.parse(JSON.parse(eventData) as string) as { success: boolean; stopped?: boolean }
+              setRunState(result.stopped ? 'stopped' : result.success ? 'success' : 'error')
+            } catch {}
+          }
+        }
       }
+      if (runState === 'running') setRunState('success')
     } catch (err: unknown) {
       if (err instanceof Error && err.name === 'AbortError') {
         try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
-        setOutput('Stopped by user')
+        setOutput(prev => prev + '\n\n[Stopped by user]')
         setRunState('stopped')
       } else {
-        setOutput('Network error')
+        setOutput(prev => prev || 'Network error')
         setRunState('error')
       }
     } finally {
@@ -220,29 +258,29 @@ export default function ResearchClient({ buffer, projects }: Props) {
       </div>
 
       {/* Output panel */}
-      {runState !== 'idle' && output && (
+      {runState !== 'idle' && (
         <div className="card" style={{ marginBottom: 24, overflow: 'hidden' }}>
           <div style={{
             padding: '10px 16px',
-            background: runState === 'success' ? 'var(--green-light)' : runState === 'error' ? 'var(--red-light)' : 'var(--bg-section)',
+            background: runState === 'success' ? 'var(--green-light)' : runState === 'error' ? 'var(--red-light)' : runState === 'stopped' ? 'var(--yellow-light)' : 'var(--bg-section)',
             borderBottom: '1px solid var(--border)',
             fontSize: 12, fontWeight: 600,
-            color: runState === 'success' ? 'var(--green)' : runState === 'error' ? 'var(--red)' : 'var(--text-secondary)',
+            color: runState === 'success' ? 'var(--green)' : runState === 'error' ? 'var(--red)' : runState === 'stopped' ? 'var(--yellow)' : 'var(--text-secondary)',
           }}>
             {runState === 'running' && '● Running research pipeline...'}
             {runState === 'success' && '✓ Research completed'}
             {runState === 'error' && '✗ Research failed'}
             {runState === 'stopped' && '■ Research stopped'}
           </div>
-          <pre style={{
+          <pre ref={outputRef} style={{
             padding: '14px 16px', margin: 0,
             fontSize: 11, lineHeight: 1.55,
             fontFamily: 'var(--font-mono)',
             color: 'var(--text-secondary)',
-            maxHeight: 300, overflow: 'auto',
+            maxHeight: 400, overflow: 'auto',
             whiteSpace: 'pre-wrap', wordBreak: 'break-word',
           }}>
-            {output}
+            {output || 'Starting research pipeline...'}
           </pre>
         </div>
       )}

package/dashboard/components/quick-actions.tsx

@@ -25,14 +25,15 @@ type RunState = 'idle' | 'running' | 'success' | 'error' | 'stopped'
 export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActionsProps) {
   const [running, setRunning] = useState<string | null>(null)
   const [state, setState] = useState<RunState>('idle')
-  const [output, setOutput] = useState<string | null>(null)
+  const [output, setOutput] = useState<string>('')
   const abortRef = useRef<AbortController | null>(null)
+  const outputRef = useRef<HTMLPreElement | null>(null)
 
   const handleRun = async (action: Action) => {
     if (action.disabled) return
     setRunning(action.id)
     setState('running')
-    setOutput(null)
+    setOutput('')
 
     const controller = new AbortController()
     abortRef.current = controller
@@ -44,21 +45,76 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
         body: JSON.stringify({ command: action.command }),
         signal: controller.signal,
       })
-      const data = await res.json()
-      if (data.stopped) {
-        setOutput(data.output ?? 'Stopped')
-        setState('stopped')
-      } else {
-        setOutput(data.output ?? data.error ?? 'No output')
-        setState(data.success ? 'success' : 'error')
+
+      if (!res.body) {
+        setOutput('No response body')
+        setState('error')
+        return
+      }
+
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+
+        // Parse SSE events from buffer
+        const events = buffer.split('\n\n')
+        buffer = events.pop() ?? '' // keep incomplete event
+
+        for (const event of events) {
+          const lines = event.split('\n')
+          let eventType = ''
+          let eventData = ''
+
+          for (const line of lines) {
+            if (line.startsWith('event: ')) eventType = line.slice(7)
+            if (line.startsWith('data: ')) eventData = line.slice(6)
+          }
+
+          if (eventType === 'output' && eventData) {
+            try {
+              const text = JSON.parse(eventData) as string
+              setOutput(prev => prev + text)
+              // Auto-scroll to bottom
+              setTimeout(() => {
+                if (outputRef.current) {
+                  outputRef.current.scrollTop = outputRef.current.scrollHeight
+                }
+              }, 10)
+            } catch {}
+          }
+
+          if (eventType === 'done' && eventData) {
+            try {
+              const result = JSON.parse(JSON.parse(eventData) as string) as { success: boolean; stopped?: boolean; timedOut?: boolean }
+              if (result.stopped) {
+                setOutput(prev => prev + '\n\n[Stopped by user]')
+                setState('stopped')
+              } else if (result.timedOut) {
+                setOutput(prev => prev + '\n\n[Timed out]')
+                setState('error')
+              } else {
+                setState(result.success ? 'success' : 'error')
+              }
+            } catch {}
+          }
+        }
       }
+
+      // If we reach here without a 'done' event, mark as complete
+      if (state === 'running') setState('success')
     } catch (err: unknown) {
       if (err instanceof Error && err.name === 'AbortError') {
         try { await fetch('/api/run', { method: 'DELETE' }) } catch {}
-        setOutput('Stopped by user')
+        setOutput(prev => prev + '\n\n[Stopped by user]')
         setState('stopped')
       } else {
-        setOutput('Network error')
+        setOutput(prev => prev || 'Network error')
         setState('error')
       }
     } finally {
@@ -227,7 +283,7 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
             </div>
           </div>
 
-          <pre style={{
+          <pre ref={outputRef} style={{
             padding: '12px 14px', margin: 0,
             fontSize: 11, lineHeight: 1.5,
             fontFamily: 'var(--font-mono)',
@@ -235,7 +291,7 @@ export function QuickActions({ actions, flowDiagram: FlowDiagram }: QuickActions
             maxHeight: 400, overflow: 'auto',
             whiteSpace: 'pre-wrap', wordBreak: 'break-word',
           }}>
-            {output ?? 'Waiting for output...'}
+            {output || (state === 'running' ? 'Starting...' : 'No output')}
           </pre>
         </div>
       )}

package/dist/cli.js

@@ -9808,7 +9808,7 @@ init_llm();
 import { join as join7 } from "node:path";
 
 // src/prompts/cluster.ts
-function buildClusterPrompt(failures, skills) {
+function buildClusterPrompt(failures, skills, graph) {
   const failuresJson = failures.map((f) => ({
     id: f.id,
     project: f.project,
@@ -9819,6 +9819,29 @@ function buildClusterPrompt(failures, skills) {
   }));
   const skillsList = skills.map((s) => `- ${s.slug}: ${s.meta.description}`).join(`
 `);
+  let graphSection = "";
+  if (graph && graph.edges.length > 0) {
+    const edgesList = graph.edges.map((e) => `- ${e.from} --[${e.type}]--> ${e.to} (strength: ${e.strength})`).join(`
+`);
+    const clustersList = graph.clusters.map((c) => `- ${c.name}: [${c.skills.join(", ")}] (cohesion: ${c.cohesion})`).join(`
+`);
+    graphSection = `
+## Skill Network Graph
+The following relationships exist between skills. Use this to identify when failures might affect multiple related skills.
+
+### Relationships
+${edgesList}
+
+### Clusters
+${clustersList}
+
+When clustering failures, consider:
+- Failures in skills that are in the same cluster likely share root causes
+- "inherits" edges mean a child skill should follow parent skill rules
+- "enhances" edges mean skills complement each other
+- "conflicts" edges mean skills may have contradictory rules
+`;
+  }
   return `You are a failure pattern analyst.
 
 ## Task
@@ -9829,7 +9852,7 @@ ${JSON.stringify(failuresJson, null, 2)}
 
 ## Current Skills
 ${skillsList}
-
+${graphSection}
 ## Output Requirements
 Return a JSON object with this exact structure:
 {
@@ -9846,7 +9869,8 @@ Return a JSON object with this exact structure:
 - Do not create clusters with only 1 record (unless truly unique)
 - Maximum 8 clusters
 - Each record belongs to exactly one cluster
-- Cluster names should be specific (e.g., "WCAG color contrast violations", not "UI issues")`;
+- Cluster names should be specific (e.g., "WCAG color contrast violations", not "UI issues")
+- If skill graph is available, use relationships to identify which skills should be targeted together`;
 }
 function parseClusterOutput(raw) {
   const data = raw;
@@ -9857,7 +9881,7 @@ function parseClusterOutput(raw) {
 }
 
 // src/prompts/proposer.ts
-function buildProposerPrompt(clusterType, failures, relevantSkill, relatedProposals) {
+function buildProposerPrompt(clusterType, failures, relevantSkill, relatedProposals, graphContext) {
   const failureDetails = failures.map((f) => `- [${f.id}] User asked: "${f.userRequest}" → Agent did: "${f.agentAction}" → User corrected: "${f.correction}"`).join(`
 `);
   const skillContent = relevantSkill ? `### ${relevantSkill.slug}
@@ -9866,6 +9890,37 @@ ${relevantSkill.content}
 \`\`\`` : "No existing skill covers this area.";
   const historySection = relatedProposals.length > 0 ? relatedProposals.map((p) => `- [${p.id}] ${p.description} → ${p.outcome} (${p.outcomeReason})`).join(`
 `) : "No prior proposals for this area.";
+  let graphSection = "";
+  if (graphContext && graphContext.relatedSkills.length > 0) {
+    const relatedEdges = relevantSkill ? graphContext.edges.filter((e) => e.from === relevantSkill.slug || e.to === relevantSkill.slug).map((e) => {
+      const other = e.from === relevantSkill.slug ? e.to : e.from;
+      const direction = e.from === relevantSkill.slug ? "outgoing" : "incoming";
+      return `  - ${e.type} (${direction}): ${other} (strength: ${e.strength})`;
+    }).join(`
+`) : "";
+    const relatedSkillSummaries = graphContext.relatedSkills.map((s) => {
+      const preview = s.content.slice(0, 200).replace(/\n/g, " ");
+      return `  - ${s.slug} (score: ${s.meta.score ?? "N/A"}, gen: ${s.meta.generation ?? 0}): ${preview}...`;
+    }).join(`
+`);
+    const clusterInfo = graphContext.cluster ? `This skill belongs to the "${graphContext.cluster.name}" cluster (cohesion: ${graphContext.cluster.cohesion}) with: ${graphContext.cluster.skills.join(", ")}` : "";
+    graphSection = `
+## Skill Network Context
+${relevantSkill?.slug ?? "New skill"} has the following relationships in the skill graph:
+${relatedEdges || "  No edges yet"}
+
+${clusterInfo}
+
+### Related Skills (summaries)
+${relatedSkillSummaries}
+
+## Graph-Aware Guidelines
+- If this skill "inherits" from a parent, ensure your changes are consistent with the parent skill's rules
+- If this skill "enhances" another, check that your changes don't conflict with the enhanced skill
+- If related skills in the same cluster share similar rules, consider whether the fix should be applied at a more abstract level
+- If the correction addresses a pattern common across multiple related skills, note this in your justification — it may warrant propagation
+`;
+  }
   return `You are a skill evolution expert. Analyze failures and propose a concrete skill improvement.
 
 ## Failure Cluster: "${clusterType}"
@@ -9876,12 +9931,13 @@ ${skillContent}
 
 ## Prior Proposals (avoid repeating rejected approaches)
 ${historySection}
-
+${graphSection}
 ## Instructions
 1. Analyze the root cause shared by these failures
 2. Determine: edit existing skill or create new one?
-3. Generate the exact SKILL.md content (complete file if create, or a unified diff if edit)
+3. Generate the exact SKILL.md content (complete file with frontmatter)
 4. Explain why this is better than any rejected prior proposals
+5. If graph context is available, consider whether the improvement should be structured hierarchically (core principles at top, specific rules below)
 
 ## Output
 Return JSON:
@@ -9891,14 +9947,19 @@ Return JSON:
   "proposedSkillMd": "full SKILL.md content with frontmatter",
   "diff": "human-readable description of changes",
   "justification": "why this addresses the root cause",
-  "relatedIterations": ["prop_id"] // related prior proposal IDs
+  "relatedIterations": ["prop_id"],
+  "propagationSuggestions": ["skill-slug"] // skills that might benefit from similar changes (optional)
 }
 
 ## Constraints
 - YAGNI: every rule must map to a specific failure
 - One skill at a time
 - Preserve all existing effective rules when editing
-- Be specific — no vague "consider doing X" rules`;
+- Be specific — no vague "consider doing X" rules
+- When graph context shows skill relationships, organize content hierarchically:
+  1. Inherited/shared principles (from parent skills)
+  2. Core rules (this skill's domain)
+  3. Specific patterns (from failures)`;
 }
 
 // src/prompts/replay.ts
@@ -10398,9 +10459,17 @@ async function evolveCommand(options) {
   console.log(`  Processing ${batch.length} failures (${failures.length} total unresolved)
 `);
   const skills = loadAllGeneralSkills();
-  if (verbose)
-    console.log(`  Skills loaded: ${skills.map((s) => s.slug).join(", ")}
-`);
+  const graph = loadSkillGraph();
+  const hasGraph = graph.nodes.length > 0 && graph.edges.length > 0;
+  if (verbose) {
+    console.log(`  Skills loaded: ${skills.map((s) => s.slug).join(", ")}`);
+    if (hasGraph) {
+      console.log(`  Graph: ${graph.nodes.length} nodes, ${graph.edges.length} edges, ${graph.clusters.length} clusters`);
+    } else {
+      console.log(`  Graph: not built yet (run "helixevo graph --rebuild" for graph-aware evolution)`);
+    }
+    console.log();
+  }
   const stagnation = getStagnationCount();
   if (stagnation >= config.evolution.stopAfterNoImprovement) {
     console.log(`  ⚠ Stagnation detected (${stagnation} rounds with no improvement).`);
@@ -10408,7 +10477,7 @@ async function evolveCommand(options) {
 `);
   }
   console.log("  Step 1: Clustering failures...");
-  const clusterPrompt = buildClusterPrompt(batch, skills);
+  const clusterPrompt = buildClusterPrompt(batch, skills, hasGraph ? graph : undefined);
   const clusterResult = await chatJson({ prompt: clusterPrompt });
   const clusters = parseClusterOutput(clusterResult);
   console.log(`  → ${clusters.clusters.length} cluster(s) found
@@ -10436,7 +10505,10 @@ async function evolveCommand(options) {
     });
     const related = findRelatedProposals(relevantSkill?.slug ?? "", cluster.type);
     console.log("  Step 3: Generating proposal...");
-    const proposerPrompt = buildProposerPrompt(cluster.type, clusterFailures, relevantSkill, related);
+    const relatedSkillSlugs = hasGraph && relevantSkill ? graph.edges.filter((e) => e.from === relevantSkill.slug || e.to === relevantSkill.slug).map((e) => e.from === relevantSkill.slug ? e.to : e.from) : [];
+    const relatedSkillContents = relatedSkillSlugs.map((slug) => skills.find((s) => s.slug === slug)).filter((s) => s !== null);
+    const skillCluster = hasGraph ? graph.clusters.find((c) => c.skills.includes(relevantSkill?.slug ?? "")) : undefined;
+    const proposerPrompt = buildProposerPrompt(cluster.type, clusterFailures, relevantSkill, related, hasGraph ? { relatedSkills: relatedSkillContents, edges: graph.edges, cluster: skillCluster } : undefined);
     const proposalOutput = await chatJson({ prompt: proposerPrompt });
     if (verbose) {
       console.log(`    Action: ${proposalOutput.action}`);
@@ -10554,8 +10626,15 @@ async function evolveCommand(options) {
         if (evicted)
           console.log(`    Evicted: ${evicted.id} (score: ${evicted.score.toFixed(2)})`);
       }
+      if (proposalOutput.propagationSuggestions?.length) {
+        console.log(`  ↗ Propagation suggested to: ${proposalOutput.propagationSuggestions.join(", ")}`);
+        console.log("    (Run evolve again or generalize to apply these)");
+      }
     } else if (finalAccepted && dryRun) {
       console.log(`  [DRY RUN] Would apply: ${proposal.targetSkill}`);
+      if (proposalOutput.propagationSuggestions?.length) {
+        console.log(`  ↗ Would propagate to: ${proposalOutput.propagationSuggestions.join(", ")}`);
+      }
     }
     proposals.push(proposal);
     proposalCount++;
@@ -10569,7 +10648,25 @@ async function evolveCommand(options) {
     proposals
   };
   addIteration(iteration);
-  console.log("  Step 7: Network health assessment...");
+  if (hasGraph) {
+    const accepted2 = proposals.filter((p) => p.outcome === "accepted");
+    if (accepted2.length > 0) {
+      console.log("  Step 7: Updating skill graph...");
+      for (const p of accepted2) {
+        const node = graph.nodes.find((n) => n.id === p.targetSkill);
+        if (node) {
+          node.generation = generation;
+          node.score = (p.judges.taskCompletion.score + p.judges.correctionAlignment.score + p.judges.sideEffectCheck.score) / 30;
+          node.lastEvolved = new Date().toISOString();
+        }
+      }
+      graph.updated = new Date().toISOString();
+      saveSkillGraph(graph);
+      console.log(`  ✓ Graph updated (${accepted2.length} node(s) evolved)
+`);
+    }
+  }
+  console.log("  Step 8: Network health assessment...");
   const health = await assessNetworkHealth(verbose);
   if (verbose)
     printHealthReport(health);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helixevo",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "Self-evolving skill ecosystem for AI agents. Skills and projects co-evolve through multi-judge evaluation and a Pareto frontier.",
   "type": "module",
   "bin": {