helixevo 0.2.40 → 0.3.0

package/dist/cli.js

@@ -9174,9 +9174,240 @@ var init_skills = __esm(() => {
   FRONTMATTER_RE = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 });
 
+// src/ontology/entities.ts
+var ONTOLOGY_KERNEL_ENTITY_NAMES;
+var init_entities = __esm(() => {
+  ONTOLOGY_KERNEL_ENTITY_NAMES = [
+    "ProjectRecord",
+    "SessionRecord",
+    "TaskRecord",
+    "FailureRecord",
+    "PressureSignal",
+    "Capability",
+    "SkillNode",
+    "SkillRelation",
+    "ActivationEvent",
+    "MutationProposal",
+    "TopologyChange",
+    "EvidenceArtifact",
+    "EvaluationResult",
+    "TransferEvent",
+    "GovernanceMode",
+    "HealthMetric",
+    "LineageRecord",
+    "OntologyConcept",
+    "OntologyChangeEvent"
+  ];
+});
+
+// src/ontology/relations.ts
+var ONTOLOGY_RELATION_FAMILIES;
+var init_relations = __esm(() => {
+  ONTOLOGY_RELATION_FAMILIES = [
+    "belongs_to",
+    "derived_from",
+    "replaced_by",
+    "parent_of",
+    "child_of",
+    "specializes",
+    "generalizes_from",
+    "depends_on",
+    "enhances",
+    "conflicts_with",
+    "co_evolves_with",
+    "covers",
+    "activated_for",
+    "suppressed_by",
+    "contributed_to",
+    "competed_with",
+    "triggered_by",
+    "validated_by",
+    "contradicted_by",
+    "survived_in",
+    "requires_review",
+    "proposed_due_to",
+    "benefits",
+    "transferred_to",
+    "refined_by",
+    "promoted_from",
+    "executed_under",
+    "deferred_by",
+    "prioritized_by",
+    "locked_by",
+    "measures",
+    "signals_weakness_in",
+    "suggests_repair_for"
+  ];
+});
+
+// src/ontology/operations.ts
+var SKILL_OPERATIONS, TOPOLOGY_OPERATIONS, ONTOLOGY_OPERATIONS, GOVERNANCE_OPERATIONS, ONTOLOGY_MUTATION_OPERATIONS, ONTOLOGY_ALL_OPERATIONS;
+var init_operations = __esm(() => {
+  SKILL_OPERATIONS = [
+    "create_skill",
+    "edit_skill",
+    "specialize_skill",
+    "generalize_skill",
+    "promote_skill",
+    "demote_skill",
+    "retire_skill"
+  ];
+  TOPOLOGY_OPERATIONS = [
+    "merge_skills",
+    "split_skill",
+    "rewire_relation",
+    "prune_branch",
+    "consolidate_cluster"
+  ];
+  ONTOLOGY_OPERATIONS = [
+    "hypothesize_concept",
+    "promote_concept",
+    "merge_concepts",
+    "split_concept",
+    "deprecate_concept",
+    "refine_relation_subtype",
+    "add_invariant",
+    "migrate_mapping"
+  ];
+  GOVERNANCE_OPERATIONS = [
+    "change_mode",
+    "adjust_plasticity_regime",
+    "allocate_attention",
+    "defer_change",
+    "require_review"
+  ];
+  ONTOLOGY_MUTATION_OPERATIONS = [
+    ...SKILL_OPERATIONS,
+    ...TOPOLOGY_OPERATIONS
+  ];
+  ONTOLOGY_ALL_OPERATIONS = [
+    ...SKILL_OPERATIONS,
+    ...TOPOLOGY_OPERATIONS,
+    ...ONTOLOGY_OPERATIONS,
+    ...GOVERNANCE_OPERATIONS
+  ];
+});
+
+// src/ontology/invariants.ts
+var ONTOLOGY_INVARIANTS;
+var init_invariants = __esm(() => {
+  ONTOLOGY_INVARIANTS = [
+    {
+      id: "accepted-change-requires-evidence",
+      description: "Every accepted change must reference evidence."
+    },
+    {
+      id: "specialist-requires-local-context",
+      description: "Every specialist skill must be linked to a project or local context."
+    },
+    {
+      id: "promotion-requires-repeated-evidence",
+      description: "Every promotion toward generalist intelligence must cite repeated cross-project or repeated-context evidence."
+    },
+    {
+      id: "relation-requires-family-and-confidence",
+      description: "Every skill relation must declare a relation family and confidence source."
+    },
+    {
+      id: "topology-change-preserves-lineage",
+      description: "Every topology change must preserve or explicitly rewrite lineage."
+    },
+    {
+      id: "deprecated-state-remains-recoverable",
+      description: "Every deprecated skill or concept must remain recoverable through lineage."
+    },
+    {
+      id: "ontology-promotion-requires-migration",
+      description: "Every ontology promotion must include a migration mapping."
+    },
+    {
+      id: "frontier-concepts-stay-provisional",
+      description: "Every frontier concept remains provisional until promoted through review."
+    },
+    {
+      id: "transfer-requires-source-and-target",
+      description: "Every transfer claim must identify source and target contexts."
+    },
+    {
+      id: "high-risk-topology-change-requires-validation",
+      description: "Every accepted high-risk topology change must have replay or equivalent validation."
+    }
+  ];
+});
+
+// src/ontology/events.ts
+var ONTOLOGY_EVENT_TYPES;
+var init_events = __esm(() => {
+  ONTOLOGY_EVENT_TYPES = [
+    "failure_captured",
+    "pressure_detected",
+    "skill_activated",
+    "skill_suppressed",
+    "capability_gap_detected",
+    "mutation_proposed",
+    "mutation_accepted",
+    "mutation_rejected",
+    "topology_changed",
+    "transfer_realized",
+    "replay_completed",
+    "regression_completed",
+    "canary_completed",
+    "rollback_triggered",
+    "concept_hypothesized",
+    "concept_promoted",
+    "concept_rejected",
+    "concept_merged",
+    "concept_split",
+    "governance_changed"
+  ];
+});
+
+// src/ontology/spec.ts
+var ONTOLOGY_SPEC_VERSION = "0.1.0", ONTOLOGY_KERNEL_PILLARS, ONTOLOGY_LAYERS, ONTOLOGY_V0_SPEC;
+var init_spec = __esm(() => {
+  init_entities();
+  init_events();
+  init_invariants();
+  init_operations();
+  init_relations();
+  ONTOLOGY_KERNEL_PILLARS = [
+    "Operational World",
+    "Perception / Pressure",
+    "Working Memory / Activation",
+    "Long-Term Memory",
+    "Plasticity / Topology",
+    "Evidence / Immune System",
+    "Executive / Governance",
+    "Metacognition / Health",
+    "Time / Lineage"
+  ];
+  ONTOLOGY_LAYERS = ["kernel", "extension", "frontier", "vocabulary"];
+  ONTOLOGY_V0_SPEC = {
+    version: ONTOLOGY_SPEC_VERSION,
+    pillars: [...ONTOLOGY_KERNEL_PILLARS],
+    layers: [...ONTOLOGY_LAYERS],
+    entityNames: [...ONTOLOGY_KERNEL_ENTITY_NAMES],
+    relationFamilies: [...ONTOLOGY_RELATION_FAMILIES],
+    mutationOperations: [...ONTOLOGY_MUTATION_OPERATIONS],
+    operations: [...ONTOLOGY_ALL_OPERATIONS],
+    invariantIds: ONTOLOGY_INVARIANTS.map((invariant) => invariant.id),
+    eventTypes: [...ONTOLOGY_EVENT_TYPES]
+  };
+});
+
+// src/ontology/index.ts
+var init_ontology = __esm(() => {
+  init_entities();
+  init_relations();
+  init_operations();
+  init_invariants();
+  init_events();
+  init_spec();
+});
+
 // src/utils/data.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync, existsSync as existsSync3 } from "node:fs";
-import { dirname } from "node:path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync, existsSync as existsSync3, readdirSync as readdirSync2 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
 function readJsonl(filename) {
   const path = getDataPath(filename);
   if (!existsSync3(path))
@@ -9246,19 +9477,45 @@ function loadSkillGraph() {
 function saveSkillGraph(graph) {
   writeJson("skill-graph.json", graph);
 }
+function appendEvolutionArtifact(artifact) {
+  appendJsonl("evolution-artifacts.jsonl", artifact);
+}
+function appendActivationTrace(trace) {
+  appendJsonl("activation-traces.jsonl", trace);
+}
+function appendPressureSignal(signal) {
+  appendJsonl("pressure-signals.jsonl", signal);
+}
 var init_data = __esm(() => {
+  init_ontology();
   init_config();
 });
 
 // src/utils/llm.ts
 import { spawn } from "node:child_process";
-function runClaude(prompt, args) {
+function buildClaudeEnv({ dropOauthToken }) {
+  const env = { ...process.env };
+  if (dropOauthToken) {
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+  return env;
+}
+function runClaudeOnce(prompt, args, env) {
   return new Promise((resolve, reject) => {
     const proc = spawn("claude", args, {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env
     });
     let stdout = "";
     let stderr = "";
+    let settled = false;
+    const timeout = setTimeout(() => {
+      proc.kill();
+      if (!settled) {
+        settled = true;
+        reject(new Error("claude call timed out after 180s"));
+      }
+    }, 180000);
     proc.stdout.on("data", (data) => {
       stdout += data.toString();
     });
@@ -9266,23 +9523,42 @@ function runClaude(prompt, args) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
+      clearTimeout(timeout);
+      if (settled)
+        return;
+      settled = true;
       if (code !== 0) {
-        reject(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+        const output = (stderr || stdout).slice(0, 500);
+        reject(new Error(`claude exited with code ${code}: ${output}`));
       } else {
         resolve(stdout.trim());
       }
     });
     proc.on("error", (err) => {
+      clearTimeout(timeout);
+      if (settled)
+        return;
+      settled = true;
       reject(new Error(`Failed to spawn claude: ${err.message}`));
     });
     proc.stdin.write(prompt);
     proc.stdin.end();
-    setTimeout(() => {
-      proc.kill();
-      reject(new Error("claude call timed out after 180s"));
-    }, 180000);
   });
 }
+function isRetryableClaudeAuthError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return CLAUDE_AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+}
+async function runClaude(prompt, args) {
+  try {
+    return await runClaudeOnce(prompt, args, buildClaudeEnv({ dropOauthToken: false }));
+  } catch (error) {
+    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN || !isRetryableClaudeAuthError(error)) {
+      throw error;
+    }
+    return runClaudeOnce(prompt, args, buildClaudeEnv({ dropOauthToken: true }));
+  }
+}
 async function chat(options) {
   const config = loadConfig();
   const model = options.model ?? config.model;
@@ -9334,8 +9610,14 @@ async function searchWeb(query) {
   ];
   return runClaude(query, args);
 }
+var CLAUDE_AUTH_ERROR_PATTERNS;
 var init_llm = __esm(() => {
   init_config();
+  CLAUDE_AUTH_ERROR_PATTERNS = [
+    "OAuth token has expired",
+    "authentication_error",
+    "Failed to authenticate"
+  ];
 });
 
 // src/core/network-health.ts
@@ -9576,7 +9858,7 @@ init_config();
 init_skills();
 init_data();
 init_llm();
-import { join as join4 } from "node:path";
+import { join as join5 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { existsSync as existsSync4, cpSync } from "node:fs";
 
@@ -9607,10 +9889,10 @@ Return JSON:
 
 // src/version.ts
 import { createRequire as createRequire2 } from "node:module";
-import { join as join3, dirname as dirname2 } from "node:path";
+import { join as join4, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join3(dirname2(fileURLToPath(import.meta.url)), "..", "package.json"));
+var pkg = require2(join4(dirname2(fileURLToPath(import.meta.url)), "..", "package.json"));
 var VERSION = pkg.version;
 
 // src/commands/init.ts
@@ -9621,22 +9903,22 @@ async function initCommand(options) {
   const generalDir = getGeneralSkillsPath();
   ensureDir(sgDir);
   ensureDir(generalDir);
-  if (!existsSync4(join4(sgDir, "config.json"))) {
+  if (!existsSync4(join5(sgDir, "config.json"))) {
     saveConfig(DEFAULT_CONFIG);
     console.log("  ✓ Created config.json");
   }
   const defaultPaths = [
-    join4(homedir2(), ".agents", "skills"),
-    join4(homedir2(), ".craft-agent", "workspaces")
+    join5(homedir2(), ".agents", "skills"),
+    join5(homedir2(), ".craft-agent", "workspaces")
   ];
   const scanPaths = options.skillsPaths ?? defaultPaths;
   const expandedPaths = [];
   for (const p of scanPaths) {
     if (p.includes("workspaces") && existsSync4(p)) {
-      const { readdirSync: readdirSync2 } = await import("node:fs");
-      const workspaces = readdirSync2(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
+      const { readdirSync: readdirSync3 } = await import("node:fs");
+      const workspaces = readdirSync3(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
       for (const ws of workspaces) {
-        const skillsDir = join4(p, ws.name, "skills");
+        const skillsDir = join5(p, ws.name, "skills");
         if (existsSync4(skillsDir))
           expandedPaths.push(skillsDir);
       }
@@ -9649,7 +9931,7 @@ async function initCommand(options) {
 `);
   let imported = 0;
   for (const skill of existingSkills) {
-    const targetDir = join4(generalDir, skill.slug);
+    const targetDir = join5(generalDir, skill.slug);
     if (existsSync4(targetDir)) {
       console.log(`    → ${skill.slug}: already exists, skipping`);
       continue;
@@ -9747,19 +10029,57 @@ async function captureCommand(sessionPath, options) {
   }
   const project = options.project ?? output.project;
   for (const f of output.failures) {
+    const timestamp = new Date().toISOString();
+    const failureId = `f_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+    const activationTraceId = `activation_${failureId}`;
+    const pressureSignalId = `pressure_${failureId}`;
     const record = {
-      id: `f_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      id: failureId,
       sessionId,
-      timestamp: new Date().toISOString(),
+      timestamp,
       project,
       userRequest: f.userRequest,
       agentAction: f.agentAction,
       correction: f.correction,
       correctionType: f.correctionType,
       skillsActive: f.skillsActive,
-      skillsRelevant: f.skillsActive
+      skillsRelevant: f.skillsActive,
+      activationTraceId,
+      pressureSignals: [pressureSignalId]
+    };
+    const activationTrace = {
+      id: activationTraceId,
+      timestamp,
+      provenance: "capture-derived",
+      sourceId: failureId,
+      projectId: project ?? undefined,
+      sessionId,
+      activatedSkillIds: f.skillsActive,
+      relevantSkillIds: f.skillsActive,
+      reasonSummary: `${f.correctionType} correction captured from session review`,
+      contextSummary: f.correction,
+      relatedFailureId: failureId,
+      traceVersion: "0.1.0"
+    };
+    const pressureSignal = {
+      id: pressureSignalId,
+      kind: `correction:${f.correctionType}`,
+      provenance: "failure-native",
+      sourceType: "failure",
+      sourceId: failureId,
+      projectId: project ?? undefined,
+      detectedAt: timestamp,
+      severity: f.correctionType === "manual_edit" ? 0.95 : f.correctionType === "mode_switch" ? 0.9 : f.correctionType === "retry" ? 0.72 : 0.65,
+      priority: f.correctionType === "manual_edit" || f.correctionType === "mode_switch" ? "high" : f.correctionType === "retry" ? "medium" : "low",
+      description: f.correction,
+      relatedFailureId: failureId,
+      relatedActivationTraceId: activationTraceId,
+      skillIds: f.skillsActive,
+      status: "open"
     };
     appendFailure(record);
+    appendActivationTrace(activationTrace);
+    appendPressureSignal(pressureSignal);
     console.log(`  ✓ Captured: "${f.correction.slice(0, 60)}..."`);
   }
   console.log(`
@@ -9805,7 +10125,7 @@ init_config();
 init_data();
 init_skills();
 init_llm();
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/prompts/cluster.ts
 function buildClusterPrompt(failures, skills, graph) {
@@ -10216,11 +10536,11 @@ Return JSON: { "score": <number>, "reason": "<one sentence>" }`;
 // src/core/canary.ts
 init_config();
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6, cpSync as cpSync2, rmSync } from "node:fs";
-import { join as join5 } from "node:path";
-var CANARY_DIR = join5(getHelixDir(), "canary");
-var BACKUPS_DIR = join5(getHelixDir(), "backups");
+import { join as join6 } from "node:path";
+var CANARY_DIR = join6(getHelixDir(), "canary");
+var BACKUPS_DIR = join6(getHelixDir(), "backups");
 function getRegistryPath() {
-  return join5(getHelixDir(), "canary-registry.json");
+  return join6(getHelixDir(), "canary-registry.json");
 }
 function loadRegistry() {
   const path = getRegistryPath();
@@ -10233,7 +10553,7 @@ function saveRegistry(registry) {
 }
 function backupSkill(skillPath, slug, version) {
   ensureDir(BACKUPS_DIR);
-  const backupPath = join5(BACKUPS_DIR, `${slug}_${version}_${Date.now()}`);
+  const backupPath = join6(BACKUPS_DIR, `${slug}_${version}_${Date.now()}`);
   if (existsSync6(skillPath)) {
     cpSync2(skillPath, backupPath, { recursive: true });
   }
@@ -10315,7 +10635,7 @@ init_config();
 init_skills();
 init_data();
 init_llm();
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 async function autoGeneralize(candidates, verbose = false, dryRun = false) {
   const created = [];
   const skipped = [];
@@ -10384,7 +10704,7 @@ Keep it focused and actionable. No filler.`
       meta.lastEvolved = new Date().toISOString();
       meta.tags = [...meta.tags ?? [], "auto-generalized"];
       meta.enhances = candidate.sourceSkills;
-      const skillDir = join6(getGeneralSkillsPath(), candidate.suggestedName);
+      const skillDir = join7(getGeneralSkillsPath(), candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       created.push(candidate.suggestedName);
       console.log(`  ✓ Created: ${candidate.suggestedName} (domain layer)`);
@@ -10489,8 +10809,10 @@ async function evolveCommand(options) {
     console.log();
   }
   const generation = getCurrentGeneration() + 1;
+  const iterationId = generateIterationId();
   const proposals = [];
   const failureClusters = [];
+  const artifacts = [];
   let proposalCount = 0;
   for (const cluster of clusters.clusters) {
     if (proposalCount >= maxProposals)
@@ -10589,10 +10911,40 @@ async function evolveCommand(options) {
       outcomeReason: !consensus ? `Rejected: only ${passCount}/3 judges passed` : !passedRegression ? `Rejected: regression ${(regressionResult.passRate * 100).toFixed(0)}% < ${(config.quality.regressionPassRate * 100).toFixed(0)}% threshold` : `Accepted: ${passCount}/3 judges + ${(regressionResult.passRate * 100).toFixed(0)}% regression`,
       relatedProposals: proposalOutput.relatedIterations
     };
+    const artifactCreatedAt = new Date().toISOString();
+    artifacts.push({
+      id: `artifact_${proposalId}`,
+      createdAt: artifactCreatedAt,
+      artifactType: "evolution",
+      provenance: "native-evolution",
+      sourceId: proposalId,
+      iterationId,
+      proposalId,
+      title: `${skillSlug} · ${proposalOutput.action}`,
+      summary: proposalOutput.diff,
+      targetSkill: skillSlug,
+      operation: proposalOutput.action,
+      outcome: proposal.outcome,
+      clusterType: cluster.type,
+      trigger: "manual",
+      judgeScores: {
+        taskCompletion: judge1.score,
+        correctionAlignment: judge2.score,
+        sideEffectCheck: judge3.score
+      },
+      regression: regressionResult,
+      metrics: {
+        averageJudgeScore: avgScore,
+        taskCompletion: judge1.score,
+        correctionAlignment: judge2.score,
+        sideEffectCheck: judge3.score,
+        regressionPassRate: regressionResult.passRate
+      }
+    });
     if (finalAccepted && !dryRun) {
       const { meta, content } = parseSkillMd(proposalOutput.proposedSkillMd);
       const skillSlug2 = proposalOutput.targetSkill ?? proposal.targetSkill;
-      const skillDir = join7(getGeneralSkillsPath(), skillSlug2);
+      const skillDir = join8(getGeneralSkillsPath(), skillSlug2);
       meta.generation = generation;
       meta.score = avgScore;
       meta.lastEvolved = new Date().toISOString();
@@ -10639,15 +10991,21 @@ async function evolveCommand(options) {
     proposals.push(proposal);
     proposalCount++;
   }
+  const iterationTimestamp = new Date().toISOString();
   const iteration = {
-    id: generateIterationId(),
-    timestamp: new Date().toISOString(),
+    id: iterationId,
+    timestamp: iterationTimestamp,
     trigger: "manual",
     failureCount: batch.length,
     failureClusters,
     proposals
   };
   addIteration(iteration);
+  if (!dryRun) {
+    for (const artifact of artifacts) {
+      appendEvolutionArtifact(artifact);
+    }
+  }
   if (hasGraph) {
     const accepted2 = proposals.filter((p) => p.outcome === "accepted");
     if (accepted2.length > 0) {
@@ -10705,9 +11063,9 @@ init_skills();
 // src/core/knowledge-buffer.ts
 init_config();
 import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "node:fs";
-import { join as join8 } from "node:path";
-var BUFFER_PATH = () => join8(getHelixDir(), "knowledge-buffer.json");
-var DRAFTS_DIR = () => join8(getHelixDir(), "drafts");
+import { join as join9 } from "node:path";
+var BUFFER_PATH = () => join9(getHelixDir(), "knowledge-buffer.json");
+var DRAFTS_DIR = () => join9(getHelixDir(), "drafts");
 var MAX_DISCOVERIES = 50;
 var MAX_DRAFTS = 10;
 var DECAY_RATE = 0.1;
@@ -10764,9 +11122,9 @@ function saveDraft(draft) {
       existing.avgScore = draft.avgScore;
       existing.iteration++;
       existing.lastIterated = new Date().toISOString();
-      const draftDir = join8(DRAFTS_DIR(), draft.skillName);
+      const draftDir = join9(DRAFTS_DIR(), draft.skillName);
       ensureDir(draftDir);
-      writeFileSync5(join8(draftDir, "SKILL.md"), draft.skillMd);
+      writeFileSync5(join9(draftDir, "SKILL.md"), draft.skillMd);
     }
   } else {
     buffer.drafts.push({
@@ -10780,9 +11138,9 @@ function saveDraft(draft) {
       iteration: 1,
       lastIterated: new Date().toISOString()
     });
-    const draftDir = join8(DRAFTS_DIR(), draft.skillName);
+    const draftDir = join9(DRAFTS_DIR(), draft.skillName);
     ensureDir(draftDir);
-    writeFileSync5(join8(draftDir, "SKILL.md"), draft.skillMd);
+    writeFileSync5(join9(draftDir, "SKILL.md"), draft.skillMd);
   }
   trimAndSave(buffer);
 }
@@ -10882,7 +11240,7 @@ async function statusCommand() {
 init_data();
 init_skills();
 import { writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 init_config();
 async function reportCommand(options) {
   const days = parseInt(options.days ?? "1");
@@ -10966,8 +11324,8 @@ async function reportCommand(options) {
     report += `- **${s.slug}**${evolved}
 `;
   }
-  const outputPath = options.output ?? join9(getHelixDir(), "reports", `${date}.md`);
-  ensureDir(join9(getHelixDir(), "reports"));
+  const outputPath = options.output ?? join10(getHelixDir(), "reports", `${date}.md`);
+  ensureDir(join10(getHelixDir(), "reports"));
   writeFileSync6(outputPath, report);
   console.log(report);
   console.log(`
@@ -10978,7 +11336,7 @@ async function reportCommand(options) {
 init_config();
 init_skills();
 init_llm();
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 async function generalizeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
@@ -11041,7 +11399,7 @@ async function generalizeCommand(options) {
       meta.generation = 1;
       meta.score = candidate.confidence;
       meta.lastEvolved = new Date().toISOString();
-      const skillDir = join10(getGeneralSkillsPath(), candidate.suggestedName);
+      const skillDir = join11(getGeneralSkillsPath(), candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${candidate.suggestedName} (${candidate.suggestedLayer} layer)
 `);
@@ -11149,7 +11507,7 @@ Return JSON:
 init_data();
 init_skills();
 init_llm();
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function specializeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
@@ -11220,8 +11578,8 @@ async function specializeCommand(options) {
       meta.generation = 1;
       meta.score = candidate.confidence;
       meta.lastEvolved = new Date().toISOString();
-      const projectSkillsDir = join11(process.cwd(), ".helix", "skills");
-      const skillDir = join11(projectSkillsDir, candidate.suggestedName);
+      const projectSkillsDir = join12(process.cwd(), ".helix", "skills");
+      const skillDir = join12(projectSkillsDir, candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${candidate.suggestedName} (project layer, parent: ${candidate.domainSkill})
 `);
@@ -11318,10 +11676,11 @@ Return JSON:
 // src/commands/graph.ts
 import { writeFileSync as writeFileSync8 } from "node:fs";
 import { execSync } from "node:child_process";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 import { tmpdir } from "node:os";
 
 // src/core/network.ts
+init_ontology();
 init_skills();
 init_data();
 init_config();
@@ -11371,7 +11730,12 @@ async function fullRebuild(verbose) {
     status: "active",
     tags: s.meta.tags ?? [],
     failureCount: s.meta.failureCount ?? 0,
-    lastEvolved: s.meta.lastEvolved ?? ""
+    lastEvolved: s.meta.lastEvolved ?? "",
+    cognitiveRole: s.meta.cognitiveRole,
+    stabilityState: s.meta.stabilityState,
+    plasticityState: s.meta.plasticityState,
+    capabilities: s.meta.capabilities,
+    lineageId: s.meta.lineageId
   }));
   const edges = [];
   for (const s of skills) {
@@ -11399,6 +11763,7 @@ async function fullRebuild(verbose) {
   const clusters = clusterSkills(nodes, edges);
   const graph = {
     updated: new Date().toISOString(),
+    ontologyVersion: ONTOLOGY_SPEC_VERSION,
     nodes,
     edges: deduplicateEdges(edges),
     clusters
@@ -11671,29 +12036,29 @@ function detectMergeCandidates(enhances, coEvolves, skills) {
 init_data();
 init_skills();
 import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function syncToObsidian(vaultPath, verbose = false) {
   const graph = loadSkillGraph();
   const skills = loadAllGeneralSkills();
-  const skillsDir = join12(vaultPath, "Skills");
-  const reportsDir = join12(vaultPath, "Reports");
+  const skillsDir = join13(vaultPath, "Skills");
+  const reportsDir = join13(vaultPath, "Reports");
   mkdirSync3(skillsDir, { recursive: true });
   mkdirSync3(reportsDir, { recursive: true });
   for (const node of graph.nodes) {
     const skill = skills.find((s) => s.slug === node.id);
     const note = generateSkillNote(node, graph.edges, skill ?? undefined);
-    const notePath = join12(skillsDir, `${node.id}.md`);
+    const notePath = join13(skillsDir, `${node.id}.md`);
     writeFileSync7(notePath, note);
     if (verbose)
       console.log(`  ✓ ${node.id}.md`);
   }
   const indexNote = generateIndexNote(graph);
-  writeFileSync7(join12(vaultPath, "HelixEvo Index.md"), indexNote);
+  writeFileSync7(join13(vaultPath, "HelixEvo Index.md"), indexNote);
   const recent = getRecentIterations(7);
   if (recent.length > 0) {
     const report = generateEvolutionReport(recent);
     const date = new Date().toISOString().slice(0, 10);
-    writeFileSync7(join12(reportsDir, `Evolution ${date}.md`), report);
+    writeFileSync7(join13(reportsDir, `Evolution ${date}.md`), report);
   }
   console.log(`  ✓ Synced ${graph.nodes.length} skills to ${vaultPath}`);
 }
@@ -12052,7 +12417,7 @@ ${mermaidCode}
   });
 </script>
 </body></html>`;
-  const htmlPath = join13(tmpdir(), "helix-network.html");
+  const htmlPath = join14(tmpdir(), "helix-network.html");
   writeFileSync8(htmlPath, html);
   execSync(`open "${htmlPath}"`);
   console.log(`  ✓ Opened in browser`);
@@ -12117,7 +12482,7 @@ function renderScoreBar(score) {
 init_config();
 init_skills();
 init_llm();
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { readFileSync as readFileSync7, existsSync as existsSync9 } from "node:fs";
 async function researchCommand(options) {
   const verbose = options.verbose ?? false;
@@ -12233,7 +12598,7 @@ Only include discoveries that are NOT already covered by current skills.`
       meta.score = result.avgScore / 10;
       meta.lastEvolved = new Date().toISOString();
       meta.tags = [...meta.tags ?? [], "research-discovered"];
-      const skillDir = join14(getGeneralSkillsPath(), hypothesis.skillName);
+      const skillDir = join15(getGeneralSkillsPath(), hypothesis.skillName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${hypothesis.skillName} (from research)
 `);
@@ -12281,7 +12646,7 @@ async function understandGoals(projectPath, skills) {
   const paths = projectPath ? [projectPath] : [process.cwd()];
   for (const p of paths) {
     for (const file of ["README.md", "CLAUDE.md", "package.json", ".agents/AGENTS.md"]) {
-      const fullPath = join14(p, file);
+      const fullPath = join15(p, file);
       if (existsSync9(fullPath)) {
         const content = readFileSync7(fullPath, "utf-8").slice(0, 2000);
         context.push(`## ${file}
@@ -12443,15 +12808,126 @@ ${replay.slice(0, 800)}`
 
 // src/commands/dashboard.ts
 import { execSync as execSync2, spawn as spawn2 } from "node:child_process";
-import { join as join15, dirname as dirname3 } from "node:path";
-import { existsSync as existsSync10, cpSync as cpSync3, mkdirSync as mkdirSync4, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join17, dirname as dirname3 } from "node:path";
+import { existsSync as existsSync11, cpSync as cpSync3, mkdirSync as mkdirSync5, readdirSync as readdirSync3, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { homedir as homedir3 } from "node:os";
+import { homedir as homedir4 } from "node:os";
 init_skills();
 init_data();
+
+// src/utils/update-check.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join16 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var HELIX_DIR2 = join16(homedir3(), ".helix");
+var CACHE_PATH = join16(HELIX_DIR2, "update-check.json");
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+var REGISTRY_URL = "https://registry.npmjs.org/helixevo/latest";
+function readCache() {
+  try {
+    if (!existsSync10(CACHE_PATH))
+      return null;
+    return JSON.parse(readFileSync8(CACHE_PATH, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    if (!existsSync10(HELIX_DIR2))
+      mkdirSync4(HELIX_DIR2, { recursive: true });
+    writeFileSync9(CACHE_PATH, JSON.stringify(cache));
+  } catch {}
+}
+function hasNewerVersion(current, latest) {
+  const c = current.split(".").map(Number);
+  const l = latest.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    if ((l[i] ?? 0) > (c[i] ?? 0))
+      return true;
+    if ((l[i] ?? 0) < (c[i] ?? 0))
+      return false;
+  }
+  return false;
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function getUpdateInfo(currentVersion = VERSION, forceRefresh = false) {
+  const cache = forceRefresh ? null : readCache();
+  if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
+    return {
+      currentVersion,
+      latestVersion: cache.latestVersion,
+      hasUpdate: hasNewerVersion(currentVersion, cache.latestVersion),
+      source: "cache"
+    };
+  }
+  const latest = await fetchLatestVersion();
+  if (!latest) {
+    return {
+      currentVersion,
+      latestVersion: cache?.latestVersion ?? null,
+      hasUpdate: cache ? hasNewerVersion(currentVersion, cache.latestVersion) : false,
+      source: cache ? "cache" : "none"
+    };
+  }
+  writeCache({ lastCheck: Date.now(), latestVersion: latest });
+  return {
+    currentVersion,
+    latestVersion: latest,
+    hasUpdate: hasNewerVersion(currentVersion, latest),
+    source: "network"
+  };
+}
+async function checkForUpdates() {
+  try {
+    const update = await getUpdateInfo(VERSION);
+    if (update.hasUpdate && update.latestVersion) {
+      printUpdateBanner(update.currentVersion, update.latestVersion);
+    }
+  } catch {}
+}
+function printUpdateBanner(currentVersion, latestVersion) {
+  const yellow = "\x1B[33m";
+  const green = "\x1B[32m";
+  const cyan = "\x1B[36m";
+  const bold = "\x1B[1m";
+  const dim = "\x1B[2m";
+  const reset = "\x1B[0m";
+  console.log();
+  console.log(`${yellow}  ╭──────────────────────────────────────────────╮${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  │  ${bold}Update available!${reset}${yellow}  ${dim}v${currentVersion}${reset}${yellow} → ${green}${bold}v${latestVersion}${reset}${yellow}          │${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  │  ${reset}Run ${cyan}npm install -g helixevo@latest${reset}${yellow}        │${reset}`);
+  console.log(`${yellow}  │  ${reset}to update${yellow}                                   │${reset}`);
+  console.log(`${yellow}  │                                              │${reset}`);
+  console.log(`${yellow}  ╰──────────────────────────────────────────────╯${reset}`);
+  console.log();
+}
+
+// src/commands/dashboard.ts
 var __filename = "/Users/tianchichen/Documents/GitHub/helixevo/src/commands/dashboard.ts";
-var HELIX_DASHBOARD_DIR = join15(homedir3(), ".helix", "dashboard");
+var HELIX_DASHBOARD_DIR = join17(homedir4(), ".helix", "dashboard");
+var DASHBOARD_SKIP_AUTO_UPDATE_ENV = "HELIXEVO_DASHBOARD_SKIP_AUTO_UPDATE";
 async function dashboardCommand(options) {
+  if (options.autoUpdate !== false && process.env[DASHBOARD_SKIP_AUTO_UPDATE_ENV] !== "1" && !findDevDashboard()) {
+    const didRelaunch = await maybeAutoUpdateAndRelaunch(options);
+    if (didRelaunch)
+      return;
+  }
   const dir = prepareDashboard();
   if (!dir) {
     console.error(`  Dashboard not found.
@@ -12461,7 +12937,7 @@ async function dashboardCommand(options) {
     console.error("    cd helixevo/dashboard && npm install && npx next dev --port 3847");
     process.exit(1);
   }
-  if (!existsSync10(join15(dir, "node_modules"))) {
+  if (!existsSync11(join17(dir, "node_modules"))) {
     console.log("  Installing dashboard dependencies...");
     try {
       execSync2("npm install --no-audit --no-fund", { cwd: dir, stdio: "inherit" });
@@ -12474,22 +12950,22 @@ async function dashboardCommand(options) {
   }
   ensureSkillGraph();
   if (options.background) {
-    const logFile = join15(homedir3(), ".helix", "dashboard.log");
+    const logFile = join17(homedir4(), ".helix", "dashboard.log");
     const out = __require("fs").openSync(logFile, "a");
     const err = __require("fs").openSync(logFile, "a");
-    let currentVersion = VERSION;
+    let currentVersion2 = VERSION;
     try {
-      currentVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
+      currentVersion2 = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
     } catch {}
     const child = spawn2("npx", ["next", "dev", "--port", "3847"], {
       cwd: dir,
       stdio: ["ignore", out, err],
-      env: { ...process.env, HELIXEVO_VERSION: currentVersion },
+      env: { ...process.env, HELIXEVO_VERSION: currentVersion2 },
       detached: true
     });
     child.unref();
-    writeFileSync9(join15(homedir3(), ".helix", "dashboard.pid"), String(child.pid));
-    console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${VERSION} running in background`);
+    writeFileSync10(join17(homedir4(), ".helix", "dashboard.pid"), String(child.pid));
+    console.log(`  \uD83C\uDF10 HelixEvo Dashboard v${currentVersion2} running in background`);
     console.log(`     http://localhost:3847`);
     console.log(`     Logs: ${logFile}`);
     console.log(`     Stop: helixevo dashboard --stop
@@ -12503,10 +12979,54 @@ async function dashboardCommand(options) {
     }, 2000);
     process.exit(0);
   }
-  console.log(`  \uD83C\uDF10 Starting HelixEvo Dashboard v${VERSION} at http://localhost:3847
+  let currentVersion = VERSION;
+  try {
+    currentVersion = execSync2("helixevo --version 2>/dev/null", { encoding: "utf-8" }).trim() || VERSION;
+  } catch {}
+  console.log(`  \uD83C\uDF10 Starting HelixEvo Dashboard v${currentVersion} at http://localhost:3847
 `);
   launchDashboard(dir, true);
 }
+async function maybeAutoUpdateAndRelaunch(options) {
+  const update = await getUpdateInfo(VERSION);
+  if (!update.hasUpdate || !update.latestVersion)
+    return false;
+  console.log(`  ⟳ New HelixEvo version detected: v${VERSION} → v${update.latestVersion}`);
+  console.log(`  Updating before launching dashboard...
+`);
+  try {
+    execSync2("npm install -g helixevo@latest", {
+      stdio: "inherit",
+      timeout: 120000,
+      env: { ...process.env }
+    });
+  } catch {
+    console.warn(`
+  Auto-update failed. Continuing with the current installed version.
+`);
+    return false;
+  }
+  console.log(`
+  ✓ Updated to v${update.latestVersion}. Relaunching dashboard...
+`);
+  const executable = process.platform === "win32" ? "helixevo.cmd" : "helixevo";
+  const args = ["dashboard"];
+  if (options.background)
+    args.push("--background");
+  if (options.autoUpdate === false)
+    args.push("--no-auto-update");
+  await new Promise((resolve, reject) => {
+    const child = spawn2(executable, args, {
+      stdio: "inherit",
+      env: { ...process.env, [DASHBOARD_SKIP_AUTO_UPDATE_ENV]: "1" }
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      process.exit(code ?? 0);
+    });
+  });
+  return true;
+}
 var RESTART_EXIT_CODE = 75;
 function launchDashboard(dir, openBrowser) {
   let currentVersion = VERSION;
@@ -12533,8 +13053,8 @@ function launchDashboard(dir, openBrowser) {
   \uD83D\uDD04 Restarting dashboard after update...
 `);
       setTimeout(() => {
-        const nextCache = join15(dir, ".next");
-        if (existsSync10(nextCache)) {
+        const nextCache = join17(dir, ".next");
+        if (existsSync11(nextCache)) {
           try {
             rmSync2(nextCache, { recursive: true });
           } catch {}
@@ -12560,20 +13080,20 @@ function prepareDashboard() {
   const npmSource = findNpmDashboard();
   if (npmSource)
     return copyToHelix(npmSource);
-  if (existsSync10(join15(HELIX_DASHBOARD_DIR, "package.json"))) {
+  if (existsSync11(join17(HELIX_DASHBOARD_DIR, "package.json"))) {
     return HELIX_DASHBOARD_DIR;
   }
   return null;
 }
 function findDevDashboard() {
   const candidates = [
-    join15(process.cwd(), "dashboard")
+    join17(process.cwd(), "dashboard")
   ];
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  candidates.push(join15(home, "Documents", "GitHub", "helixevo", "dashboard"));
-  candidates.push(join15(home, "Documents", "GitHub", "skillgraph", "dashboard"));
+  candidates.push(join17(home, "Documents", "GitHub", "helixevo", "dashboard"));
+  candidates.push(join17(home, "Documents", "GitHub", "skillgraph", "dashboard"));
   for (const dir of candidates) {
-    if (existsSync10(join15(dir, "package.json")) && !dir.includes("node_modules")) {
+    if (existsSync11(join17(dir, "package.json")) && !dir.includes("node_modules")) {
       return dir;
     }
   }
@@ -12584,15 +13104,15 @@ function findNpmDashboard() {
   try {
     const thisFile = typeof __filename !== "undefined" ? __filename : fileURLToPath2(import.meta.url);
     const pkgRoot = dirname3(dirname3(thisFile));
-    candidates.push(join15(pkgRoot, "dashboard"));
+    candidates.push(join17(pkgRoot, "dashboard"));
   } catch {}
   try {
     const globalPrefix = execSync2("npm prefix -g", { encoding: "utf-8" }).trim();
-    candidates.push(join15(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
-    candidates.push(join15(globalPrefix, "node_modules", "helixevo", "dashboard"));
+    candidates.push(join17(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
+    candidates.push(join17(globalPrefix, "node_modules", "helixevo", "dashboard"));
   } catch {}
   for (const dir of candidates) {
-    if (existsSync10(join15(dir, "package.json"))) {
+    if (existsSync11(join17(dir, "package.json"))) {
       return dir;
     }
   }
@@ -12600,10 +13120,10 @@ function findNpmDashboard() {
 }
 function getInstalledDashboardVersion() {
   try {
-    const versionFile = join15(HELIX_DASHBOARD_DIR, ".helixevo-version");
-    if (!existsSync10(versionFile))
+    const versionFile = join17(HELIX_DASHBOARD_DIR, ".helixevo-version");
+    if (!existsSync11(versionFile))
       return null;
-    return readFileSync8(versionFile, "utf-8").trim();
+    return readFileSync9(versionFile, "utf-8").trim();
   } catch {
     return null;
   }
@@ -12611,8 +13131,8 @@ function getInstalledDashboardVersion() {
 function copyToHelix(sourceDir) {
   let sourceVersion = VERSION;
   try {
-    const srcRoot = join15(sourceDir, "..", "package.json");
-    const pkg2 = JSON.parse(readFileSync8(srcRoot, "utf-8"));
+    const srcRoot = join17(sourceDir, "..", "package.json");
+    const pkg2 = JSON.parse(readFileSync9(srcRoot, "utf-8"));
     if (pkg2.name === "helixevo" && pkg2.version)
       sourceVersion = pkg2.version;
   } catch {}
@@ -12625,37 +13145,37 @@ function copyToHelix(sourceDir) {
   } else {
     console.log("  Setting up dashboard at ~/.helix/dashboard...");
   }
-  mkdirSync4(HELIX_DASHBOARD_DIR, { recursive: true });
+  mkdirSync5(HELIX_DASHBOARD_DIR, { recursive: true });
   let depsChanged = true;
   try {
-    const srcDeps = readFileSync8(join15(sourceDir, "package.json"), "utf-8");
-    const dstDeps = readFileSync8(join15(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
+    const srcDeps = readFileSync9(join17(sourceDir, "package.json"), "utf-8");
+    const dstDeps = readFileSync9(join17(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
     const srcPkg = JSON.parse(srcDeps);
     const dstPkg = JSON.parse(dstDeps);
     depsChanged = JSON.stringify(srcPkg.dependencies) !== JSON.stringify(dstPkg.dependencies) || JSON.stringify(srcPkg.devDependencies) !== JSON.stringify(dstPkg.devDependencies);
   } catch {
     depsChanged = true;
   }
-  const items = readdirSync2(sourceDir, { withFileTypes: true });
+  const items = readdirSync3(sourceDir, { withFileTypes: true });
   for (const item of items) {
     if (item.name === "node_modules" || item.name === ".next" || item.name === "package-lock.json" || item.name === ".env.local")
       continue;
-    const src = join15(sourceDir, item.name);
-    const dest = join15(HELIX_DASHBOARD_DIR, item.name);
+    const src = join17(sourceDir, item.name);
+    const dest = join17(HELIX_DASHBOARD_DIR, item.name);
     cpSync3(src, dest, { recursive: true });
   }
   if (depsChanged) {
-    const oldModules = join15(HELIX_DASHBOARD_DIR, "node_modules");
-    if (existsSync10(oldModules))
+    const oldModules = join17(HELIX_DASHBOARD_DIR, "node_modules");
+    if (existsSync11(oldModules))
       rmSync2(oldModules, { recursive: true });
-    const oldLock = join15(HELIX_DASHBOARD_DIR, "package-lock.json");
-    if (existsSync10(oldLock))
+    const oldLock = join17(HELIX_DASHBOARD_DIR, "package-lock.json");
+    if (existsSync11(oldLock))
       rmSync2(oldLock);
   }
-  const nextCache = join15(HELIX_DASHBOARD_DIR, ".next");
-  if (existsSync10(nextCache))
+  const nextCache = join17(HELIX_DASHBOARD_DIR, ".next");
+  if (existsSync11(nextCache))
     rmSync2(nextCache, { recursive: true });
-  writeFileSync9(join15(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
+  writeFileSync10(join17(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
   return HELIX_DASHBOARD_DIR;
 }
 function ensureSkillGraph() {
@@ -12697,13 +13217,13 @@ function ensureSkillGraph() {
 }
 
 // src/commands/watch.ts
-import { join as join17 } from "node:path";
-import { existsSync as existsSync13 } from "node:fs";
+import { join as join19 } from "node:path";
+import { existsSync as existsSync14 } from "node:fs";
 
 // src/core/auto-capture.ts
 init_data();
 init_llm();
-import { readFileSync as readFileSync9, existsSync as existsSync11, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync10, existsSync as existsSync12, statSync as statSync2 } from "node:fs";
 var CORRECTION_SIGNALS = [
   /\bno[, ]+(?:that's|thats|that is)\s+(?:wrong|incorrect|not right)/i,
   /\bdon'?t\s+do\s+(?:that|it\s+like\s+that)/i,
@@ -12791,17 +13311,17 @@ If no corrections found, return: { "corrections": [] }`
 }
 function watchEvents(options) {
   const { eventsPath, project, onCapture, onError, pollIntervalMs = 5000 } = options;
-  let lastSize = existsSync11(eventsPath) ? statSync2(eventsPath).size : 0;
+  let lastSize = existsSync12(eventsPath) ? statSync2(eventsPath).size : 0;
   let messageBuffer = [];
   let pendingExtraction = false;
   const interval = setInterval(async () => {
     try {
-      if (!existsSync11(eventsPath))
+      if (!existsSync12(eventsPath))
         return;
       const currentSize = statSync2(eventsPath).size;
       if (currentSize <= lastSize)
         return;
-      const content = readFileSync9(eventsPath, "utf-8");
+      const content = readFileSync10(eventsPath, "utf-8");
       const lines = content.trim().split(`
 `).filter(Boolean);
       const newLines = lines.slice(messageBuffer.length);
@@ -12843,22 +13363,22 @@ init_data();
 // src/core/metrics.ts
 init_config();
 init_data();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync10, existsSync as existsSync12 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
+import { join as join18 } from "node:path";
 function getMetricsPath() {
-  return join16(getHelixDir(), "metrics.json");
+  return join18(getHelixDir(), "metrics.json");
 }
 function loadMetrics() {
   const path = getMetricsPath();
-  if (!existsSync12(path)) {
+  if (!existsSync13(path)) {
     return { updated: new Date().toISOString(), skills: [], globalCorrectionRate: [], evolutionImpact: [] };
   }
-  return JSON.parse(readFileSync10(path, "utf-8"));
+  return JSON.parse(readFileSync11(path, "utf-8"));
 }
 function saveMetrics(store) {
   ensureDir(getHelixDir());
   store.updated = new Date().toISOString();
-  writeFileSync10(getMetricsPath(), JSON.stringify(store, null, 2));
+  writeFileSync11(getMetricsPath(), JSON.stringify(store, null, 2));
 }
 function updateMetrics() {
   const failures = loadFailures();
@@ -13033,14 +13553,14 @@ async function watchCommand(options) {
   const verbose = options.verbose ?? false;
   const autoEvolve = options.evolve !== false;
   const project = options.project ?? null;
-  const eventsPath = options.events ?? join17(process.cwd(), "events.jsonl");
+  const eventsPath = options.events ?? join19(process.cwd(), "events.jsonl");
   console.log(`\uD83E\uDDEC HelixEvo Watch Mode — Always-On Learning
 `);
   console.log(`  Events:      ${eventsPath}`);
   console.log(`  Project:     ${project ?? "(auto-detect)"}`);
   console.log(`  Auto-evolve: ${autoEvolve ? "ON" : "OFF"}`);
   console.log();
-  if (!existsSync13(eventsPath)) {
+  if (!existsSync14(eventsPath)) {
     console.log(`  ⚠ Events file not found yet. Will start watching when it appears.`);
     console.log(`  Expected at: ${eventsPath}
 `);
@@ -13188,10 +13708,12 @@ async function metricsCommand(options) {
 }
 
 // src/commands/project-setup.ts
+init_data();
 init_skills();
 init_llm();
-import { join as join18 } from "node:path";
-import { existsSync as existsSync14, readFileSync as readFileSync11, writeFileSync as writeFileSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "node:fs";
+import { isAbsolute, join as join20, normalize, resolve } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
 
 // src/prompts/project-analysis.ts
 function buildProjectAnalysisPrompt(projectContext, skills) {
@@ -13255,6 +13777,23 @@ Return JSON:
 
 // src/commands/project-setup.ts
 init_config();
+function stripTrailingSeparator(path) {
+  if (path.length <= 1)
+    return path;
+  return path.replace(/[\\/]+$/, "") || path;
+}
+function expandHomePath(path) {
+  if (path === "~")
+    return homedir5();
+  if (path.startsWith("~/"))
+    return join20(homedir5(), path.slice(2));
+  return path;
+}
+function normalizeProjectPath(projectPath) {
+  const expanded = expandHomePath(projectPath.trim());
+  const resolvedPath = isAbsolute(expanded) ? normalize(expanded) : resolve(process.cwd(), expanded);
+  return stripTrailingSeparator(resolvedPath);
+}
 function readProjectContext(projectPath) {
   const contextFiles = [];
   const filesToRead = [
@@ -13272,33 +13811,33 @@ function readProjectContext(projectPath) {
     "Dockerfile"
   ];
   for (const f of filesToRead) {
-    const p = join18(projectPath, f);
-    if (existsSync14(p)) {
+    const p = join20(projectPath, f);
+    if (existsSync15(p)) {
       try {
-        const content = readFileSync11(p, "utf-8");
+        const content = readFileSync12(p, "utf-8");
         contextFiles.push({ name: f, content: content.slice(0, 2000) });
       } catch {}
     }
   }
   let dirStructure = "";
   try {
-    const items = readdirSync3(projectPath, { withFileTypes: true }).filter((d) => !d.name.startsWith(".") && d.name !== "node_modules" && d.name !== "__pycache__").slice(0, 30);
+    const items = readdirSync4(projectPath, { withFileTypes: true }).filter((d) => !d.name.startsWith(".") && d.name !== "node_modules" && d.name !== "__pycache__").slice(0, 30);
     dirStructure = items.map((d) => `${d.isDirectory() ? "\uD83D\uDCC1" : "\uD83D\uDCC4"} ${d.name}`).join(`
 `);
   } catch {}
   let srcStructure = "";
-  const srcDir = join18(projectPath, "src");
-  if (existsSync14(srcDir)) {
+  const srcDir = join20(projectPath, "src");
+  if (existsSync15(srcDir)) {
     try {
       const scanDir = (dir, prefix, depth) => {
         if (depth > 2)
           return [];
         const lines = [];
-        const items = readdirSync3(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).slice(0, 20);
+        const items = readdirSync4(dir, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).slice(0, 20);
         for (const item of items) {
           lines.push(`${prefix}${item.isDirectory() ? "\uD83D\uDCC1" : "\uD83D\uDCC4"} ${item.name}`);
           if (item.isDirectory()) {
-            lines.push(...scanDir(join18(dir, item.name), prefix + "  ", depth + 1));
+            lines.push(...scanDir(join20(dir, item.name), prefix + "  ", depth + 1));
           }
         }
         return lines;
@@ -13332,18 +13871,18 @@ ${f.content}
   return context;
 }
 function getProjectsDir() {
-  return join18(getHelixDir(), "projects");
+  return join20(getHelixDir(), "projects");
 }
 function saveProjectProfile(profile) {
-  const dir = join18(getProjectsDir(), profile.name);
-  mkdirSync5(dir, { recursive: true });
-  writeFileSync11(join18(dir, "profile.json"), JSON.stringify(profile, null, 2));
+  const dir = join20(getProjectsDir(), profile.name);
+  mkdirSync6(dir, { recursive: true });
+  writeFileSync12(join20(dir, "profile.json"), JSON.stringify(profile, null, 2));
 }
 async function projectSetupCommand(projectPath, options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
-  const resolvedPath = join18(process.cwd(), projectPath).replace(/\/$/, "");
-  if (!existsSync14(resolvedPath)) {
+  const resolvedPath = normalizeProjectPath(projectPath);
+  if (!existsSync15(resolvedPath)) {
     console.error(`  ✗ Path not found: ${resolvedPath}`);
     process.exit(1);
   }
@@ -13402,19 +13941,58 @@ async function projectSetupCommand(projectPath, options) {
     }
   }
   if (!dryRun) {
+    const analyzedAt = new Date().toISOString();
     const profile = {
       name: analysis.name,
       path: resolvedPath,
       description: analysis.description,
       techStack: analysis.techStack,
       domains: analysis.domains,
-      analyzedAt: new Date().toISOString(),
+      analyzedAt,
       matchedSkills: analysis.matchedSkills,
       gaps: analysis.gaps,
       recommendations: analysis.recommendations,
       status: "analyzed"
     };
     saveProjectProfile(profile);
+    const activationTraceId = `activation_project_${analysis.name}_${Date.now()}`;
+    const activationTrace = {
+      id: activationTraceId,
+      timestamp: analyzedAt,
+      provenance: "project-analysis",
+      sourceId: resolvedPath,
+      projectId: analysis.name,
+      projectPath: resolvedPath,
+      activatedSkillIds: analysis.matchedSkills.map((skill) => skill.slug),
+      relevantSkillIds: analysis.matchedSkills.map((skill) => skill.slug),
+      reasonSummary: "project-analysis skill match and capability scan",
+      contextSummary: analysis.description,
+      gapAreas: analysis.gaps.map((gap) => gap.area),
+      recommendations: analysis.recommendations,
+      traceVersion: "0.1.0"
+    };
+    appendActivationTrace(activationTrace);
+    analysis.gaps.forEach((gap, index) => {
+      const signal = {
+        id: `pressure_project_${analysis.name}_${index}_${Date.now()}`,
+        kind: `gap:${gap.area}`,
+        provenance: "project-analysis-native",
+        sourceType: "project-analysis",
+        sourceId: resolvedPath,
+        projectId: analysis.name,
+        projectPath: resolvedPath,
+        detectedAt: analyzedAt,
+        severity: gap.priority === "high" ? 0.95 : gap.priority === "medium" ? 0.75 : 0.55,
+        priority: gap.priority,
+        capability: gap.area,
+        description: gap.description,
+        suggestedAction: gap.suggestedAction,
+        relatedActivationTraceId: activationTraceId,
+        skillIds: analysis.matchedSkills.map((skill) => skill.slug),
+        status: "open"
+      };
+      appendPressureSignal(signal);
+    });
     console.log(`
   ✓ Project profile saved to ~/.helix/projects/${analysis.name}/`);
     console.log(`    Next: Run "helixevo specialize --project ${analysis.name}" to create project-specific skills`);
@@ -13428,95 +14006,9 @@ async function projectSetupCommand(projectPath, options) {
   console.log();
 }
 
-// src/utils/update-check.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync12, existsSync as existsSync15, mkdirSync as mkdirSync6 } from "node:fs";
-import { join as join19 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-var HELIX_DIR2 = join19(homedir4(), ".helix");
-var CACHE_PATH = join19(HELIX_DIR2, "update-check.json");
-var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
-var REGISTRY_URL = "https://registry.npmjs.org/helixevo/latest";
-function readCache() {
-  try {
-    if (!existsSync15(CACHE_PATH))
-      return null;
-    return JSON.parse(readFileSync12(CACHE_PATH, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function writeCache(cache) {
-  try {
-    if (!existsSync15(HELIX_DIR2))
-      mkdirSync6(HELIX_DIR2, { recursive: true });
-    writeFileSync12(CACHE_PATH, JSON.stringify(cache));
-  } catch {}
-}
-function compareVersions(current, latest) {
-  const c = current.split(".").map(Number);
-  const l = latest.split(".").map(Number);
-  for (let i = 0;i < 3; i++) {
-    if ((l[i] ?? 0) > (c[i] ?? 0))
-      return true;
-    if ((l[i] ?? 0) < (c[i] ?? 0))
-      return false;
-  }
-  return false;
-}
-async function fetchLatestVersion() {
-  try {
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), 3000);
-    const res = await fetch(REGISTRY_URL, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (!res.ok)
-      return null;
-    const data = await res.json();
-    return data.version ?? null;
-  } catch {
-    return null;
-  }
-}
-async function checkForUpdates() {
-  try {
-    const cache = readCache();
-    if (cache && Date.now() - cache.lastCheck < CHECK_INTERVAL_MS) {
-      if (compareVersions(VERSION, cache.latestVersion)) {
-        printUpdateBanner(cache.latestVersion);
-      }
-      return;
-    }
-    const latest = await fetchLatestVersion();
-    if (!latest)
-      return;
-    writeCache({ lastCheck: Date.now(), latestVersion: latest });
-    if (compareVersions(VERSION, latest)) {
-      printUpdateBanner(latest);
-    }
-  } catch {}
-}
-function printUpdateBanner(latestVersion) {
-  const yellow = "\x1B[33m";
-  const green = "\x1B[32m";
-  const cyan = "\x1B[36m";
-  const bold = "\x1B[1m";
-  const dim = "\x1B[2m";
-  const reset = "\x1B[0m";
-  console.log();
-  console.log(`${yellow}  ╭──────────────────────────────────────────────╮${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  │  ${bold}Update available!${reset}${yellow}  ${dim}v${VERSION}${reset}${yellow} → ${green}${bold}v${latestVersion}${reset}${yellow}          │${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  │  ${reset}Run ${cyan}npm install -g helixevo@latest${reset}${yellow}        │${reset}`);
-  console.log(`${yellow}  │  ${reset}to update${yellow}                                   │${reset}`);
-  console.log(`${yellow}  │                                              │${reset}`);
-  console.log(`${yellow}  ╰──────────────────────────────────────────────╯${reset}`);
-  console.log();
-}
-
 // src/cli.ts
-import { join as join20 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { join as join21 } from "node:path";
+import { homedir as homedir6 } from "node:os";
 import { existsSync as existsSync16, readFileSync as readFileSync13, rmSync as rmSync3 } from "node:fs";
 var program2 = new Command;
 program2.name("helixevo").description("Self-evolving skill ecosystem for AI agents").version(VERSION).addHelpText("after", `
@@ -13545,9 +14037,9 @@ program2.command("generalize").description("Promote cross-skill patterns to high
 program2.command("specialize").description("Create project-specific skills ↓ --project <name> [--dry-run] [--verbose]").requiredOption("--project <name>", "Project name").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(specializeCommand);
 program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
 program2.command("research").description("Proactive research via web [--project <path>] [--dry-run] [--verbose]").option("--project <path>", "Project path for goal extraction").option("--dry-run", "Show discoveries without creating skills").option("--verbose", "Show detailed research steps").option("--max-hypotheses <n>", "Max hypotheses to test", "3").action(researchCommand);
-program2.command("dashboard").description("Open web dashboard at http://localhost:3847").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").action(async (options) => {
+program2.command("dashboard").description("Open web dashboard at http://localhost:3847").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").option("--no-auto-update", "Skip automatic update check before launching the dashboard").action(async (options) => {
   if (options.stop) {
-    const pidFile = join20(homedir5(), ".helix", "dashboard.pid");
+    const pidFile = join21(homedir6(), ".helix", "dashboard.pid");
     if (existsSync16(pidFile)) {
       const pid = parseInt(readFileSync13(pidFile, "utf-8").trim());
       try {
@@ -13560,7 +14052,7 @@ program2.command("dashboard").description("Open web dashboard at http://localhos
     }
     return;
   }
-  dashboardCommand(options);
+  await dashboardCommand(options);
 });
 program2.command("status").description("Show frontier, skills, failures, and network health").action(statusCommand);
 program2.command("report").description("Evolution report [--days <n>] [--output <path>]").option("--days <n>", "Report period in days", "1").option("--output <path>", "Output path for report").action(reportCommand);