mirror: sync from hq/multiverse

Automated by mirror-to-agentis workflow.
Source commit: f7a31b0b305b95d86f86dee863ed827b8b933738

Author: github-actions[bot]

package.json

@@ -12,11 +12,7 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:e2e": "playwright test",
-    "test:e2e:headed": "playwright test --headed",
-    "build:local": "./scripts/build-local.sh",
-    "local:run": "node packages/local-runner/bin/agentis-local.js",
-    "local:pack-run": "cd packages/local-runner && npm pack --ignore-scripts && npx ./$(ls -t *.tgz | head -1)",
-    "local:clean": "rm -rf packages/local-runner/bundle packages/local-runner/*.tgz"
+    "test:e2e:headed": "playwright test --headed"
   },
   "devDependencies": {
     "@playwright/test": "^1.58.2",

packages/engine/src/__tests__/monster-panel-vm.test.ts

@@ -426,14 +426,14 @@ describe('panelTitle', () => {
     const monster = makeMonster({
       error_details: { message: 'ECONNREFUSED on port 3000', tool_name: 'Deploy' },
     })
-    expect(panelTitle(monster, 'local_failure')).toBe('Deploy Connection refused')
+    expect(panelTitle(monster, 'local_failure')).toBe('Deploy: Connection refused')
   })
 
-  it('returns "Tool failed" when only tool present', () => {
+  it('returns "Tool failure" when only tool present', () => {
     const monster = makeMonster({
       error_details: { message: 'Something broke', tool_name: 'Bash' },
     })
-    expect(panelTitle(monster, 'local_failure')).toBe('Bash failed')
+    expect(panelTitle(monster, 'local_failure')).toBe('Bash failure')
   })
 
   it('returns signature when only signature present', () => {
@@ -488,16 +488,18 @@ describe('generateErrorCodename', () => {
     expect(warning).not.toBe(critical)
   })
 
-  it('handles collisions with Roman numeral suffixes', () => {
-    // Force two different IDs that produce the same codename by generating many
-    // and checking if any duplicates get suffixed
+  it('handles collisions with word-based expansion (no digits)', () => {
     const names: string[] = []
     for (let i = 0; i < 100; i++) {
       names.push(generateErrorCodename(`monster_collision_${i}`, 'error'))
     }
-    // All names should be unique (collisions get suffixed)
+    // All names should be unique (collisions get expanded with epithets)
     const unique = new Set(names)
     expect(unique.size).toBe(names.length)
+    // No name should contain any digit
+    for (const name of names) {
+      expect(name).not.toMatch(/\d/)
+    }
   })
 
   it('codenames do not overlap with agent name pools', () => {
@@ -537,7 +539,7 @@ describe('deriveErrorName', () => {
     expect(result.short.split(' ').length).toBeGreaterThanOrEqual(2)
     expect(result.codename).toBe(result.short)
     // full should be the technical descriptor
-    expect(result.full).toBe('Deploy Connection refused')
+    expect(result.full).toBe('Deploy: Connection refused')
     expect(result.descriptor).toBe(result.full)
   })
 
@@ -546,9 +548,9 @@ describe('deriveErrorName', () => {
     expect(result.descriptor).toBe('Type error')
   })
 
-  it('returns tool failed descriptor when no signature', () => {
+  it('returns tool failure descriptor when no signature', () => {
     const result = deriveErrorName({ message: 'Something went wrong', tool_name: 'Bash' }, 'error', 'monster_test_3')
-    expect(result.descriptor).toBe('Bash failed')
+    expect(result.descriptor).toBe('Bash failure')
   })
 
   it('extracts excerpt from raw message when no tool/signature', () => {

packages/engine/src/components/monster-panel-vm.ts

@@ -99,36 +99,53 @@ function fnv1a(str: string): number {
 
 /**
  * Severity-aware codename pools.
- * Each pool has [prefix[], core[]] tuples. The codename is formed as
+ * Each pool has prefixes[], cores[], and epithets[]. The codename is formed as
  * "Prefix Core" by picking one from each using hash(monsterId).
+ * On collision, a third word (epithet) is appended instead of a number.
  *
  * These pools are intentionally disjoint from agent name pools
  * (Nova, Forge, Atlas, Alpha, Beta, etc.).
  */
-const CODENAME_POOLS: Record<string, { prefixes: readonly string[]; cores: readonly string[] }> = {
+const CODENAME_POOLS: Record<string, {
+  prefixes: readonly string[]
+  cores: readonly string[]
+  epithets: readonly string[]
+}> = {
   warning: {
-    prefixes: ['Grey', 'Faint', 'Pale', 'Dusk', 'Mist', 'Haze', 'Thin', 'Dim'],
-    cores: ['Wisp', 'Moth', 'Shade', 'Flicker', 'Murmur', 'Ember', 'Glint', 'Ripple'],
+    prefixes: ['Grey', 'Faint', 'Pale', 'Dusk', 'Mist', 'Haze', 'Thin', 'Dim',
+               'Wan', 'Soft', 'Low', 'Still', 'Cold', 'Dry', 'Slow', 'Bare'],
+    cores: ['Wisp', 'Moth', 'Shade', 'Flicker', 'Murmur', 'Ember', 'Glint', 'Ripple',
+            'Sigh', 'Drift', 'Hush', 'Trace', 'Echo', 'Veil', 'Frost', 'Spark'],
+    epithets: ['Ashen', 'Hollow', 'Silent', 'Fading', 'Distant', 'Waning', 'Fleeting', 'Sunken'],
   },
   error: {
-    prefixes: ['Iron', 'Rust', 'Bitter', 'Bleak', 'Ashen', 'Thorn', 'Bane', 'Grim'],
-    cores: ['Fang', 'Specter', 'Wraith', 'Vortex', 'Rend', 'Scourge', 'Blight', 'Fracture'],
+    prefixes: ['Iron', 'Rust', 'Bitter', 'Bleak', 'Ashen', 'Thorn', 'Bane', 'Grim',
+               'Dusk', 'Sable', 'Keen', 'Stark', 'Nether', 'Riven', 'Wicked', 'Fell'],
+    cores: ['Fang', 'Specter', 'Wraith', 'Vortex', 'Rend', 'Scourge', 'Blight', 'Fracture',
+            'Maw', 'Claw', 'Shard', 'Surge', 'Rot', 'Hex', 'Torment', 'Ruin'],
+    epithets: ['Risen', 'Unbound', 'Cursed', 'Scarred', 'Twisted', 'Ragged', 'Barbed', 'Hollow'],
   },
   critical: {
-    prefixes: ['Dire', 'Dread', 'Crimson', 'Void', 'Fell', 'Wrath', 'Doom', 'Black'],
-    cores: ['Hydra', 'Leviathan', 'Titan', 'Colossus', 'Behemoth', 'Reaper', 'Tyrant', 'Inferno'],
+    prefixes: ['Dire', 'Dread', 'Crimson', 'Void', 'Fell', 'Wrath', 'Doom', 'Black',
+               'Blood', 'Shadow', 'Storm', 'Death', 'Night', 'Dark', 'Chaos', 'Bone'],
+    cores: ['Hydra', 'Leviathan', 'Titan', 'Colossus', 'Behemoth', 'Reaper', 'Tyrant', 'Inferno',
+            'Warden', 'Phantom', 'Sovereign', 'Herald', 'Juggernaut', 'Harbinger', 'Sentinel', 'Monolith'],
+    epithets: ['Eternal', 'Ancient', 'Unchained', 'Supreme', 'Undying', 'Merciless', 'Relentless', 'Forsaken'],
   },
   outage: {
-    prefixes: ['Abyssal', 'Cataclysm', 'Oblivion', 'Ruin', 'Eclipse', 'Null', 'Extinction', 'Omega'],
-    cores: ['Drake', 'Kraken', 'Annihilator', 'Maelstrom', 'Cataclysm', 'Worldbreaker', 'Tempest', 'Ravager'],
+    prefixes: ['Abyssal', 'Oblivion', 'Ruin', 'Eclipse', 'Null', 'Extinction', 'Omega', 'End',
+               'Nether', 'Hollow', 'Sundered', 'Shattered', 'Forsaken', 'Eldritch', 'Prime', 'Apex'],
+    cores: ['Drake', 'Kraken', 'Annihilator', 'Maelstrom', 'Worldbreaker', 'Tempest', 'Ravager', 'Scourge',
+            'Devourer', 'Obliterator', 'Cataclysm', 'Dominion', 'Nexus', 'Terminus', 'Sovereign', 'Abyss'],
+    epithets: ['Ascended', 'Absolute', 'Infinite', 'Ultimate', 'Primordial', 'Boundless', 'Transcendent', 'Final'],
   },
 }
 
 /** Default pool used when severity is unknown */
 const DEFAULT_POOL = CODENAME_POOLS['error']!
 
 /** Session-level codename deduplication registry */
-const usedCodenames = new Map<string, number>()
+const usedCodenames = new Set<string>()
 
 /** Reset the dedup registry (call on scenario reload) */
 export function resetErrorCodenames(): void {
@@ -139,12 +156,15 @@ export function resetErrorCodenames(): void {
  * Generate a deterministic, human-friendly codename for an error/monster.
  *
  * Uses severity-aware word pools and FNV-1a hash of the monster ID for
- * deterministic selection. Handles collisions within a session by appending
- * a Roman numeral suffix (II, III, IV...).
+ * deterministic selection. On collision, appends a third word (epithet)
+ * from a dedicated pool — never digits or Roman numerals.
+ *
+ * With 16 prefixes x 16 cores = 256 base combinations per severity,
+ * plus 8 epithets for collision expansion = 2048 total unique names.
  *
  * @param monsterId - Unique monster ID (required for determinism)
  * @param severity  - Monster severity level (selects the word pool)
- * @returns A codename like "Iron Specter" or "Dire Hydra II"
+ * @returns A codename like "Iron Specter" or "Dire Hydra Eternal"
  */
 export function generateErrorCodename(monsterId: string, severity: string): string {
   const pool = CODENAME_POOLS[severity] ?? DEFAULT_POOL
@@ -155,16 +175,49 @@ export function generateErrorCodename(monsterId: string, severity: string): stri
   const core = pool.cores[(hash >>> 16) % pool.cores.length]!
   const baseName = `${prefix} ${core}`
 
-  // Dedup within session: if this exact codename was already issued, suffix it
-  const count = usedCodenames.get(baseName) ?? 0
-  usedCodenames.set(baseName, count + 1)
+  // If base name is unique in this session, use it directly
+  if (!usedCodenames.has(baseName)) {
+    usedCodenames.add(baseName)
+    return baseName
+  }
+
+  // Collision: append an epithet chosen by a different hash mix
+  const epithetHash = fnv1a(monsterId + ':epithet')
+  const epithet = pool.epithets[epithetHash % pool.epithets.length]!
+  const expanded = `${baseName} ${epithet}`
+
+  if (!usedCodenames.has(expanded)) {
+    usedCodenames.add(expanded)
+    return expanded
+  }
 
-  if (count === 0) return baseName
+  // Extremely rare double-collision: try remaining epithets deterministically
+  for (let i = 0; i < pool.epithets.length; i++) {
+    const candidate = `${baseName} ${pool.epithets[i]!}`
+    if (!usedCodenames.has(candidate)) {
+      usedCodenames.add(candidate)
+      return candidate
+    }
+  }
+
+  // Exhausted all epithets: use a unique word-based suffix from the hash
+  const fallback = `${baseName} ${hashWord(monsterId)}`
+  usedCodenames.add(fallback)
+  return fallback
+}
 
-  // Roman numeral suffixes for collisions (deterministic, readable)
-  const ROMAN = ['II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX', 'X']
-  const suffix = count <= ROMAN.length ? ROMAN[count - 1]! : `${count + 1}`
-  return `${baseName} ${suffix}`
+/** Generate a pronounceable word-like suffix from a hash (no digits) */
+function hashWord(id: string): string {
+  const h = fnv1a(id + ':word')
+  const consonants = 'bcdfghjklmnprstvwz'
+  const vowels = 'aeiou'
+  // Build a 4-letter pronounceable token: CVCV
+  const c1 = consonants[h % consonants.length]!
+  const v1 = vowels[(h >>> 4) % vowels.length]!
+  const c2 = consonants[(h >>> 8) % consonants.length]!
+  const v2 = vowels[(h >>> 12) % vowels.length]!
+  const word = c1 + v1 + c2 + v2
+  return word.charAt(0).toUpperCase() + word.slice(1)
 }
 
 // ---------------------------------------------------------------------------
@@ -220,9 +273,9 @@ function deriveDescriptor(
   const tool = errorDetails?.tool_name
   const sig = extractSignature(errorDetails?.message)
 
-  if (tool && sig) return `${tool} ${sig}`
+  if (tool && sig) return tool + ': ' + sig
   if (sig) return sig
-  if (tool) return `${tool} failed`
+  if (tool) return tool + ' failure'
 
   const excerpt = extractExcerpt(errorDetails?.message)
   if (excerpt) return excerpt

packages/engine/src/engine/entity-sprite-map.ts

@@ -83,15 +83,16 @@ const DEFAULT_CONFIG: EntitySpriteConfig = {
 }
 
 // ---------------------------------------------------------------------------
-// String hash (djb2) — deterministic, fast, collision-resistant enough
+// FNV-1a 32-bit hash — better avalanche than djb2 for similar agent IDs
 // ---------------------------------------------------------------------------
 
-function djb2Hash(str: string): number {
-  let hash = 5381
+function fnv1aHash(str: string): number {
+  let hash = 0x811c9dc5
   for (let i = 0; i < str.length; i++) {
-    hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0
+    hash ^= str.charCodeAt(i)
+    hash = Math.imul(hash, 0x01000193)
   }
-  return Math.abs(hash)
+  return hash >>> 0
 }
 
 // ---------------------------------------------------------------------------
@@ -244,8 +245,8 @@ export class EntitySpriteMap {
       return agentConfig.base
     }
 
-    // Deterministic variant: hash the agent ID
-    const idx = djb2Hash(agentId) % variants.length
+    // Deterministic variant: hash the agent ID with FNV-1a for better spread
+    const idx = fnv1aHash(agentId) % variants.length
     const key = variants[idx] ?? agentConfig.base
     this.agentCache.set(agentId, key)
     return key
@@ -308,7 +309,7 @@ export class EntitySpriteMap {
     if (entry.length === 0) return FALLBACK_EVENT_KEY
     if (!eventId || entry.length === 1) return entry[0] ?? FALLBACK_EVENT_KEY
 
-    const idx = djb2Hash(eventId) % entry.length
+    const idx = fnv1aHash(eventId) % entry.length
     return entry[idx] ?? entry[0] ?? FALLBACK_EVENT_KEY
   }
 

packages/engine/src/stores/eventStore.ts

@@ -653,13 +653,24 @@ function dispatchEvent(event: AgentEvent): void {
         const occupied = collectOccupiedPositions(agentMap, monsters.monsters)
         const finalPosition = findNonOverlappingPosition(position, occupied)
 
+        // Deterministically assign agent type from pool based on ID
+        // so different subagents get visually distinct sprites
+        const AGENT_TYPES = ['claude', 'cursor', 'codex', 'gemini', 'openclaw'] as const
+        const spawnHash = ((): number => {
+          let h = 5381
+          const s = newAgentId + ':type'
+          for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) | 0
+          return Math.abs(h)
+        })()
+        const agentType = AGENT_TYPES[spawnHash % AGENT_TYPES.length]!
+
         agentMap.set(newAgentId, {
           id: newAgentId,
           universe_id: 'universe_imported',
           name: `Agent ${newAgentId.slice(-6)}`,
-          type: 'claude',
+          type: agentType,
           sprite_config: {
-            sprite_sheet: 'agents/claude',
+            sprite_sheet: `agents/${agentType}`,
             idle_animation: 'idle',
             walk_animation: 'walk',
             combat_animation: 'combat',

packages/world-model/src/adapter.ts

@@ -507,7 +507,10 @@ function toAgent(actor: ActorRef, snapshot: WorldModelSnapshot, index: number):
   const x = workLoc ? workLoc.x + jitterX : 10
   const y = workLoc ? workLoc.y + jitterY : 10
 
-  const agentType = 'claude'
+  // Deterministically assign agent type from pool based on actor ID
+  // so different agents get visually distinct sprites
+  const AGENT_TYPES = ['claude', 'cursor', 'codex', 'gemini', 'openclaw'] as const
+  const agentType = AGENT_TYPES[djb2(actor.id + ':type') % AGENT_TYPES.length]!
 
   // Collect unique tools used across all work units for this agent
   const usedToolNames = collectUsedTools(actor.id, snapshot)