@holoscript/framework 6.0.3

package/src/swarm/spatial/__tests__/ZoneClaiming.prod.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ZoneClaiming } from '../ZoneClaiming';
+import { Vector3 } from '../Vector3';
+
+// ─── helpers ────────────────────────────────────────────────────────────────
+
+function mkZC(cfg?: ConstructorParameters<typeof ZoneClaiming>[0]) {
+  return new ZoneClaiming(cfg);
+}
+
+function v(x: number, y = 0, z = 0) {
+  return new Vector3(x, y, z);
+}
+
+function makeZone(zc: ZoneClaiming, id = 'z1', center = v(0), radius = 10) {
+  return zc.createZone(id, center, radius);
+}
+
+// ─── tests ───────────────────────────────────────────────────────────────────
+
+describe('ZoneClaiming — defaultConfig', () => {
+  it('claimThreshold = 0.3', () => expect(mkZC().getConfig().claimThreshold).toBe(0.3));
+  it('captureThreshold = 0.7', () => expect(mkZC().getConfig().captureThreshold).toBe(0.7));
+  it('strengthDecayRate = 0.05', () => expect(mkZC().getConfig().strengthDecayRate).toBe(0.05));
+  it('reinforceRate = 0.1', () => expect(mkZC().getConfig().reinforceRate).toBe(0.1));
+  it('defenseBonus = 0.15', () => expect(mkZC().getConfig().defenseBonus).toBe(0.15));
+});
+
+describe('ZoneClaiming — zone CRUD', () => {
+  it('createZone stores zone', () => {
+    const zc = mkZC();
+    zc.createZone('z1', v(0), 10);
+    expect(zc.getZone('z1')).toBeDefined();
+  });
+  it('createZone initial state = unclaimed', () => {
+    const zc = mkZC();
+    zc.createZone('z2', v(0), 10);
+    expect(zc.getZone('z2')!.state).toBe('unclaimed');
+  });
+  it('createZone sets value', () => {
+    const zc = mkZC();
+    zc.createZone('z3', v(0), 10, { value: 5 });
+    expect(zc.getZone('z3')!.value).toBe(5);
+  });
+  it('createZone default value = 1', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    expect(zc.getZone('z1')!.value).toBe(1);
+  });
+  it('removeZone returns true', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    expect(zc.removeZone('z1')).toBe(true);
+  });
+  it('removeZone deletes zone', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    zc.removeZone('z1');
+    expect(zc.getZone('z1')).toBeUndefined();
+  });
+  it('removeZone missing id returns false', () => {
+    expect(mkZC().removeZone('nope')).toBe(false);
+  });
+  it('getAllZones returns all', () => {
+    const zc = mkZC();
+    zc.createZone('a', v(0), 5);
+    zc.createZone('b', v(10), 5);
+    expect(zc.getAllZones()).toHaveLength(2);
+  });
+});
+
+describe('ZoneClaiming — spatial queries', () => {
+  it('findZonesAt finds overlapping zone', () => {
+    const zc = mkZC();
+    makeZone(zc, 'z1', v(0), 10);
+    expect(zc.findZonesAt(v(5))).toHaveLength(1);
+  });
+  it('findZonesAt excludes non-overlapping zones', () => {
+    const zc = mkZC();
+    makeZone(zc, 'z1', v(0), 5);
+    expect(zc.findZonesAt(v(100))).toHaveLength(0);
+  });
+  it('isAgentInZone true when inside', () => {
+    const zc = mkZC();
+    makeZone(zc, 'z1', v(0), 10);
+    expect(zc.isAgentInZone('a1', 'z1', v(5))).toBe(true);
+  });
+  it('isAgentInZone false when outside', () => {
+    const zc = mkZC();
+    makeZone(zc, 'z1', v(0), 5);
+    expect(zc.isAgentInZone('a1', 'z1', v(100))).toBe(false);
+  });
+});
+
+describe('ZoneClaiming — claimZone', () => {
+  it('creates a claim', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    zc.claimZone('agent1', 'z1', { strength: 0.5 });
+    expect(zc.getClaimStrength('agent1', 'z1')).toBeCloseTo(0.5, 5);
+  });
+  it('reinforces existing claim', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.3 });
+    zc.claimZone('a', 'z1', { strength: 0.3 });
+    expect(zc.getClaimStrength('a', 'z1')).toBeCloseTo(0.6, 5);
+  });
+  it('returns null for missing zone', () => {
+    expect(mkZC().claimZone('a', 'nonexistent')).toBeNull();
+  });
+  it('zone state = claimed after sufficient strength', () => {
+    const zc = mkZC({ claimThreshold: 0.3, captureThreshold: 0.7 });
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.8 });
+    expect(zc.getZone('z1')!.state).toBe('claimed');
+  });
+  it('zone owner set after claim', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    makeZone(zc);
+    zc.claimZone('agent1', 'z1', { strength: 0.9 });
+    expect(zc.getZone('z1')!.owner).toBe('agent1');
+  });
+  it('zone = contested when two agents have similar strength', () => {
+    const zc = mkZC({ claimThreshold: 0.1, captureThreshold: 0.9 });
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.5 });
+    zc.claimZone('b', 'z1', { strength: 0.4 });
+    // secondStrength (0.4) >= highestStrength (0.5) * 0.5 → contested
+    expect(zc.getZone('z1')!.state).toBe('contested');
+  });
+  it('getAgentClaims returns zones agent has claims in', () => {
+    const zc = mkZC();
+    zc.createZone('z1', v(0), 5);
+    zc.createZone('z2', v(10), 5);
+    zc.claimZone('ag', 'z1', { strength: 0.5 });
+    zc.claimZone('ag', 'z2', { strength: 0.5 });
+    expect(zc.getAgentClaims('ag')).toHaveLength(2);
+  });
+});
+
+describe('ZoneClaiming — releaseClaim', () => {
+  it('release removes claim', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.5 });
+    zc.releaseClaim('a', 'z1');
+    expect(zc.getClaimStrength('a', 'z1')).toBe(0);
+  });
+  it('release on missing zone returns false', () => {
+    expect(mkZC().releaseClaim('a', 'nope')).toBe(false);
+  });
+  it('release on missing claim returns false', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    expect(zc.releaseClaim('nobody', 'z1')).toBe(false);
+  });
+  it('release by owner emits abandoned event', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    makeZone(zc);
+    zc.claimZone('owner', 'z1', { strength: 0.9 });
+    const events: any[] = [];
+    zc.onEvent((e) => events.push(e));
+    zc.releaseClaim('owner', 'z1');
+    expect(events.some((e) => e.type === 'abandoned')).toBe(true);
+  });
+});
+
+describe('ZoneClaiming — events', () => {
+  it('onEvent fires claimed event when zone first captured', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    makeZone(zc);
+    const events: any[] = [];
+    zc.onEvent((e) => events.push(e));
+    zc.claimZone('agent', 'z1', { strength: 0.9 });
+    expect(events.some((e) => e.type === 'claimed')).toBe(true);
+  });
+  it('onEvent unsubscribe stops receiving events', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    makeZone(zc);
+    const events: any[] = [];
+    const unsub = zc.onEvent((e) => events.push(e));
+    unsub();
+    zc.claimZone('agent', 'z1', { strength: 0.9 });
+    expect(events).toHaveLength(0);
+  });
+});
+
+describe('ZoneClaiming — applyDecay', () => {
+  it('decays claim strength over time', () => {
+    const zc = mkZC({ strengthDecayRate: 0.1 });
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.5 });
+    zc.applyDecay(1); // 1 second → -0.1
+    expect(zc.getClaimStrength('a', 'z1')).toBeCloseTo(0.4, 5);
+  });
+  it('removes claim when strength reaches 0', () => {
+    const zc = mkZC({ strengthDecayRate: 1 });
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.5 });
+    zc.applyDecay(1); // strength → -0.5 → removed
+    expect(zc.getClaimStrength('a', 'z1')).toBe(0);
+  });
+});
+
+describe('ZoneClaiming — statistics', () => {
+  it('getStatistics returns total count', () => {
+    const zc = mkZC();
+    zc.createZone('z1', v(0), 5);
+    zc.createZone('z2', v(10), 5);
+    expect(zc.getStatistics().total).toBe(2);
+  });
+  it('getStatistics counts unclaimed', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    expect(zc.getStatistics().unclaimed).toBe(1);
+  });
+  it('getTotalValue sums owned zone values', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    zc.createZone('z1', v(0), 5, { value: 3 });
+    zc.createZone('z2', v(10), 5, { value: 7 });
+    zc.claimZone('owner', 'z1', { strength: 0.9 });
+    zc.claimZone('owner', 'z2', { strength: 0.9 });
+    expect(zc.getTotalValue('owner')).toBe(10);
+  });
+  it('getContestedZones only returns contested', () => {
+    const zc = mkZC({ claimThreshold: 0.1, captureThreshold: 0.9 });
+    makeZone(zc);
+    zc.claimZone('a', 'z1', { strength: 0.5 });
+    zc.claimZone('b', 'z1', { strength: 0.4 });
+    expect(zc.getContestedZones()).toHaveLength(1);
+  });
+  it('getUnclaimedZones returns unclaimed', () => {
+    const zc = mkZC();
+    makeZone(zc);
+    expect(zc.getUnclaimedZones()).toHaveLength(1);
+  });
+  it('getZonesByState filters by state', () => {
+    const zc = mkZC({ captureThreshold: 0.5 });
+    zc.createZone('z1', v(0), 5);
+    zc.createZone('z2', v(10), 5);
+    zc.claimZone('a', 'z1', { strength: 0.9 });
+    expect(zc.getZonesByState('claimed')).toHaveLength(1);
+    expect(zc.getZonesByState('unclaimed')).toHaveLength(1);
+  });
+});

package/src/swarm/spatial/__tests__/ZoneClaiming.test.ts

@@ -0,0 +1,374 @@
+/**
+ * ZoneClaiming Tests
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ZoneClaiming, IZoneEvent } from '../ZoneClaiming';
+import { Vector3 } from '../Vector3';
+
+describe('ZoneClaiming', () => {
+  let zoning: ZoneClaiming;
+
+  beforeEach(() => {
+    zoning = new ZoneClaiming({
+      claimThreshold: 0.3,
+      captureThreshold: 0.7,
+      strengthDecayRate: 0.05,
+      reinforceRate: 0.1,
+      swarmBonus: 0.2,
+      defenseBonus: 0.15,
+    });
+  });
+
+  describe('zone management', () => {
+    it('should create a zone', () => {
+      const zone = zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      expect(zone.id).toBe('zone-1');
+      expect(zone.radius).toBe(50);
+      expect(zone.state).toBe('unclaimed');
+    });
+
+    it('should create zone with value and metadata', () => {
+      const zone = zoning.createZone('zone-1', new Vector3(0, 0, 0), 50, {
+        value: 10,
+        metadata: { type: 'resource' },
+      });
+      expect(zone.value).toBe(10);
+      expect(zone.metadata.type).toBe('resource');
+    });
+
+    it('should remove a zone', () => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      expect(zoning.removeZone('zone-1')).toBe(true);
+      expect(zoning.getZone('zone-1')).toBeUndefined();
+    });
+
+    it('should get all zones', () => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      zoning.createZone('zone-2', new Vector3(100, 0, 0), 50);
+      expect(zoning.getAllZones()).toHaveLength(2);
+    });
+  });
+
+  describe('zone queries', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      zoning.createZone('zone-2', new Vector3(100, 0, 0), 50);
+    });
+
+    it('should find zones at position', () => {
+      const zones = zoning.findZonesAt(new Vector3(25, 0, 0));
+      expect(zones).toHaveLength(1);
+      expect(zones[0].id).toBe('zone-1');
+    });
+
+    it('should find overlapping zones', () => {
+      zoning.createZone('zone-3', new Vector3(30, 0, 0), 50);
+      const zones = zoning.findZonesAt(new Vector3(25, 0, 0));
+      expect(zones).toHaveLength(2);
+    });
+
+    it('should check if agent is in zone', () => {
+      expect(zoning.isAgentInZone('agent-1', 'zone-1', new Vector3(25, 0, 0))).toBe(true);
+      expect(zoning.isAgentInZone('agent-1', 'zone-1', new Vector3(100, 0, 0))).toBe(false);
+    });
+  });
+
+  describe('claiming', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+    });
+
+    it('should create a claim', () => {
+      const claim = zoning.claimZone('agent-1', 'zone-1');
+      expect(claim).not.toBeNull();
+      expect(claim!.agentId).toBe('agent-1');
+      expect(claim!.strength).toBe(0.1);
+    });
+
+    it('should reinforce existing claim', () => {
+      zoning.claimZone('agent-1', 'zone-1');
+      zoning.claimZone('agent-1', 'zone-1');
+
+      const strength = zoning.getClaimStrength('agent-1', 'zone-1');
+      expect(strength).toBe(0.2);
+    });
+
+    it('should cap claim strength at 1', () => {
+      for (let i = 0; i < 20; i++) {
+        zoning.claimZone('agent-1', 'zone-1');
+      }
+
+      const strength = zoning.getClaimStrength('agent-1', 'zone-1');
+      expect(strength).toBe(1);
+    });
+
+    it('should track swarm ID in claim', () => {
+      const claim = zoning.claimZone('agent-1', 'zone-1', { swarmId: 'swarm-1' });
+      expect(claim!.swarmId).toBe('swarm-1');
+    });
+
+    it('should return null for non-existent zone', () => {
+      const claim = zoning.claimZone('agent-1', 'invalid');
+      expect(claim).toBeNull();
+    });
+  });
+
+  describe('zone state transitions', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+    });
+
+    it('should transition to claimed when threshold reached', () => {
+      // Claim enough to pass threshold (0.3)
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.35 });
+
+      const zone = zoning.getZone('zone-1')!;
+      expect(zone.state).toBe('claimed');
+      expect(zone.owner).toBe('agent-1');
+    });
+
+    it('should become contested when multiple claimants', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.4 });
+      zoning.claimZone('agent-2', 'zone-1', { strength: 0.3 });
+
+      const zone = zoning.getZone('zone-1')!;
+      expect(zone.state).toBe('contested');
+    });
+
+    it('should become defended when owner has clear lead', () => {
+      // First claim establishes ownership as 'claimed'
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.8 });
+
+      const zone = zoning.getZone('zone-1')!;
+      // Initial claim is 'claimed', becomes 'defended' after reinforcement when already owner
+      expect(['claimed', 'defended']).toContain(zone.state);
+      expect(zone.owner).toBe('agent-1');
+    });
+  });
+
+  describe('releasing claims', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 });
+    });
+
+    it('should release a claim', () => {
+      expect(zoning.releaseClaim('agent-1', 'zone-1')).toBe(true);
+      expect(zoning.getClaimStrength('agent-1', 'zone-1')).toBe(0);
+    });
+
+    it('should emit abandoned event when owner releases', () => {
+      const events: IZoneEvent[] = [];
+      zoning.onEvent((e) => events.push(e));
+
+      zoning.releaseClaim('agent-1', 'zone-1');
+
+      const abandoned = events.find((e) => e.type === 'abandoned');
+      expect(abandoned).toBeDefined();
+    });
+
+    it('should return false for non-existent claim', () => {
+      expect(zoning.releaseClaim('agent-2', 'zone-1')).toBe(false);
+    });
+  });
+
+  describe('swarm bonuses', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+    });
+
+    it('should track swarm strength', () => {
+      zoning.claimZone('agent-1', 'zone-1', { swarmId: 'swarm-1', strength: 0.3 });
+      zoning.claimZone('agent-2', 'zone-1', { swarmId: 'swarm-1', strength: 0.3 });
+
+      const swarmStrength = zoning.getSwarmStrength('swarm-1', 'zone-1');
+      expect(swarmStrength).toBe(0.6);
+    });
+
+    it('should apply swarm bonus for multiple members', () => {
+      // Two swarm members vs one solo agent
+      zoning.claimZone('agent-1', 'zone-1', { swarmId: 'swarm-1', strength: 0.3 });
+      zoning.claimZone('agent-2', 'zone-1', { swarmId: 'swarm-1', strength: 0.3 });
+      zoning.claimZone('agent-3', 'zone-1', { strength: 0.5 }); // Solo agent
+
+      const zone = zoning.getZone('zone-1')!;
+      // Swarm should own due to bonus (0.6 + 0.2 = 0.8 vs 0.5)
+      expect(zone.ownerSwarm).toBe('swarm-1');
+    });
+  });
+
+  describe('decay', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+    });
+
+    it('should apply decay to claims', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 });
+      zoning.applyDecay(2); // 2 seconds worth of decay
+
+      const strength = zoning.getClaimStrength('agent-1', 'zone-1');
+      expect(strength).toBeCloseTo(0.4); // 0.5 - (0.05 * 2)
+    });
+
+    it('should remove claims that decay to zero', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.05 });
+      zoning.applyDecay(2);
+
+      expect(zoning.getClaimStrength('agent-1', 'zone-1')).toBe(0);
+    });
+
+    it('should update zone state after decay', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.4 });
+      zoning.applyDecay(10); // Complete decay
+
+      const zone = zoning.getZone('zone-1')!;
+      expect(zone.state).toBe('unclaimed');
+    });
+  });
+
+  describe('zone queries by state', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+      zoning.createZone('zone-2', new Vector3(100, 0, 0), 50);
+      zoning.createZone('zone-3', new Vector3(200, 0, 0), 50);
+
+      zoning.claimZone('agent-1', 'zone-2', { strength: 0.8 });
+      zoning.claimZone('agent-2', 'zone-3', { strength: 0.4 });
+      zoning.claimZone('agent-3', 'zone-3', { strength: 0.35 });
+    });
+
+    it('should get unclaimed zones', () => {
+      const unclaimed = zoning.getUnclaimedZones();
+      expect(unclaimed).toHaveLength(1);
+      expect(unclaimed[0].id).toBe('zone-1');
+    });
+
+    it('should get contested zones', () => {
+      const contested = zoning.getContestedZones();
+      expect(contested).toHaveLength(1);
+      expect(contested[0].id).toBe('zone-3');
+    });
+
+    it('should get zones by state', () => {
+      // zone-2 has single strong claim - either 'claimed' or 'defended'
+      const claimedOrDefended =
+        zoning.getZonesByState('claimed').length + zoning.getZonesByState('defended').length;
+      expect(claimedOrDefended).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('ownership queries', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50, { value: 10 });
+      zoning.createZone('zone-2', new Vector3(100, 0, 0), 50, { value: 20 });
+
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.8 });
+      zoning.claimZone('agent-1', 'zone-2', { strength: 0.8 });
+    });
+
+    it('should get owned zones', () => {
+      const owned = zoning.getOwnedZones('agent-1');
+      expect(owned).toHaveLength(2);
+    });
+
+    it('should get agent claims', () => {
+      const claims = zoning.getAgentClaims('agent-1');
+      expect(claims).toHaveLength(2);
+    });
+
+    it('should calculate total value', () => {
+      const value = zoning.getTotalValue('agent-1');
+      expect(value).toBe(30);
+    });
+  });
+
+  describe('events', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50);
+    });
+
+    it('should emit claimed event', () => {
+      const events: IZoneEvent[] = [];
+      zoning.onEvent((e) => events.push(e));
+
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 });
+
+      const claimed = events.find((e) => e.type === 'claimed');
+      expect(claimed).toBeDefined();
+      expect(claimed!.agentId).toBe('agent-1');
+    });
+
+    it('should emit captured event when changing owner', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.8 });
+
+      const events: IZoneEvent[] = [];
+      zoning.onEvent((e) => events.push(e));
+
+      // Need to significantly overpower existing claim to capture
+      zoning.claimZone('agent-2', 'zone-1', { strength: 1.0 });
+
+      // Either captured or zone is now contested
+      const zone = zoning.getZone('zone-1')!;
+      const captured = events.find((e) => e.type === 'captured');
+      const isContested = zone.state === 'contested';
+
+      // Either there was a capture event OR the zone became contested
+      expect(captured || isContested).toBeTruthy();
+    });
+
+    it('should emit defended event when holding contested zone', () => {
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 });
+      zoning.claimZone('agent-2', 'zone-1', { strength: 0.4 }); // Makes it contested
+
+      const events: IZoneEvent[] = [];
+      zoning.onEvent((e) => events.push(e));
+
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 }); // Reinforce to defend
+
+      const defended = events.find((e) => e.type === 'defended');
+      expect(defended).toBeDefined();
+    });
+
+    it('should unsubscribe from events', () => {
+      const events: IZoneEvent[] = [];
+      const unsubscribe = zoning.onEvent((e) => events.push(e));
+
+      unsubscribe();
+      zoning.claimZone('agent-1', 'zone-1', { strength: 0.5 });
+
+      expect(events).toHaveLength(0);
+    });
+  });
+
+  describe('statistics', () => {
+    beforeEach(() => {
+      zoning.createZone('zone-1', new Vector3(0, 0, 0), 50, { value: 10 });
+      zoning.createZone('zone-2', new Vector3(100, 0, 0), 50, { value: 20 });
+      zoning.createZone('zone-3', new Vector3(200, 0, 0), 50, { value: 30 });
+
+      zoning.claimZone('agent-1', 'zone-2', { strength: 0.8 });
+    });
+
+    it('should get zone statistics', () => {
+      const stats = zoning.getStatistics();
+      expect(stats.total).toBe(3);
+      expect(stats.unclaimed).toBe(2);
+      expect(stats.totalValue).toBe(60);
+      expect(stats.claimedValue).toBe(20);
+    });
+  });
+
+  describe('configuration', () => {
+    it('should update config', () => {
+      zoning.setConfig({ claimThreshold: 0.5 });
+      expect(zoning.getConfig().claimThreshold).toBe(0.5);
+    });
+
+    it('should preserve existing config', () => {
+      zoning.setConfig({ claimThreshold: 0.5 });
+      expect(zoning.getConfig().captureThreshold).toBe(0.7);
+    });
+  });
+});

package/src/swarm/spatial/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Spatial Swarm Behaviors - Index
+ * HoloScript v3.2 - Autonomous Agent Swarms
+ */
+
+// Vector utilities
+export { Vector3 } from './Vector3';
+
+// Boid-based flocking
+export { FlockingBehavior, type IBoid, type IFlockingConfig } from './FlockingBehavior';
+
+// Geometric formations
+export {
+  FormationController,
+  type FormationType,
+  type IFormationSlot,
+  type IFormationConfig,
+} from './FormationController';
+
+// Territory control
+export {
+  ZoneClaiming,
+  type ZoneState,
+  type IZone,
+  type IZoneClaim,
+  type IZoneEvent,
+  type IZoneClaimingConfig,
+} from './ZoneClaiming';