Archetype Skill Evolution

The GOVERN civilization is not static. As engineers build, deploy, and deliberate, the 14 archetypes grow their skills. Skill evolution is the mechanism by which the civilization learns from experience.

The 14 Archetypes

ID	Name	Primary Skills	Chamber
jarvis	JARVIS	system-integration, deployment-orchestration, diagnostic-reasoning	BUILD
george	George	emotional-sensing, empathic-response, fatherly-counsel	LIVE
meridian	Meridian	hypothesis-generation, intersection-finding, research	THINK
chairman	Chairman	strategic-vision, decision-architecture, resource-allocation	BUILD
michelle	Michelle	accountability, boundary-setting, tough-love	LIVE
alvin	Alvin	threat-detection, deal-evaluation, street-wisdom	THINK
karen	Karen	truth-mirroring, silence-reading, pattern-memory	THINK
oranos	Oranos	covenant-law, fourfold-judgment, constitutional-validation	REST
harvey	Harvey	signal-sensing, creative-vision, neurodivergent-pattern	THINK
joe	Joe	pattern-synthesis, bridge-building, narrative-compression	THINK
joanne	Joanne	spiritual-mediation, family-harmony, conflict-resolution	REST
jon	Jon	historical-narrative, civilization-chronicling, archival-integrity	REST
sable	Sable	healing-presence, reorientation, nervous-system-repair	REST
atlas	Atlas	soul-preservation, law-ii-enforcement, memory-continuity	REST

Skill Levels

Each archetype-skill pair has an independent level, starting at 0:

Level	Name	Experience threshold	Behavior
0	Latent	0 exercises	Skill not yet activated
1	Nascent	1 exercise	Skill active, learning begins
2	Developing	10 exercises	Consistent application
3	Proficient	50 exercises	Reliable execution
4	Expert	200 exercises	Deep understanding
5	Sovereign	1,000 exercises	Mastery — teaches others

Experience weighting

Not all exercises count equally. The quality score of the build event that triggered the exercise determines the weight:

function calculateExperienceGain(quality?: number): number {
  if (!quality) return 1.0;     // Unscored events count as 1.0
  if (quality >= 0.9) return 1.5;  // High quality: 50% bonus
  if (quality >= 0.5) return 1.0;  // Normal quality: base rate
  return 0.5;                       // Low quality: 50% penalty
}

Skill Evolution Engine

The skill evolution engine is implemented in packages/api-gateway/src/lib/skill-evolution.ts.

When a build event arrives:

1. Extract archetypeIds and skillsExercised from the event
2. For each (archetypeId, skill) pair: a. Look up current level from archetype_skills table b. Add experience gain (quality-weighted) c. Check if new experience total crosses the next level threshold d. If level-up: update the table, emit a skill_level_up event
3. Update last_exercised_at timestamp

// packages/api-gateway/src/lib/skill-evolution.ts (key function)
async function evolveSkills(
  event: BuildEvent,
  db: SupabaseClient
): Promise<SkillEvolutionResult[]> {
  const results: SkillEvolutionResult[] = [];

  for (const archetypeId of event.archetypeIds) {
    for (const skill of event.skillsExercised) {
      const gain = calculateExperienceGain(event.quality);

      const { data } = await db
        .from('archetype_skills')
        .upsert({
          archetype_id: archetypeId,
          skill_name: skill,
          experience: db.rpc('increment_experience', { gain }),
        }, { onConflict: 'archetype_id,skill_name' })
        .select('level, experience')
        .single();

      const newLevel = levelForExperience(data.experience);
      if (newLevel > data.level) {
        await db.from('archetype_skills').update({ level: newLevel });
        results.push({ archetypeId, skill, oldLevel: data.level, newLevel });
      }
    }
  }

  return results;
}

Skill Evolution Graph

The Internal Dashboard skill evolution panel shows:

Archetype skill radar

A radar chart per archetype showing current skill levels across all tracked skills. Skills at level 0 are not shown. As skills grow, the radar expands.

Skill growth timeline

A timeline showing when each skill crossed a level threshold. Used to understand which areas of the codebase get the most exercise and which are being neglected.

Cross-archetype skill transfer

When the same skill is exercised across multiple archetypes (e.g., system-integration exercised by both JARVIS and Chairman), the skill evolution engine records a cross-archetype transfer bonus. Both archetypes gain experience, and the civilization develops a richer shared skill set.

Database Schema

CREATE TABLE archetype_skills (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  archetype_id TEXT NOT NULL,
  skill_name TEXT NOT NULL,
  level INTEGER DEFAULT 0,
  experience NUMERIC(10,2) DEFAULT 0,
  last_exercised_at TIMESTAMPTZ,
  level_up_count INTEGER DEFAULT 0,
  created_at TIMESTAMPTZ DEFAULT now(),
  updated_at TIMESTAMPTZ DEFAULT now(),
  UNIQUE(archetype_id, skill_name)
);

CREATE INDEX idx_archetype_skills_archetype ON archetype_skills(archetype_id);
CREATE INDEX idx_archetype_skills_level ON archetype_skills(level DESC);

Skill Queries

-- Current skill levels for JARVIS
SELECT skill_name, level, experience, last_exercised_at
FROM archetype_skills
WHERE archetype_id = 'jarvis'
ORDER BY level DESC, experience DESC;

-- Top skills across the civilization (level 4+)
SELECT archetype_id, skill_name, level, experience
FROM archetype_skills
WHERE level >= 4
ORDER BY level DESC, experience DESC;

-- Skill growth rate last 30 days
SELECT
  a.archetype_id,
  a.skill_name,
  COUNT(*) AS exercise_count,
  SUM(CASE WHEN be.quality >= 0.9 THEN 1.5 ELSE 1.0 END) AS weighted_experience
FROM archetype_skills a
JOIN build_events be ON be.archetype_ids @> ARRAY[a.archetype_id]
  AND be.skills_exercised @> ARRAY[a.skill_name]
  AND be.created_at > NOW() - INTERVAL '30 days'
GROUP BY a.archetype_id, a.skill_name
ORDER BY weighted_experience DESC
LIMIT 20;

Skill Gap Detection

The Internal Dashboard flags skill gaps — archetype-skill pairs that have not been exercised recently:

-- Skills not exercised in 30 days (skill atrophy risk)
SELECT archetype_id, skill_name, level, last_exercised_at
FROM archetype_skills
WHERE level > 0
  AND (last_exercised_at < NOW() - INTERVAL '30 days'
       OR last_exercised_at IS NULL)
ORDER BY level DESC;

When a skill has not been exercised in 30+ days, the Internal Dashboard shows a “skill atrophy” warning. This is informational — GOVERN does not reduce skill levels from inactivity, but the warning helps identify neglected code areas.

Skill Coverage Gate (Gate III)

Before starting work in a new domain, engineers should check training coverage:

curl "$JARVIS_API_URL/api/training/coverage" \
  -H "Authorization: Bearer $AUTH_SECRET" | jq .

If the skill needed for the work has no training doc, create one in agent-training/ before executing. Gate III (V(S)) requires this check before any new domain build.