Checkpoint Devvit v0.0.26

Rarity schema + granulated rarity depictions, and a new-plant NEW badge
so freshly bred seeds are not lost in the alphabetized seed list.

- Add src/shared/valuation.ts: 9-tier rarity schema (common -> primordial)
with bounded rarityIndex (0-100 collectibility, generation saturates so
top tiers stay scarce) and unbounded rarityScore (market valuation);
exported via shared/index.ts
- Depict tiers per seed card: rarity-* left-border colors + primordial
glow and matching rarity-chip text colors (index.css, game.tsx:1900)
- NEW badge for freshly bred seeds: newSeedIds diffed against
knownSeedIdsRef, keyed by seed id so it survives sorting, cleared by
acknowledgeNew; is-new pulse + new-badge (game.tsx, index.css)
- breeder: de-dupe offspring strain name against existing seeds
- lab/predictCross: summary_only + downsample to shrink payload
- color: add vibrance() helper; api: summary_only request field;
agentLink route adjustments

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/client/game.tsx

@@ -6,8 +6,9 @@ import { connectRealtime } from '@devvit/web/client';
 import { StrictMode, useEffect, useMemo, useRef, useState } from 'react';
 import type { CSSProperties } from 'react';
 import { createRoot } from 'react-dom/client';
-import { colorFamily as colorFamilyFromHue } from '../shared/color';
+import { colorFamily as colorFamilyFromHue, vibrance } from '../shared/color';
 import { bloomScoreFromPalette } from '../shared/phenotype';
+import { rarityIndex, rarityTier, type RarityTier } from '../shared/valuation';
 import type {
   BusReceipt,
   BusSignal,
@@ -103,6 +104,7 @@ type InventoryRow = {
   budFamily: string;
   budPattern: string;
   parentText: string;
+  rarity: RarityTier;
 };
 type SpriteSeed = Partial<SeedProfile & InventorySeed> & {
   baseImageName?: string;
@@ -648,9 +650,11 @@ function App() {
   const [hudOpen, setHudOpen] = useState(false);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState('');
+  const [newSeedIds, setNewSeedIds] = useState<Set<string>>(new Set());
 
   const seedsRef = useRef<InventorySeed[]>([]);
   const selectionRef = useRef<string[]>([]);
+  const knownSeedIdsRef = useRef<Set<string> | null>(null);
   const lastAgentEventIdRef = useRef<string | null>(null);
   const agentRefreshInFlightRef = useRef(false);
   const pendingAgentRefreshRef = useRef(false);
@@ -680,6 +684,23 @@ function App() {
     ]);
 
     const twoSlotSelection = selected.ids.slice(0, 2);
+    const incomingIds = inventory.seeds.map((seed) => seed.id);
+    const incomingSet = new Set(incomingIds);
+    const known = knownSeedIdsRef.current;
+    if (known === null) {
+      // First load establishes the baseline; nothing is "new" on arrival.
+      knownSeedIdsRef.current = incomingSet;
+    } else {
+      const fresh = incomingIds.filter((id) => !known.has(id));
+      setNewSeedIds((prev) => {
+        const next = new Set<string>();
+        for (const id of prev) if (incomingSet.has(id)) next.add(id);
+        for (const id of fresh) next.add(id);
+        return next;
+      });
+      knownSeedIdsRef.current = incomingSet;
+    }
+
     setUsername(init.username);
     setPostId(init.postId);
     setSeeds(inventory.seeds);
@@ -796,7 +817,17 @@ function App() {
     selectionRef.current = twoSlotSelection;
   }
 
+  function acknowledgeNew(seedId: string) {
+    setNewSeedIds((prev) => {
+      if (!prev.has(seedId)) return prev;
+      const next = new Set(prev);
+      next.delete(seedId);
+      return next;
+    });
+  }
+
   function toggleSelection(seedId: string) {
+    acknowledgeNew(seedId);
     const current = selectionRef.current;
     const next = current.includes(seedId) ? current.filter((id) => id !== seedId) : [...current, seedId].slice(-2);
     void run('selection', async () => updateSelection(next));
@@ -817,15 +848,22 @@ function App() {
     await refreshAll();
   }
 
-  async function growSeed(seedId: string) {
+  // SEED -> SEEDLING -> MATURE is a fixed two-step ladder with no time gate, so
+  // growing advances straight to maturity. Grow on a MATURE plant is a server no-op.
+  async function growToMature(seedId: string) {
     await postJson(`/api/seed/${seedId}/grow`);
+    await postJson(`/api/seed/${seedId}/grow`);
+  }
+
+  async function growSeed(seedId: string) {
+    await growToMature(seedId);
     await refreshAll();
   }
 
   async function growAll() {
     const immature = seedsRef.current.filter((seed) => seed.stage !== 'MATURE');
     for (const seed of immature) {
-      await postJson(`/api/seed/${seed.id}/grow`);
+      await growToMature(seed.id);
     }
     await refreshAll();
   }
@@ -834,7 +872,7 @@ function App() {
     const currentSeeds = new Map(seedsRef.current.map((seed) => [seed.id, seed]));
     const selected = selectionRef.current.map((id) => currentSeeds.get(id)).filter((seed): seed is InventorySeed => Boolean(seed));
     for (const seed of selected) {
-      if (seed.stage !== 'MATURE') await postJson(`/api/seed/${seed.id}/grow`);
+      if (seed.stage !== 'MATURE') await growToMature(seed.id);
     }
     await refreshAll();
   }
@@ -1003,6 +1041,7 @@ function App() {
             onToggle={toggleSelection}
             onRemoveSelection={removeSelection}
             agentHighlightSeedId={agentUiIntent?.highlightSeedId}
+            newSeedIds={newSeedIds}
           />
         ) : null}
         {view === 'lab' ? (
@@ -1120,9 +1159,11 @@ function PlayView(props: {
   onToggle: (seedId: string) => void;
   onRemoveSelection: (seedId: string) => void;
   agentHighlightSeedId?: string | undefined;
+  newSeedIds: Set<string>;
 }) {
   const generationCache = new Map<string, number>();
   const [inventoryFilters, setInventoryFilters] = useState<InventoryFilters>(DEFAULT_INVENTORY_FILTERS);
+  const [maximizedSeed, setMaximizedSeed] = useState<InventorySeed | null>(null);
   const [labIntakeHidden, setLabIntakeHidden] = useState(() => readLocalStorage(LAB_INTAKE_HIDDEN_KEY) === '1');
   const [chaseGoal, setChaseGoal] = useState<ChaseGoal>(() => {
     const stored = readLocalStorage(LAB_INTAKE_GOAL_KEY);
@@ -1233,6 +1274,7 @@ function PlayView(props: {
             onClone={props.onClone}
             onRemove={props.onRemoveSelection}
             highlighted={props.agentHighlightSeedId === props.selectedSeeds[0]?.id}
+            onMaximize={() => props.selectedSeeds[0] && setMaximizedSeed(props.selectedSeeds[0])}
           />
           <ParentSlot
             label="Parent B"
@@ -1243,6 +1285,7 @@ function PlayView(props: {
             onClone={props.onClone}
             onRemove={props.onRemoveSelection}
             highlighted={props.agentHighlightSeedId === props.selectedSeeds[1]?.id}
+            onMaximize={() => props.selectedSeeds[1] && setMaximizedSeed(props.selectedSeeds[1])}
           />
         </div>
         <PredictionPanel prediction={props.prediction} />
@@ -1281,6 +1324,9 @@ function PlayView(props: {
                 onToggle={() => props.onToggle(row.seed.id)}
                 onClone={() => props.onClone(row.seed.id)}
                 highlighted={props.agentHighlightSeedId === row.seed.id}
+                rarity={row.rarity}
+                isNew={props.newSeedIds.has(row.seed.id)}
+                onMaximize={() => setMaximizedSeed(row.seed)}
               />
             ))}
           </div>
@@ -1289,6 +1335,64 @@ function PlayView(props: {
         )}
         {props.seeds.length && !filteredRows.length ? <div className="empty-state">No specimens match the active lab filters.</div> : null}
       </section>
+      {maximizedSeed ? <PlantModal seed={maximizedSeed} byId={props.byId} onClose={() => setMaximizedSeed(null)} /> : null}
+    </div>
+  );
+}
+
+function PlantModal({ seed, byId, onClose }: { seed: InventorySeed; byId: Map<string, InventorySeed>; onClose: () => void }) {
+  useEffect(() => {
+    function onKey(event: KeyboardEvent) {
+      if (event.key === 'Escape') onClose();
+    }
+    window.addEventListener('keydown', onKey);
+    return () => window.removeEventListener('keydown', onKey);
+  }, [onClose]);
+  const generation = generationOf(seed, byId);
+  const row = inventoryRow(seed, generation, byId);
+  const parents = seed.lineage.map((parentId) => (parentId ? byId.get(parentId)?.name ?? shortId(parentId) : 'founder'));
+  const cloneRoom = Math.max(0, seed.max_attempts - seed.attempts_used);
+  return (
+    <div className="plant-modal-backdrop" onClick={onClose}>
+      <div className={`plant-modal rarity-${row.rarity}`} role="dialog" aria-modal="true" onClick={(event) => event.stopPropagation()}>
+        <div className="plant-modal-bar">
+          <div className="plant-modal-title">
+            <h2>{seed.name}</h2>
+            <span className={`rarity-chip rarity-${row.rarity}`}>{row.rarity}</span>
+          </div>
+          <button className="plant-modal-close" type="button" onClick={onClose}>Close</button>
+        </div>
+        <div className="plant-modal-body">
+          <div className="plant-modal-stage">
+            <GeneticSprite className="plant-modal-img" seed={seed} stage="mature" />
+            <div className="plant-modal-swatches">
+              <div className="swatch-line"><span className="swatch" style={{ background: rgb(seed.bud_color) }} /><span>Bud {seed.bud_color.join(', ')} / hue {hueFromRgb(seed.bud_color)}</span></div>
+              <PaletteStrip colors={seed.bud_palette} />
+              <div className="swatch-line"><span className="swatch" style={{ background: rgb(seed.leaf_color) }} /><span>Leaf {seed.leaf_color.join(', ')} / hue {hueFromRgb(seed.leaf_color)}</span></div>
+              <PaletteStrip colors={seed.leaf_palette} />
+            </div>
+          </div>
+          <div className="plant-modal-info">
+            <p className="plant-modal-sub">{seed.type} / F{generation} / {seed.stage} / {seed.is_starter ? 'starter' : 'derived'} / {row.budPattern}</p>
+            <div className="stat-grid">
+              <Stat label="THC" value={`${fmt(seed.thc)}%`} />
+              <Stat label="CBD" value={`${fmt(seed.cbd)}%`} />
+              <Stat label="Yield" value={`${fmt(seed.yield)}g`} />
+              <Stat label="Grow" value={`${fmt(seed.grow_time)}d`} />
+              <Stat label="Bloom" value={fmt(row.bloom.score, 1)} />
+              <Stat label="Volatility" value={fmt(row.volatility, 2)} />
+              <Stat label="Attempts" value={`${cloneRoom} left`} />
+              <Stat label="Colors" value={row.bloom.colorCount} />
+            </div>
+            <TraitMatrix seed={seed} />
+            <div className="lineage-box">
+              <div><b>ID</b><span>{seed.id}</span></div>
+              <div><b>Parents</b><span>{parents.join(' / ')}</span></div>
+              <div><b>Description</b><span>{seed.description || 'No description'}</span></div>
+            </div>
+          </div>
+        </div>
+      </div>
     </div>
   );
 }
@@ -1496,6 +1600,7 @@ function ParentSlot({
   onClone,
   onRemove,
   highlighted,
+  onMaximize,
 }: {
   label: string;
   seed: InventorySeed | undefined;
@@ -1505,6 +1610,7 @@ function ParentSlot({
   onClone: (seedId?: string) => void;
   onRemove: (seedId: string) => void;
   highlighted?: boolean;
+  onMaximize?: () => void;
 }) {
   if (!seed) {
     return (
@@ -1534,7 +1640,7 @@ function ParentSlot({
             <Stat label="CBD" value={`${fmt(seed.cbd)}%`} />
             <Stat label="Yield" value={`${fmt(seed.yield)}g`} />
             <Stat label="Grow" value={`${fmt(seed.grow_time)}d`} />
-            <Stat label="Attempts" value={`${seed.attempts_used}/${seed.max_attempts}`} />
+            <Stat label="Attempts" value={`${Math.max(0, seed.max_attempts - seed.attempts_used)} left`} />
             <Stat label="Can breed" value={seed.can_attempt ? 'yes' : 'no'} />
           </div>
         </div>
@@ -1556,6 +1662,7 @@ function ParentSlot({
       <div className="slot-actions">
         <button disabled={seed.stage === 'MATURE'} onClick={() => onGrow(seed.id)}>Grow</button>
         <button disabled={!seed.can_attempt} onClick={() => onClone(seed.id)}>Clone</button>
+        <button onClick={onMaximize}>Expand</button>
         <button onClick={() => onRemove(seed.id)}>Remove</button>
       </div>
     </article>
@@ -1574,6 +1681,9 @@ function SeedCard({
   onToggle,
   onClone,
   highlighted,
+  rarity,
+  isNew,
+  onMaximize,
 }: {
   seed: InventorySeed;
   selected: boolean;
@@ -1586,9 +1696,14 @@ function SeedCard({
   onToggle: () => void;
   onClone: () => void;
   highlighted?: boolean;
+  rarity: RarityTier;
+  isNew?: boolean;
+  onMaximize: () => void;
 }) {
   return (
-    <article className={`seed-card${selected ? ' selected' : ''}${highlighted ? ' agent-highlight' : ''}`}>
+    <article className={`seed-card rarity-${rarity}${isNew ? ' is-new' : ''}${selected ? ' selected' : ''}${highlighted ? ' agent-highlight' : ''}`}>
+      {isNew ? <span className="new-badge">NEW</span> : null}
+      <button className="card-expand" type="button" title="Full view" aria-label="Open full view" onClick={onMaximize}>Expand</button>
       <div className="seed-head">
         <GeneticSprite className="seed-img" seed={seed} />
         <div>
@@ -1597,9 +1712,10 @@ function SeedCard({
         </div>
       </div>
       <div className="seed-meta-line">
+        <span className={`rarity-chip rarity-${rarity}`}>{rarity}</span>
         <span>{seed.is_starter ? 'starter' : 'derived'}</span>
         <span>{shortId(seed.id)}</span>
-        <span>{seed.attempts_used}/{seed.max_attempts} attempts</span>
+        <span>{Math.max(0, seed.max_attempts - seed.attempts_used)} left</span>
         <span>Bloom {fmt(bloomScore, 1)}</span>
         <span>Vol {fmt(volatility, 2)}</span>
         <span>{budPattern}</span>
@@ -1780,15 +1896,28 @@ function inventoryRow(seed: InventorySeed, generation: number, byId: Map<string,
   const stability = meanSeedStability(seed);
   const budPalette = spritePalette(seed, 'bud');
   const parentText = seed.lineage.map((parentId) => (parentId ? byId.get(parentId)?.name ?? shortId(parentId) : 'founder')).join(' / ');
+  const bloom = bloomScoreFromPalette(budPalette, (seed.bud_pattern ?? seed.budPattern ?? 'solid') as InventorySeed['budPattern']);
+  const rarity = rarityTier(rarityIndex({
+    thc: seed.thc,
+    cbd: seed.cbd,
+    yield: seed.yield,
+    growTime: seed.grow_time,
+    stability,
+    generation,
+    vibrance: vibrance(seed.bud_color),
+    bloom: bloom.score,
+    canAttempt: seed.can_attempt,
+  }));
   return {
     seed,
     generation,
     stability,
     volatility: Math.round((1 - stability) * 1000) / 1000,
-    bloom: bloomScoreFromPalette(budPalette, (seed.bud_pattern ?? seed.budPattern ?? 'solid') as InventorySeed['budPattern']),
+    bloom,
     budFamily: colorFamilyFromHue(hueFromRgb(seed.bud_color)),
     budPattern: String(seed.bud_pattern ?? seed.budPattern ?? 'solid'),
     parentText,
+    rarity,
   };
 }
 
@@ -2207,7 +2336,7 @@ function DeckView({
                 <GeneticSprite seed={seed} />
                 <div>
                   <b>{seed.name}</b>
-                  <span>{seed.stage} / THC {fmt(seed.thc)} / Yield {fmt(seed.yield)} / attempts {seed.attempts_used}/{seed.max_attempts}</span>
+                  <span>{seed.stage} / THC {fmt(seed.thc)} / Yield {fmt(seed.yield)} / {Math.max(0, seed.max_attempts - seed.attempts_used)} attempts left</span>
                 </div>
                 <span className="swatch" style={{ background: rgb(seed.bud_color) }} />
               </div>
@@ -2494,7 +2623,7 @@ function MarketView({
                   <GeneticSprite seed={seed} />
                   <div>
                     <b>{seed.name}</b>
-                    <span>{seed.stage} / THC {fmt(seed.thc)} / Yield {fmt(seed.yield)} / attempts {seed.attempts_used}/{seed.max_attempts}</span>
+                    <span>{seed.stage} / THC {fmt(seed.thc)} / Yield {fmt(seed.yield)} / {Math.max(0, seed.max_attempts - seed.attempts_used)} attempts left</span>
                   </div>
                   <button disabled={busy || !seed.can_attempt} onClick={() => onListClone(seed.id)}>List clone</button>
                   <button className="danger" disabled={busy} onClick={() => onListPlant(seed.id)}>List plant</button>

src/client/index.css

@@ -251,8 +251,111 @@ code, pre { font-family: ui-monospace, SFMono-Regular, Consolas, "Liberation Mon
 .chip { border: 1px solid var(--green-2); background: #182318; color: #dff5d8; border-radius: 999px; padding: 4px 8px; font-size: 12px; }
 .chip.alt { border-color: #315675; background: #15202a; color: #d7ecff; }
 .registry-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(235px, 1fr)); gap: 10px; max-height: calc(100vh - 238px); overflow: auto; padding-right: 2px; }
-.seed-card { display: grid; grid-template-rows: auto auto auto auto 1fr auto; gap: 8px; border: 1px solid var(--line); border-radius: 8px; background: #151a1b; padding: 10px; min-height: 288px; }
+.seed-card { position: relative; display: grid; grid-template-rows: auto auto auto auto 1fr auto; gap: 8px; border: 1px solid var(--line); border-radius: 8px; background: #151a1b; padding: 10px; min-height: 288px; }
 .seed-card.selected { border-color: var(--green); box-shadow: 0 0 0 1px rgba(139, 211, 111, 0.45); }
+
+/* Rarity ladder edge (9 tiers, ascending heat). common stays edgeless to keep quiet. */
+.seed-card.rarity-uncommon { border-left: 3px solid #6f9e5a; }
+.seed-card.rarity-notable { border-left: 3px solid var(--blue); }
+.seed-card.rarity-rare { border-left: 3px solid var(--cyan); }
+.seed-card.rarity-elite { border-left: 3px solid var(--violet); }
+.seed-card.rarity-exotic { border-left: 3px solid #e07bc4; }
+.seed-card.rarity-legendary { border-left: 3px solid var(--amber); }
+.seed-card.rarity-mythic { border-left: 3px solid #f0873f; }
+.seed-card.rarity-primordial { border-left: 3px solid #ffd76a; box-shadow: 0 0 0 1px rgba(255, 215, 106, 0.35), 0 0 18px rgba(255, 215, 106, 0.22); }
+
+.rarity-chip { text-transform: capitalize; color: var(--muted); }
+.rarity-chip.rarity-uncommon { color: #8fca74; border-color: rgba(111, 158, 90, 0.5); }
+.rarity-chip.rarity-notable { color: var(--blue); border-color: rgba(119, 183, 239, 0.5); }
+.rarity-chip.rarity-rare { color: var(--cyan); border-color: rgba(101, 210, 208, 0.5); }
+.rarity-chip.rarity-elite { color: var(--violet); border-color: rgba(168, 138, 232, 0.5); }
+.rarity-chip.rarity-exotic { color: #e07bc4; border-color: rgba(224, 123, 196, 0.5); }
+.rarity-chip.rarity-legendary { color: var(--amber); border-color: rgba(229, 190, 102, 0.6); }
+.rarity-chip.rarity-mythic { color: #f0873f; border-color: rgba(240, 135, 63, 0.6); }
+.rarity-chip.rarity-primordial { color: #ffd76a; border-color: rgba(255, 215, 106, 0.7); }
+
+/* Session-new plants: badge + pulse so fresh breeds are findable in the alphabetized list. */
+.new-badge {
+  position: absolute;
+  top: -7px;
+  right: -6px;
+  z-index: 3;
+  padding: 2px 7px;
+  font-size: 10px;
+  font-weight: 700;
+  letter-spacing: 0.06em;
+  color: #0d0f12;
+  background: var(--green);
+  border-radius: 999px;
+  box-shadow: 0 1px 6px rgba(139, 211, 111, 0.5);
+}
+.seed-card.is-new { border-color: var(--green); animation: newPulse 1.4s ease-in-out infinite alternate; }
+@keyframes newPulse {
+  from { box-shadow: 0 0 0 1px rgba(139, 211, 111, 0.3); }
+  to { box-shadow: 0 0 0 1px rgba(139, 211, 111, 0.72), 0 0 16px rgba(139, 211, 111, 0.22); }
+}
+
+/* Per-card Expand affordance -> full-window plant view */
+.card-expand {
+  position: absolute;
+  top: 6px;
+  left: 6px;
+  z-index: 2;
+  min-height: 0;
+  padding: 2px 8px;
+  font-size: 10px;
+  line-height: 1.5;
+  border-radius: 999px;
+  background: rgba(13, 15, 18, 0.72);
+  border-color: var(--line-soft);
+  color: var(--muted);
+  opacity: 0.6;
+  transition: opacity 0.12s ease, color 0.12s ease, border-color 0.12s ease;
+}
+.seed-card:hover .card-expand, .seed-card:focus-within .card-expand { opacity: 1; }
+.card-expand:hover:not(:disabled) { color: var(--text); border-color: var(--green); background: #202724; }
+
+.plant-modal-backdrop {
+  position: fixed;
+  inset: 0;
+  z-index: 120;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+  background: rgba(6, 8, 9, 0.78);
+  backdrop-filter: blur(3px);
+  overflow: auto;
+}
+.plant-modal {
+  width: min(940px, 100%);
+  max-height: 92vh;
+  overflow: auto;
+  display: grid;
+  gap: 12px;
+  padding: 16px;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: var(--panel);
+  box-shadow: 0 24px 80px rgba(0, 0, 0, 0.55);
+}
+.plant-modal-bar { display: flex; align-items: center; justify-content: space-between; gap: 12px; }
+.plant-modal-title { display: flex; align-items: center; gap: 10px; min-width: 0; }
+.plant-modal-title h2 { margin: 0; font-size: 22px; overflow-wrap: anywhere; }
+.plant-modal-close { min-height: 30px; }
+.plant-modal-body { display: grid; grid-template-columns: minmax(0, 360px) minmax(0, 1fr); gap: 16px; align-items: start; }
+.plant-modal-stage { display: grid; gap: 10px; }
+.plant-modal-img { width: 100%; aspect-ratio: 1; object-fit: contain; image-rendering: pixelated; border: 1px solid var(--line); border-radius: 10px; background: #0b0e0f; }
+.plant-modal-swatches { display: grid; gap: 6px; }
+.plant-modal-info { display: grid; gap: 10px; align-content: start; }
+.plant-modal-sub { margin: 0; color: var(--muted); font-size: 13px; }
+.plant-modal .stat-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 6px; }
+.plant-modal .trait-matrix { max-height: none; }
+@media (max-width: 680px) {
+  .plant-modal-body { grid-template-columns: 1fr; }
+  .plant-modal-img { max-width: 320px; justify-self: center; }
+  .plant-modal .stat-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+}
 .seed-head { display: grid; grid-template-columns: 60px minmax(0, 1fr); gap: 10px; align-items: center; }
 .seed-img { width: 60px; height: 60px; object-fit: contain; image-rendering: pixelated; border: 1px solid var(--line); border-radius: 7px; background: #0b0e0f; }
 .seed-head h3 { margin: 0; font-size: 15px; line-height: 1.18; overflow-wrap: anywhere; }

src/server/routes/agentLink.ts

@@ -17,9 +17,13 @@ import {
   newId,
   nowIso,
   predictCross,
+  rarityIndex,
+  rarityScore,
+  rarityTier,
   replaceSeeds,
+  vibrance,
 } from '../../shared';
-import type { BusReceipt, GameState, SeedProfile } from '../../shared';
+import type { BusReceipt, GameState, RarityTier, SeedProfile } from '../../shared';
 
 type RuntimeIdentity = { postId: string; username: string };
 const BROKER_USERNAME = 'Maryjane_Broker';
@@ -71,7 +75,7 @@ type InventorySeed = SeedProfile & {
 
 type SeedValuation = {
   score: number;
-  tier: 'common' | 'notable' | 'rare' | 'elite' | 'legendary';
+  tier: RarityTier;
   commonCloneEquivalent: number;
   leaderboardEvidence: Array<{ metric: string; rank: number; score: number }>;
   traits: {
@@ -252,7 +256,7 @@ const AGENT_LINK_TOOLS: AgentLinkTool[] = [
   { name: 'grow', label: 'Grow specimen', scope: 'garden', risk: 'mutating', description: 'Advance one specimen by one growth stage.', input: { seed_id: { type: 'string' } } },
   { name: 'grow_selected', label: 'Grow selected', scope: 'garden', risk: 'mutating', description: 'Advance each selected on-deck specimen by one stage.', input: {} },
   { name: 'grow_all', label: 'Grow all', scope: 'garden', risk: 'mutating', description: 'Advance every immature specimen by one stage.', input: {} },
-  { name: 'predict_cross', label: 'Predict cross', scope: 'breed', risk: 'inspect', description: 'Run the cross predictor for two parents or current on-deck plants.', input: { parent1_id: { type: 'string' }, parent2_id: { type: 'string' }, n: { type: 'integer' } } },
+  { name: 'predict_cross', label: 'Predict cross', scope: 'breed', risk: 'inspect', description: 'Run the cross predictor for two parents or current on-deck plants. Pass summary_only=true to drop raw per-sample arrays and color clouds for a lighter payload.', input: { parent1_id: { type: 'string' }, parent2_id: { type: 'string' }, n: { type: 'integer' }, summary_only: { type: 'boolean' } } },
   { name: 'breed', label: 'Breed parents', scope: 'breed', risk: 'mutating', description: 'Breed two parents or the current on-deck plants.', input: { parent1_id: { type: 'string' }, parent2_id: { type: 'string' } } },
   { name: 'clone', label: 'Clone plant', scope: 'garden', risk: 'mutating', description: 'Clone one plant into the owner inventory.', input: { seed_id: { type: 'string' } } },
   { name: 'inspect_market', label: 'Inspect exchange', scope: 'market', risk: 'inspect', description: 'Read clone exchange listings, offers, sequence candidates, and order-book stats.', input: {} },
@@ -432,40 +436,37 @@ function addMissingStarters(state: GameState): GameState {
   return missing.length ? replaceSeeds(state, [...state.seeds, ...missing]) : state;
 }
 
-function vibrance(color: SeedProfile['budColor']): number {
-  const [red, green, blue] = color;
-  return Math.round(((Math.max(red, green, blue) - Math.min(red, green, blue)) / 255) * 1000) / 10;
-}
-
-function valuationTier(score: number): SeedValuation['tier'] {
-  if (score >= 85) return 'legendary';
-  if (score >= 70) return 'elite';
-  if (score >= 55) return 'rare';
-  if (score >= 38) return 'notable';
-  return 'common';
-}
-
 function valuationFromRecord(record: LabRecord, leaderboard: LeaderboardEntry[]): SeedValuation {
   const vibranceScore = vibrance(record.budColor);
   const bloomScore = record.Bloom;
-  const score = Math.round((
-    record.THC * 1.35 +
-    record.CBD * 0.55 +
-    record.Yield * 0.18 +
-    Math.max(0, 90 - record.GrowTime) * 0.18 +
-    record.Stability * 18 +
-    record.generation * 4 +
-    vibranceScore * 0.16 +
-    bloomScore * 0.14 +
-    (record.canAttempt ? 5 : 0)
-  ) * 10) / 10;
+  const score = rarityScore({
+    thc: record.THC,
+    cbd: record.CBD,
+    yield: record.Yield,
+    growTime: record.GrowTime,
+    stability: record.Stability,
+    generation: record.generation,
+    vibrance: vibranceScore,
+    bloom: bloomScore,
+    canAttempt: record.canAttempt,
+  });
   const evidence = leaderboard
     .filter((entry) => entry.seedId === record.germplasmDbId && entry.rank !== undefined && entry.rank <= 10)
     .map((entry) => ({ metric: entry.metric, rank: entry.rank ?? 0, score: entry.score }))
     .slice(0, 6);
   return {
     score,
-    tier: valuationTier(score),
+    tier: rarityTier(rarityIndex({
+      thc: record.THC,
+      cbd: record.CBD,
+      yield: record.Yield,
+      growTime: record.GrowTime,
+      stability: record.Stability,
+      generation: record.generation,
+      vibrance: vibranceScore,
+      bloom: bloomScore,
+      canAttempt: record.canAttempt,
+    })),
     commonCloneEquivalent: Math.max(1, Math.min(12, Math.round(score / 18))),
     leaderboardEvidence: evidence,
     traits: {
@@ -1431,7 +1432,8 @@ async function runAgentLinkTool(id: RuntimeIdentity, session: AgentLinkSession,
     const seed = findSeed(state, seedId);
     if (!seed) throw new Error('Seed not found');
     const next = await saveState(id, replaceSeeds(state, state.seeds.map((item) => item.seedId === seedId ? { ...item, growthStage: advanceGrowthStage(item.growthStage) } : item)));
-    result = { seed: findSeed(next, seedId) };
+    const grown = findSeed(next, seedId);
+    result = { seed: grown ? toInventorySeed(grown) : null };
   } else if (toolName === 'grow_selected' || toolName === 'grow_all') {
     const state = await loadState(id);
     const selected = new Set(toolName === 'grow_selected' ? state.selection : state.seeds.map((seed) => seed.seedId));
@@ -1443,7 +1445,7 @@ async function runAgentLinkTool(id: RuntimeIdentity, session: AgentLinkSession,
     const parentOne = findSeed(state, left);
     const parentTwo = findSeed(state, right);
     if (!parentOne || !parentTwo) throw new Error('Parents not found');
-    result = predictCross(parentOne, parentTwo, typeof args.n === 'number' ? args.n : 300);
+    result = predictCross(parentOne, parentTwo, typeof args.n === 'number' ? args.n : 300, args.summary_only === true);
   } else if (toolName === 'breed') {
     const state = await loadState(id);
     const [left, right] = selectedParentIds(state, args);

src/server/routes/api.ts

@@ -397,7 +397,7 @@ api.post('/lab/predict-cross', async (c) => {
   const parentOne = findSeed(state, request.parent1_id);
   const parentTwo = findSeed(state, request.parent2_id);
   if (!parentOne || !parentTwo) return jsonError(c, 'Parents not found', 404);
-  return c.json(predictCross(parentOne, parentTwo, request.n ?? 200));
+  return c.json(predictCross(parentOne, parentTwo, request.n ?? 200, request.summary_only === true));
 });
 
 api.get('/lab/newick', async (c) => {

src/shared/api.ts

@@ -30,6 +30,7 @@ export type CrossRequest = {
   parent1_id: string;
   parent2_id: string;
   n?: number;
+  summary_only?: boolean;
 };
 
 export type BreedRequest = {

src/shared/breeder.ts

@@ -258,7 +258,11 @@ export function breedInState(
   if (!parentOne || !parentTwo) {
     throw new Error('Parents not found');
   }
-  const offspring = breedProfiles(parentOne, parentTwo, rng);
+  let offspring = breedProfiles(parentOne, parentTwo, rng);
+  const takenNames = new Set(state.seeds.map((seed) => seed.strainName));
+  if (takenNames.has(offspring.strainName)) {
+    offspring = { ...offspring, strainName: `${offspring.strainName} ${offspring.seedId.slice(-4)}` };
+  }
   const seeds = state.seeds.map((seed) => {
     if (seed.seedId === parentOne.seedId || seed.seedId === parentTwo.seedId) {
       return { ...seed, attemptsUsed: seed.attemptsUsed + 1 };

src/shared/color.ts

@@ -81,6 +81,11 @@ export function hueFromRgb(rgb: Rgb): number {
   return Math.round(rgbToHsv(rgb)[0] * 10) / 10;
 }
 
+export function vibrance(rgb: Rgb): number {
+  const [red, green, blue] = rgb;
+  return Math.round(((Math.max(red, green, blue) - Math.min(red, green, blue)) / 255) * 1000) / 10;
+}
+
 export function colorFamily(hue: number): string {
   if (hue < 15 || hue >= 330) return 'red';
   if (hue < 40) return 'orange';

src/shared/index.ts

@@ -9,3 +9,4 @@ export * from './phenotype';
 export * from './rng';
 export * from './state';
 export * from './types';
+export * from './valuation';

src/shared/lab.ts

@@ -125,7 +125,15 @@ export function labPayload(seeds: SeedProfile[]): LabPayload {
   };
 }
 
-function summarize(values: number[]): DistributionSummary {
+function downsample<T>(values: T[], cap: number): T[] {
+  if (values.length <= cap) return values;
+  const step = values.length / cap;
+  const out: T[] = [];
+  for (let index = 0; index < cap; index += 1) out.push(values[Math.floor(index * step)] as T);
+  return out;
+}
+
+function summarize(values: number[], keepValues = true, cap = 80): DistributionSummary {
   const sorted = [...values].sort((left, right) => left - right);
   const total = sorted.reduce((sum, value) => sum + value, 0);
   return {
@@ -133,7 +141,7 @@ function summarize(values: number[]): DistributionSummary {
     max: sorted[sorted.length - 1] ?? 0,
     mean: sorted.length ? Math.round((total / sorted.length) * 100) / 100 : 0,
     median: sorted[Math.floor(sorted.length / 2)] ?? 0,
-    values,
+    values: keepValues ? downsample(values, cap) : [],
   };
 }
 
@@ -149,11 +157,11 @@ function bloomHint(summary: { score: DistributionSummary; volatility: Distributi
   return `stable expression: safer traits, lower bloom odds`;
 }
 
-function bloomSummary(scores: number[], volatilities: number[], colorCounts: number[], patterns: Record<ColorPattern, number>): BloomPredictionSummary {
+function bloomSummary(scores: number[], volatilities: number[], colorCounts: number[], patterns: Record<ColorPattern, number>, keepValues = true): BloomPredictionSummary {
   const summary = {
-    score: summarize(scores),
-    volatility: summarize(volatilities),
-    colorCount: summarize(colorCounts),
+    score: summarize(scores, keepValues),
+    volatility: summarize(volatilities, keepValues),
+    colorCount: summarize(colorCounts, keepValues),
     maxColors: Math.max(0, ...colorCounts),
     patterns,
     hint: '',
@@ -161,7 +169,7 @@ function bloomSummary(scores: number[], volatilities: number[], colorCounts: num
   return { ...summary, hint: bloomHint(summary) };
 }
 
-export function predictCross(parentOne: SeedProfile, parentTwo: SeedProfile, sampleCount = 200): CrossPrediction {
+export function predictCross(parentOne: SeedProfile, parentTwo: SeedProfile, sampleCount = 200, summaryOnly = false): CrossPrediction {
   const n = Math.max(20, Math.min(1000, sampleCount));
   const thc: number[] = [];
   const cbd: number[] = [];
@@ -199,17 +207,18 @@ export function predictCross(parentOne: SeedProfile, parentTwo: SeedProfile, sam
     incrementPattern(leafPatterns, phenotype.leafPattern);
   }
 
+  const keepValues = !summaryOnly;
   return {
     n,
     parents: [parentOne.strainName, parentTwo.strainName],
-    THC: summarize(thc),
-    CBD: summarize(cbd),
-    Yield: summarize(yieldValues),
-    GrowTime: summarize(growTime),
-    budCloud,
-    leafCloud,
-    budBloom: bloomSummary(budBloomScores, budVolatility, budColorCounts, budPatterns),
-    leafBloom: bloomSummary(leafBloomScores, leafVolatility, leafColorCounts, leafPatterns),
+    THC: summarize(thc, keepValues),
+    CBD: summarize(cbd, keepValues),
+    Yield: summarize(yieldValues, keepValues),
+    GrowTime: summarize(growTime, keepValues),
+    budCloud: summaryOnly ? [] : downsample(budCloud, 80),
+    leafCloud: summaryOnly ? [] : downsample(leafCloud, 80),
+    budBloom: bloomSummary(budBloomScores, budVolatility, budColorCounts, budPatterns, keepValues),
+    leafBloom: bloomSummary(leafBloomScores, leafVolatility, leafColorCounts, leafPatterns, keepValues),
   };
 }
 

src/shared/valuation.ts

@@ -0,0 +1,100 @@
+export type RarityTier =
+  | 'common'
+  | 'uncommon'
+  | 'notable'
+  | 'rare'
+  | 'elite'
+  | 'exotic'
+  | 'legendary'
+  | 'mythic'
+  | 'primordial';
+
+// Ascending order (weakest -> apex). Index positions double as a numeric rank.
+export const RARITY_TIERS: RarityTier[] = [
+  'common',
+  'uncommon',
+  'notable',
+  'rare',
+  'elite',
+  'exotic',
+  'legendary',
+  'mythic',
+  'primordial',
+];
+
+export type RarityInput = {
+  thc: number;
+  cbd: number;
+  yield: number;
+  growTime: number;
+  stability: number;
+  generation: number;
+  vibrance: number;
+  bloom: number;
+  canAttempt: boolean;
+};
+
+function clamp01(value: number): number {
+  return Math.max(0, Math.min(1, value));
+}
+
+// Market valuation: unbounded, drives pricing (commonCloneEquivalent) and the
+// leaderboard "Rarity" metric. Left intentionally as-is so the economy is untouched.
+export function rarityScore(input: RarityInput): number {
+  return Math.round((
+    input.thc * 1.35 +
+    input.cbd * 0.55 +
+    input.yield * 0.18 +
+    Math.max(0, 90 - input.growTime) * 0.18 +
+    input.stability * 18 +
+    input.generation * 4 +
+    input.vibrance * 0.16 +
+    input.bloom * 0.14 +
+    (input.canAttempt ? 5 : 0)
+  ) * 10) / 10;
+}
+
+// Bounded 0-100 collectibility index that drives the visual rarity TIER only.
+// Every term is normalized to 0..1 and generation saturates (gen/(gen+6)) so
+// breeding deeper cannot inflate a plant into the top tier forever -- the top
+// tiers stay rare permanently, unlike the raw score.
+export function rarityIndex(input: RarityInput): number {
+  const potency = clamp01(input.thc / 40);
+  const cannabinoid = clamp01(input.cbd / 18);
+  const yieldN = clamp01((input.yield - 25) / 135);
+  const speed = clamp01((90 - input.growTime) / 50);
+  const stability = clamp01(input.stability);
+  const bloomN = clamp01(input.bloom / 100);
+  const vibranceN = clamp01(input.vibrance / 100);
+  const genN = input.generation / (input.generation + 6);
+  const blended =
+    potency * 0.2 +
+    bloomN * 0.18 +
+    genN * 0.15 +
+    vibranceN * 0.12 +
+    yieldN * 0.1 +
+    stability * 0.1 +
+    speed * 0.09 +
+    cannabinoid * 0.06;
+  return Math.round(clamp01(blended) * 1000) / 10;
+}
+
+// Thresholds calibrated against the simulated index distribution (the index tops
+// out near 80 in practice) so every tier is reachable and legendary+ stay scarce:
+// veterans land ~58% exotic / 12% legendary / 2% mythic / 0.1% primordial, while
+// early players span common->rare with headroom to climb.
+export function rarityTier(index: number): RarityTier {
+  if (index >= 77) return 'primordial';
+  if (index >= 74) return 'mythic';
+  if (index >= 70) return 'legendary';
+  if (index >= 65) return 'exotic';
+  if (index >= 60) return 'elite';
+  if (index >= 55) return 'rare';
+  if (index >= 49) return 'notable';
+  if (index >= 43) return 'uncommon';
+  return 'common';
+}
+
+export function rarityRank(tier: RarityTier): number {
+  return RARITY_TIERS.indexOf(tier);
+}