@holoscript/plugin-government-civic 2.0.1 → 2.0.2

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@holoscript/plugin-government-civic",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "HoloScript domain plugin for government and civic services — permits, public meetings, service requests, voting records, and ADA/FOIA compliance.",
   "main": "src/index.ts",
   "peerDependencies": {
-    "@holoscript/core": "8.0.6"
+    "@holoscript/core": ">=8.0.0"
   },
   "license": "MIT",
   "scripts": {
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests"
   }
-}
+}

package/src/__tests__/civicsolver.test.ts

@@ -23,12 +23,12 @@ import {
 describe('permitScoring', () => {
   it('compositeScore = weighted sum of criterion scores', () => {
     const criteria = [
-      { name: 'safety',    weight: 0.40, score: 80 },
-      { name: 'zoning',    weight: 0.35, score: 90 },
-      { name: 'env',       weight: 0.25, score: 70 },
+      { name: 'safety', weight: 0.4, score: 80 },
+      { name: 'zoning', weight: 0.35, score: 90 },
+      { name: 'env', weight: 0.25, score: 70 },
     ];
     const r = permitScoring(criteria);
-    const expected = 0.40 * 80 + 0.35 * 90 + 0.25 * 70;
+    const expected = 0.4 * 80 + 0.35 * 90 + 0.25 * 70;
     expect(r.compositeScore).toBeCloseTo(expected, 4);
   });
 
@@ -46,12 +46,12 @@ describe('permitScoring', () => {
 
   it('breakdown includes contribution = score × weight', () => {
     const criteria = [
-      { name: 'env', weight: 0.60, score: 75 },
-      { name: 'traffic', weight: 0.40, score: 50 },
+      { name: 'env', weight: 0.6, score: 75 },
+      { name: 'traffic', weight: 0.4, score: 50 },
     ];
     const r = permitScoring(criteria);
-    expect(r.breakdown[0].contribution).toBeCloseTo(0.60 * 75, 4);
-    expect(r.breakdown[1].contribution).toBeCloseTo(0.40 * 50, 4);
+    expect(r.breakdown[0].contribution).toBeCloseTo(0.6 * 75, 4);
+    expect(r.breakdown[1].contribution).toBeCloseTo(0.4 * 50, 4);
   });
 
   it('throws when weights do not sum to 1.0', () => {
@@ -76,14 +76,14 @@ describe('mcdaAnalysis', () => {
     { id: 'project-C', scores: [50, 90, 70] },
   ];
   const criteria = [
-    { name: 'cost-effectiveness', weight: 0.50, isBenefit: true },
-    { name: 'community-impact',   weight: 0.30, isBenefit: true },
-    { name: 'implementation-ease',weight: 0.20, isBenefit: true },
+    { name: 'cost-effectiveness', weight: 0.5, isBenefit: true },
+    { name: 'community-impact', weight: 0.3, isBenefit: true },
+    { name: 'implementation-ease', weight: 0.2, isBenefit: true },
   ];
 
   it('winner is a valid candidate id', () => {
     const r = mcdaAnalysis(candidates, criteria);
-    const ids = candidates.map(c => c.id);
+    const ids = candidates.map((c) => c.id);
     expect(ids).toContain(r.winner);
   });
 
@@ -102,7 +102,7 @@ describe('mcdaAnalysis', () => {
 
   it('ranks are 1-indexed and sequential', () => {
     const r = mcdaAnalysis(candidates, criteria);
-    const ranks = r.ranking.map(x => x.rank).sort((a, b) => a - b);
+    const ranks = r.ranking.map((x) => x.rank).sort((a, b) => a - b);
     expect(ranks).toEqual([1, 2, 3]);
   });
 
@@ -190,19 +190,19 @@ describe('votingCohesion', () => {
     { memberId: 'A2', partyId: 'A', vote: 'yes' as const },
     { memberId: 'A3', partyId: 'A', vote: 'yes' as const },
     { memberId: 'B1', partyId: 'B', vote: 'yes' as const },
-    { memberId: 'B2', partyId: 'B', vote: 'no'  as const },
-    { memberId: 'B3', partyId: 'B', vote: 'no'  as const },
+    { memberId: 'B2', partyId: 'B', vote: 'no' as const },
+    { memberId: 'B3', partyId: 'B', vote: 'no' as const },
   ];
 
   it('unanimous party cohesion = 1.0', () => {
     const r = votingCohesion(votes);
-    const partyA = r.partyCohesion.find(p => p.partyId === 'A');
+    const partyA = r.partyCohesion.find((p) => p.partyId === 'A');
     expect(partyA!.cohesion).toBeCloseTo(1.0, 4);
   });
 
   it('split party cohesion < 1', () => {
     const r = votingCohesion(votes);
-    const partyB = r.partyCohesion.find(p => p.partyId === 'B');
+    const partyB = r.partyCohesion.find((p) => p.partyId === 'B');
     expect(partyB!.cohesion).toBeGreaterThanOrEqual(0);
     expect(partyB!.cohesion).toBeLessThan(1);
   });
@@ -219,7 +219,10 @@ describe('votingCohesion', () => {
   });
 
   it('majority=no when more no than yes', () => {
-    const noMajority = votes.map(v => ({ ...v, vote: (v.partyId === 'A' ? 'no' : v.vote) as 'yes' | 'no' | 'abstain' }));
+    const noMajority = votes.map((v) => ({
+      ...v,
+      vote: (v.partyId === 'A' ? 'no' : v.vote) as 'yes' | 'no' | 'abstain',
+    }));
     const r = votingCohesion(noMajority); // 1 yes, 5 no
     expect(r.majority).toBe('no');
   });
@@ -252,7 +255,7 @@ describe('polsbyPopper', () => {
     // Very elongated: narrow strip, A=1, P=100 → PP = 4π/10000 ≈ 0.00125
     const r = polsbyPopper(1, 100);
     expect(r.classification).toBe('gerrymandered');
-    expect(r.compactnessScore).toBeLessThan(0.20);
+    expect(r.compactnessScore).toBeLessThan(0.2);
   });
 
   it('moderate classification for 0.20 ≤ score < 0.50', () => {
@@ -264,9 +267,10 @@ describe('polsbyPopper', () => {
   });
 
   it('compactnessScore = 4π × area / perimeter²', () => {
-    const A = 5, P = 15;
+    const A = 5,
+      P = 15;
     const r = polsbyPopper(A, P);
-    expect(r.compactnessScore).toBeCloseTo((4 * Math.PI * A) / (P ** 2), 6);
+    expect(r.compactnessScore).toBeCloseTo((4 * Math.PI * A) / P ** 2, 6);
   });
 
   it('throws for non-positive area', () => {
@@ -278,9 +282,9 @@ describe('polsbyPopper', () => {
 
 describe('budgetVariance', () => {
   const lines = [
-    { category: 'Roads',       budgeted: 100_000, actual: 95_000  }, // under → favorable
-    { category: 'Parks',       budgeted:  50_000, actual: 60_000  }, // over → unfavorable
-    { category: 'Admin',       budgeted:  75_000, actual: 75_500  }, // near → on-target
+    { category: 'Roads', budgeted: 100_000, actual: 95_000 }, // under → favorable
+    { category: 'Parks', budgeted: 50_000, actual: 60_000 }, // over → unfavorable
+    { category: 'Admin', budgeted: 75_000, actual: 75_500 }, // near → on-target
   ];
 
   it('variance = actual - budgeted', () => {
@@ -306,7 +310,7 @@ describe('budgetVariance', () => {
   });
 
   it('flaggedLines contains categories with |variance%| > threshold', () => {
-    const r = budgetVariance(lines, 0.10); // 10% threshold
+    const r = budgetVariance(lines, 0.1); // 10% threshold
     // Parks: 20% over → flagged. Roads: 5% under → not flagged (below 10%)
     expect(r.flaggedLines).toContain('Parks');
     expect(r.flaggedLines).not.toContain('Roads');

package/src/__tests__/government-civic.test.ts

@@ -17,8 +17,12 @@ import type { HSPlusNode, TraitContext } from '../traits/types';
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
-function makeNode(): HSPlusNode { return { id: 'n1', traits: [], state: {}, position: [0, 0, 0] }; }
-function makeCtx(): TraitContext { return { emit: vi.fn(), scene: {} }; }
+function makeNode(): HSPlusNode {
+  return { id: 'n1', traits: [], state: {}, position: [0, 0, 0] };
+}
+function makeCtx(): TraitContext {
+  return { emit: vi.fn(), scene: {} };
+}
 
 // ── Plugin metadata ───────────────────────────────────────────────────────────
 
@@ -77,9 +81,15 @@ describe('PermitTrait', () => {
     const node = makeNode();
     const ctx = makeCtx();
     handler.onAttach(node, cfg, ctx);
-    handler.onEvent(node, cfg, ctx, { type: 'permit:update_status', payload: { status: 'approved' } });
+    handler.onEvent(node, cfg, ctx, {
+      type: 'permit:update_status',
+      payload: { status: 'approved' },
+    });
     expect((node.__permitState as { status: string }).status).toBe('approved');
-    expect(ctx.emit).toHaveBeenCalledWith('permit:status_changed', expect.objectContaining({ to: 'approved' }));
+    expect(ctx.emit).toHaveBeenCalledWith(
+      'permit:status_changed',
+      expect.objectContaining({ to: 'approved' })
+    );
   });
 
   it('cleans up on detach', () => {
@@ -106,7 +116,13 @@ describe('PublicMeetingTrait', () => {
     publicCommentMinutesPerSpeaker: 3,
     agenda: [
       { id: '1', title: 'Call to Order', type: 'action', durationMinutes: 5, requiresVote: false },
-      { id: '2', title: 'Public Comment', type: 'public_comment', durationMinutes: 30, requiresVote: false },
+      {
+        id: '2',
+        title: 'Public Comment',
+        type: 'public_comment',
+        durationMinutes: 30,
+        requiresVote: false,
+      },
     ],
     accessibilityFeatures: ['captioning'],
   };
@@ -221,7 +237,10 @@ describe('VotingRecordTrait', () => {
     const ctx = makeCtx();
     handler.onAttach(node, cfg, ctx);
     handler.onEvent(node, cfg, ctx, { type: 'vote:open' });
-    handler.onEvent(node, cfg, ctx, { type: 'vote:cast', payload: { memberId: 'CM-A', memberName: 'Councilmember A', vote: 'aye' } });
+    handler.onEvent(node, cfg, ctx, {
+      type: 'vote:cast',
+      payload: { memberId: 'CM-A', memberName: 'Councilmember A', vote: 'aye' },
+    });
     expect((node.__votingState as { ayeCount: number }).ayeCount).toBe(1);
   });
 
@@ -232,14 +251,23 @@ describe('VotingRecordTrait', () => {
     handler.onAttach(node, cfg, ctx);
     handler.onEvent(node, cfg, ctx, { type: 'vote:open' });
     for (const id of ['CM-A', 'CM-B', 'CM-C']) {
-      handler.onEvent(node, cfg, ctx, { type: 'vote:cast', payload: { memberId: id, memberName: id, vote: 'aye' } });
+      handler.onEvent(node, cfg, ctx, {
+        type: 'vote:cast',
+        payload: { memberId: id, memberName: id, vote: 'aye' },
+      });
     }
     for (const id of ['CM-D', 'Mayor']) {
-      handler.onEvent(node, cfg, ctx, { type: 'vote:cast', payload: { memberId: id, memberName: id, vote: 'nay' } });
+      handler.onEvent(node, cfg, ctx, {
+        type: 'vote:cast',
+        payload: { memberId: id, memberName: id, vote: 'nay' },
+      });
     }
     handler.onEvent(node, cfg, ctx, { type: 'vote:close' });
     expect((node.__votingState as { outcome: string }).outcome).toBe('passed');
-    expect(ctx.emit).toHaveBeenCalledWith('vote:closed', expect.objectContaining({ outcome: 'passed' }));
+    expect(ctx.emit).toHaveBeenCalledWith(
+      'vote:closed',
+      expect.objectContaining({ outcome: 'passed' })
+    );
   });
 });
 
@@ -273,9 +301,15 @@ describe('CivicComplianceTrait', () => {
     handler.onAttach(node, cfg, ctx);
     const s = node.__complianceState as { checks: Array<{ id: string; status: string }> };
     const checkId = s.checks[0]!.id;
-    handler.onEvent(node, cfg, ctx, { type: 'compliance:update_check', payload: { checkId, status: 'compliant' } });
+    handler.onEvent(node, cfg, ctx, {
+      type: 'compliance:update_check',
+      payload: { checkId, status: 'compliant' },
+    });
     expect(s.checks[0]!.status).toBe('compliant');
-    expect(ctx.emit).toHaveBeenCalledWith('compliance:check_updated', expect.objectContaining({ status: 'compliant' }));
+    expect(ctx.emit).toHaveBeenCalledWith(
+      'compliance:check_updated',
+      expect.objectContaining({ status: 'compliant' })
+    );
   });
 
   it('compliance:foia_received creates a pending FOIA request', () => {
@@ -283,11 +317,17 @@ describe('CivicComplianceTrait', () => {
     const node = makeNode();
     const ctx = makeCtx();
     handler.onAttach(node, cfg, ctx);
-    handler.onEvent(node, cfg, ctx, { type: 'compliance:foia_received', payload: { requestId: 'FOIA-001', description: 'Budget docs' } });
+    handler.onEvent(node, cfg, ctx, {
+      type: 'compliance:foia_received',
+      payload: { requestId: 'FOIA-001', description: 'Budget docs' },
+    });
     const s = node.__complianceState as { foiaRequests: unknown[]; openFoiaCount: number };
     expect(s.foiaRequests).toHaveLength(1);
     expect(s.openFoiaCount).toBe(1);
-    expect(ctx.emit).toHaveBeenCalledWith('compliance:foia_received', expect.objectContaining({ requestId: 'FOIA-001' }));
+    expect(ctx.emit).toHaveBeenCalledWith(
+      'compliance:foia_received',
+      expect.objectContaining({ requestId: 'FOIA-001' })
+    );
   });
 
   it('audit log entry is stored', () => {
@@ -295,7 +335,10 @@ describe('CivicComplianceTrait', () => {
     const node = makeNode();
     const ctx = makeCtx();
     handler.onAttach(node, cfg, ctx);
-    handler.onEvent(node, cfg, ctx, { type: 'compliance:audit_log', payload: { action: 'page_view', actor: 'user-99', details: 'Viewed homepage' } });
+    handler.onEvent(node, cfg, ctx, {
+      type: 'compliance:audit_log',
+      payload: { action: 'page_view', actor: 'user-99', details: 'Viewed homepage' },
+    });
     const s = node.__complianceState as { auditLog: unknown[] };
     expect(s.auditLog).toHaveLength(1);
   });

package/src/__tests__/runtime-integration.test.ts

@@ -53,7 +53,7 @@ describe('government-civic -> HoloScript runtime integration (civic_decision)',
     });
 
     await runtime.executeNode(
-      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never,
+      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never
     );
     await flush();
 
@@ -79,7 +79,7 @@ describe('government-civic -> HoloScript runtime integration (civic_decision)',
     runtime.on('civic_decision_solved', (e: unknown) => solved.push(e));
 
     await runtime.executeNode(
-      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never,
+      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never
     );
     await flush();
 
@@ -91,7 +91,7 @@ describe('government-civic -> HoloScript runtime integration (civic_decision)',
     registerGovernmentCivicTraitHandlers(runtime);
 
     await runtime.executeNode(
-      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never,
+      civicDecisionOrb({ candidates: TWO_CANDIDATES, criteria: TWO_CANDIDATE_CRITERIA }) as never
     );
     await flush();
 
@@ -118,7 +118,7 @@ describe('government-civic -> HoloScript runtime integration (civic_decision)',
     // handler's try/catch turns into a civic_decision_error rather than a throw.
     const mismatched: MCDACandidate[] = [{ id: 'A', scores: [1, 2] }];
     await runtime.executeNode(
-      civicDecisionOrb({ candidates: mismatched, criteria: TWO_CANDIDATE_CRITERIA }) as never,
+      civicDecisionOrb({ candidates: mismatched, criteria: TWO_CANDIDATE_CRITERIA }) as never
     );
     await flush();
 

package/src/civicsolver.ts

@@ -23,8 +23,8 @@ import { buildDomainSimulationReceipt, type DomainSimulationReceipt } from '@hol
 
 export interface PermitCriteria {
   name: string;
-  weight: number;  // sum of all weights should be 1.0
-  score: number;   // 0–100
+  weight: number; // sum of all weights should be 1.0
+  score: number; // 0–100
 }
 
 export interface PermitScoringResult {
@@ -46,7 +46,7 @@ export interface MCDACandidate {
 
 export interface MCDACriterion {
   name: string;
-  weight: number;  // 0–1
+  weight: number; // 0–1
   /** true = higher is better (benefit), false = lower is better (cost) */
   isBenefit: boolean;
 }
@@ -87,7 +87,13 @@ export interface CohesionResult {
   /** Overall chamber Rice index (0=perfect split, 1=unanimous) */
   chamberCohesion: number;
   /** Per-party Rice cohesion */
-  partyCohesion: Array<{ partyId: string; cohesion: number; yesCount: number; noCount: number; size: number }>;
+  partyCohesion: Array<{
+    partyId: string;
+    cohesion: number;
+    yesCount: number;
+    noCount: number;
+    size: number;
+  }>;
   /** Winning coalition */
   majority: 'yes' | 'no' | 'tie';
 }
@@ -122,7 +128,7 @@ export interface BudgetVarianceResult {
   totalActual: number;
   totalVariancePct: number;
   overallStatus: 'favorable' | 'unfavorable' | 'on-target';
-  flaggedLines: string[];  // categories with variance > 10%
+  flaggedLines: string[]; // categories with variance > 10%
 }
 
 export interface GovtReceiptOptions {
@@ -131,15 +137,13 @@ export interface GovtReceiptOptions {
 
 // ─── Permit Scoring ───────────────────────────────────────────────────────────
 
-export function permitScoring(
-  criteria: PermitCriteria[],
-  threshold = 70,
-): PermitScoringResult {
+export function permitScoring(criteria: PermitCriteria[], threshold = 70): PermitScoringResult {
   if (criteria.length === 0) throw new Error('No permit criteria provided');
   const totalWeight = criteria.reduce((s, c) => s + c.weight, 0);
-  if (Math.abs(totalWeight - 1.0) > 0.01) throw new Error(`Weights must sum to 1.0 (got ${totalWeight.toFixed(3)})`);
+  if (Math.abs(totalWeight - 1.0) > 0.01)
+    throw new Error(`Weights must sum to 1.0 (got ${totalWeight.toFixed(3)})`);
 
-  const breakdown = criteria.map(c => ({
+  const breakdown = criteria.map((c) => ({
     name: c.name,
     score: c.score,
     weight: c.weight,
@@ -155,30 +159,33 @@ export function permitScoring(
 
 /** Normalize a column to [0,1] range */
 function normalizeColumn(values: number[]): number[] {
-  const min = Math.min(...values), max = Math.max(...values);
+  const min = Math.min(...values),
+    max = Math.max(...values);
   if (max === min) return values.map(() => 0.5);
-  return values.map(v => (v - min) / (max - min));
+  return values.map((v) => (v - min) / (max - min));
 }
 
-export function mcdaAnalysis(
-  candidates: MCDACandidate[],
-  criteria: MCDACriterion[],
-): MCDAResult {
+export function mcdaAnalysis(candidates: MCDACandidate[], criteria: MCDACriterion[]): MCDAResult {
   if (candidates.length === 0) throw new Error('No MCDA candidates');
   if (criteria.length === 0) throw new Error('No MCDA criteria');
-  if (candidates.some(c => c.scores.length !== criteria.length)) throw new Error('scores.length must match criteria.length');
+  if (candidates.some((c) => c.scores.length !== criteria.length))
+    throw new Error('scores.length must match criteria.length');
 
-  const n = candidates.length, m = criteria.length;
+  const n = candidates.length,
+    m = criteria.length;
 
   // Weighted sum score
-  const weightedScores = candidates.map(c =>
-    c.scores.reduce((acc, s, j) => acc + s * criteria[j].weight * (criteria[j].isBenefit ? 1 : -1), 0),
+  const weightedScores = candidates.map((c) =>
+    c.scores.reduce(
+      (acc, s, j) => acc + s * criteria[j].weight * (criteria[j].isBenefit ? 1 : -1),
+      0
+    )
   );
 
   // TOPSIS: normalize → weight → ideal/anti-ideal → distance
   const normalizedMatrix: number[][] = Array.from({ length: n }, () => Array(m).fill(0));
   for (let j = 0; j < m; j++) {
-    const col = candidates.map(c => c.scores[j]);
+    const col = candidates.map((c) => c.scores[j]);
     const norm = normalizeColumn(col);
     for (let i = 0; i < n; i++) {
       normalizedMatrix[i][j] = norm[i] * criteria[j].weight;
@@ -186,10 +193,18 @@ export function mcdaAnalysis(
   }
 
   // Ideal best/worst per criterion
-  const ideal     = criteria.map((cr, j) => cr.isBenefit ? Math.max(...normalizedMatrix.map(r => r[j])) : Math.min(...normalizedMatrix.map(r => r[j])));
-  const antiIdeal = criteria.map((cr, j) => cr.isBenefit ? Math.min(...normalizedMatrix.map(r => r[j])) : Math.max(...normalizedMatrix.map(r => r[j])));
+  const ideal = criteria.map((cr, j) =>
+    cr.isBenefit
+      ? Math.max(...normalizedMatrix.map((r) => r[j]))
+      : Math.min(...normalizedMatrix.map((r) => r[j]))
+  );
+  const antiIdeal = criteria.map((cr, j) =>
+    cr.isBenefit
+      ? Math.min(...normalizedMatrix.map((r) => r[j]))
+      : Math.max(...normalizedMatrix.map((r) => r[j]))
+  );
 
-  const topsisScores = normalizedMatrix.map(row => {
+  const topsisScores = normalizedMatrix.map((row) => {
     const dPos = Math.sqrt(row.reduce((acc, v, j) => acc + (v - ideal[j]) ** 2, 0));
     const dNeg = Math.sqrt(row.reduce((acc, v, j) => acc + (v - antiIdeal[j]) ** 2, 0));
     return dNeg / (dPos + dNeg + 1e-15);
@@ -211,27 +226,40 @@ export function quorumCalculator(
   yesVotes: number,
   noVotes: number,
   abstentions: number,
-  quorumType: QuorumType = 'simple',
+  quorumType: QuorumType = 'simple'
 ): QuorumResult {
   if (totalMembers < 1) throw new Error('totalMembers must be ≥ 1');
   if (presentMembers > totalMembers) throw new Error('presentMembers cannot exceed totalMembers');
-  if (yesVotes + noVotes + abstentions > presentMembers) throw new Error('Votes exceed present members');
+  if (yesVotes + noVotes + abstentions > presentMembers)
+    throw new Error('Votes exceed present members');
 
   const quorumRequired = Math.floor(totalMembers / 2) + 1; // strict majority
   const quorumMet = presentMembers >= quorumRequired;
 
   const passThreshold =
-    quorumType === 'supermajority' ? (2 / 3) :
-    quorumType === 'absolute'      ? (totalMembers / 2 + 1) / totalMembers :
-    0.5; // simple majority of votes cast
+    quorumType === 'supermajority'
+      ? 2 / 3
+      : quorumType === 'absolute'
+        ? (totalMembers / 2 + 1) / totalMembers
+        : 0.5; // simple majority of votes cast
 
   const votingBase = quorumType === 'absolute' ? totalMembers : yesVotes + noVotes;
-  const motionPassed = quorumMet && votingBase > 0 && (yesVotes / votingBase) > passThreshold;
+  const motionPassed = quorumMet && votingBase > 0 && yesVotes / votingBase > passThreshold;
   const marginVotes = motionPassed
     ? yesVotes - Math.ceil((yesVotes + noVotes) * passThreshold)
     : Math.ceil((yesVotes + noVotes) * passThreshold) - yesVotes;
 
-  return { totalMembers, presentMembers, yesVotes, noVotes, abstentions, quorumMet, passThreshold, motionPassed, marginVotes };
+  return {
+    totalMembers,
+    presentMembers,
+    yesVotes,
+    noVotes,
+    abstentions,
+    quorumMet,
+    passThreshold,
+    motionPassed,
+    marginVotes,
+  };
 }
 
 // ─── Voting Cohesion (Rice Index) ────────────────────────────────────────────
@@ -252,17 +280,22 @@ export function votingCohesion(votes: VotingRecord[]): CohesionResult {
   const partyCohesion = [...partyMap.entries()].map(([partyId, counts]) => {
     const total = counts.yes + counts.no;
     const cohesion = total > 0 ? Math.abs((counts.yes - counts.no) / total) : 0;
-    return { partyId, cohesion, yesCount: counts.yes, noCount: counts.no, size: counts.yes + counts.no + counts.abstain };
+    return {
+      partyId,
+      cohesion,
+      yesCount: counts.yes,
+      noCount: counts.no,
+      size: counts.yes + counts.no + counts.abstain,
+    };
   });
 
-  const totalYes = votes.filter(v => v.vote === 'yes').length;
-  const totalNo  = votes.filter(v => v.vote === 'no').length;
+  const totalYes = votes.filter((v) => v.vote === 'yes').length;
+  const totalNo = votes.filter((v) => v.vote === 'no').length;
   const totalVoting = totalYes + totalNo;
   const chamberCohesion = totalVoting > 0 ? Math.abs((totalYes - totalNo) / totalVoting) : 0;
 
   const majority: CohesionResult['majority'] =
-    totalYes > totalNo ? 'yes' :
-    totalNo > totalYes ? 'no' : 'tie';
+    totalYes > totalNo ? 'yes' : totalNo > totalYes ? 'no' : 'tie';
 
   return { chamberCohesion, partyCohesion, majority };
 }
@@ -277,42 +310,56 @@ export function polsbyPopper(areaSqKm: number, perimeterKm: number): PolsbyPoppe
   if (areaSqKm <= 0) throw new Error('Area must be positive');
   if (perimeterKm <= 0) throw new Error('Perimeter must be positive');
 
-  const compactnessScore = (4 * Math.PI * areaSqKm) / (perimeterKm ** 2);
+  const compactnessScore = (4 * Math.PI * areaSqKm) / perimeterKm ** 2;
 
   const classification: PolsbyPopperResult['classification'] =
-    compactnessScore >= 0.50 ? 'compact' :
-    compactnessScore >= 0.20 ? 'moderate' : 'gerrymandered';
+    compactnessScore >= 0.5 ? 'compact' : compactnessScore >= 0.2 ? 'moderate' : 'gerrymandered';
 
   return { areaSqKm, perimeterKm, compactnessScore, classification };
 }
 
 // ─── Budget Variance ──────────────────────────────────────────────────────────
 
-export function budgetVariance(
-  lines: BudgetLine[],
-  flagThreshold = 0.10,
-): BudgetVarianceResult {
+export function budgetVariance(lines: BudgetLine[], flagThreshold = 0.1): BudgetVarianceResult {
   if (lines.length === 0) throw new Error('No budget lines');
 
-  const analyzed = lines.map(l => {
+  const analyzed = lines.map((l) => {
     const variance = l.actual - l.budgeted;
     const variancePct = l.budgeted !== 0 ? variance / l.budgeted : 0;
     const status: 'favorable' | 'unfavorable' | 'on-target' =
-      Math.abs(variancePct) < 0.02 ? 'on-target' :
-      variance < 0 ? 'favorable' : 'unfavorable';  // under-budget = favorable
-    return { category: l.category, budgeted: l.budgeted, actual: l.actual, variance, variancePct, status };
+      Math.abs(variancePct) < 0.02 ? 'on-target' : variance < 0 ? 'favorable' : 'unfavorable'; // under-budget = favorable
+    return {
+      category: l.category,
+      budgeted: l.budgeted,
+      actual: l.actual,
+      variance,
+      variancePct,
+      status,
+    };
   });
 
   const totalBudgeted = analyzed.reduce((s, l) => s + l.budgeted, 0);
-  const totalActual   = analyzed.reduce((s, l) => s + l.actual,   0);
+  const totalActual = analyzed.reduce((s, l) => s + l.actual, 0);
   const totalVariancePct = totalBudgeted !== 0 ? (totalActual - totalBudgeted) / totalBudgeted : 0;
   const overallStatus: BudgetVarianceResult['overallStatus'] =
-    Math.abs(totalVariancePct) < 0.02 ? 'on-target' :
-    totalVariancePct < 0 ? 'favorable' : 'unfavorable';
-
-  const flaggedLines = analyzed.filter(l => Math.abs(l.variancePct) > flagThreshold).map(l => l.category);
-
-  return { lines: analyzed, totalBudgeted, totalActual, totalVariancePct, overallStatus, flaggedLines };
+    Math.abs(totalVariancePct) < 0.02
+      ? 'on-target'
+      : totalVariancePct < 0
+        ? 'favorable'
+        : 'unfavorable';
+
+  const flaggedLines = analyzed
+    .filter((l) => Math.abs(l.variancePct) > flagThreshold)
+    .map((l) => l.category);
+
+  return {
+    lines: analyzed,
+    totalBudgeted,
+    totalActual,
+    totalVariancePct,
+    overallStatus,
+    flaggedLines,
+  };
 }
 
 // ─── Receipt ──────────────────────────────────────────────────────────────────
@@ -329,21 +376,37 @@ export interface GovtAnalysisResult {
 
 export function buildGovtReceipt(
   result: GovtAnalysisResult,
-  options?: GovtReceiptOptions,
+  options?: GovtReceiptOptions
 ): DomainSimulationReceipt {
   const violations: Array<{ criterion: string; message: string }> = [];
 
   if (result.permit && !result.permit.approved) {
-    violations.push({ criterion: 'permit_denied', message: `Permit score ${result.permit.compositeScore.toFixed(1)} < ${result.permit.threshold} threshold — application denied` });
+    violations.push({
+      criterion: 'permit_denied',
+      message: `Permit score ${result.permit.compositeScore.toFixed(1)} < ${result.permit.threshold} threshold — application denied`,
+    });
   }
   if (result.quorum && !result.quorum.quorumMet) {
-    violations.push({ criterion: 'no_quorum', message: `Only ${result.quorum.presentMembers}/${result.quorum.totalMembers} members present — quorum not met` });
+    violations.push({
+      criterion: 'no_quorum',
+      message: `Only ${result.quorum.presentMembers}/${result.quorum.totalMembers} members present — quorum not met`,
+    });
   }
   if (result.compactness && result.compactness.classification === 'gerrymandered') {
-    violations.push({ criterion: 'gerrymandering', message: `District compactness ${result.compactness.compactnessScore.toFixed(3)} < 0.20 — potential gerrymandering` });
+    violations.push({
+      criterion: 'gerrymandering',
+      message: `District compactness ${result.compactness.compactnessScore.toFixed(3)} < 0.20 — potential gerrymandering`,
+    });
   }
-  if (result.budgetVar && result.budgetVar.overallStatus === 'unfavorable' && Math.abs(result.budgetVar.totalVariancePct) > 0.05) {
-    violations.push({ criterion: 'budget_overrun', message: `Budget overrun ${(result.budgetVar.totalVariancePct * 100).toFixed(1)}% exceeds 5% threshold` });
+  if (
+    result.budgetVar &&
+    result.budgetVar.overallStatus === 'unfavorable' &&
+    Math.abs(result.budgetVar.totalVariancePct) > 0.05
+  ) {
+    violations.push({
+      criterion: 'budget_overrun',
+      message: `Budget overrun ${(result.budgetVar.totalVariancePct * 100).toFixed(1)}% exceeds 5% threshold`,
+    });
   }
 
   return buildDomainSimulationReceipt({
@@ -359,7 +422,11 @@ export function buildGovtReceipt(
       districtCompactness: result.compactness?.compactnessScore ?? null,
       budgetVariancePct: result.budgetVar?.totalVariancePct ?? null,
     },
-    cael: { version: 'cael.v1', event: 'government_civic.civic_analysis', solverType: 'government-civic.permit-scoring' },
+    cael: {
+      version: 'cael.v1',
+      event: 'government_civic.civic_analysis',
+      solverType: 'government-civic.permit-scoring',
+    },
     acceptance: { accepted: violations.length === 0, violations },
   });
 }

package/src/index.ts

@@ -1,9 +1,44 @@
 export * from './civicsolver';
-export { createPermitHandler, type PermitConfig, type PermitState, type PermitType, type PermitStatus } from './traits/PermitTrait';
-export { createPublicMeetingHandler, type PublicMeetingConfig, type PublicMeetingState, type MeetingType, type MeetingStatus, type AgendaItem } from './traits/PublicMeetingTrait';
-export { createServiceRequestHandler, type ServiceRequestConfig, type ServiceRequestState, type ServiceCategory, type RequestStatus, type PriorityLevel } from './traits/ServiceRequestTrait';
-export { createVotingRecordHandler, type VotingRecordConfig, type VotingRecordState, type VoteType, type VoteOutcome, type VoteCast } from './traits/VotingRecordTrait';
-export { createCivicComplianceHandler, type CivicComplianceConfig, type CivicComplianceState, type ComplianceFramework, type ComplianceStatus, type ComplianceCheck, type FoiaRequest } from './traits/CivicComplianceTrait';
+export {
+  createPermitHandler,
+  type PermitConfig,
+  type PermitState,
+  type PermitType,
+  type PermitStatus,
+} from './traits/PermitTrait';
+export {
+  createPublicMeetingHandler,
+  type PublicMeetingConfig,
+  type PublicMeetingState,
+  type MeetingType,
+  type MeetingStatus,
+  type AgendaItem,
+} from './traits/PublicMeetingTrait';
+export {
+  createServiceRequestHandler,
+  type ServiceRequestConfig,
+  type ServiceRequestState,
+  type ServiceCategory,
+  type RequestStatus,
+  type PriorityLevel,
+} from './traits/ServiceRequestTrait';
+export {
+  createVotingRecordHandler,
+  type VotingRecordConfig,
+  type VotingRecordState,
+  type VoteType,
+  type VoteOutcome,
+  type VoteCast,
+} from './traits/VotingRecordTrait';
+export {
+  createCivicComplianceHandler,
+  type CivicComplianceConfig,
+  type CivicComplianceState,
+  type ComplianceFramework,
+  type ComplianceStatus,
+  type ComplianceCheck,
+  type FoiaRequest,
+} from './traits/CivicComplianceTrait';
 export * from './traits/types';
 
 import { createPermitHandler } from './traits/PermitTrait';
@@ -15,7 +50,14 @@ import { createCivicComplianceHandler } from './traits/CivicComplianceTrait';
 export const pluginMeta = {
   name: '@holoscript/plugin-government-civic',
   version: '1.0.0',
-  traits: ['permit', 'public_meeting', 'service_request', 'voting_record', 'civic_compliance', 'civic_decision'],
+  traits: [
+    'permit',
+    'public_meeting',
+    'service_request',
+    'voting_record',
+    'civic_compliance',
+    'civic_decision',
+  ],
 };
 
 // Runtime integration — behavioral trait handler + registrar that wire the

package/src/runtime.ts

@@ -60,12 +60,16 @@ export interface TraitDispatchContext {
 
 export interface RuntimeTraitHandler {
   name: string;
-  onAttach?: (node: unknown, config: CivicDecisionTraitConfig, context: TraitDispatchContext) => void;
+  onAttach?: (
+    node: unknown,
+    config: CivicDecisionTraitConfig,
+    context: TraitDispatchContext
+  ) => void;
   onUpdate?: (
     node: unknown,
     config: CivicDecisionTraitConfig,
     context: TraitDispatchContext,
-    delta: number,
+    delta: number
   ) => void;
 }
 
@@ -80,7 +84,7 @@ interface CivicDecisionNode {
 function solveOntoNode(
   node: unknown,
   config: CivicDecisionTraitConfig | undefined,
-  context: TraitDispatchContext,
+  context: TraitDispatchContext
 ): void {
   const carrier = node as CivicDecisionNode;
   const nodeId = carrier.id ?? carrier.name ?? 'unknown';

package/src/traits/CivicComplianceTrait.ts

@@ -2,7 +2,12 @@
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
 export type ComplianceFramework = 'ADA' | 'FOIA' | 'WCAG' | 'OPRA' | 'GDPR' | 'CCPA' | 'section508';
-export type ComplianceStatus = 'compliant' | 'non_compliant' | 'pending_review' | 'exempt' | 'remediation_in_progress';
+export type ComplianceStatus =
+  | 'compliant'
+  | 'non_compliant'
+  | 'pending_review'
+  | 'exempt'
+  | 'remediation_in_progress';
 
 export interface ComplianceCheck {
   id: string;
@@ -56,10 +61,11 @@ const defaultConfig: CivicComplianceConfig = {
 };
 
 function computeOverallStatus(checks: ComplianceCheck[]): ComplianceStatus {
-  if (checks.some(c => c.status === 'non_compliant')) return 'non_compliant';
-  if (checks.some(c => c.status === 'remediation_in_progress')) return 'remediation_in_progress';
-  if (checks.some(c => c.status === 'pending_review')) return 'pending_review';
-  if (checks.length > 0 && checks.every(c => c.status === 'compliant' || c.status === 'exempt')) return 'compliant';
+  if (checks.some((c) => c.status === 'non_compliant')) return 'non_compliant';
+  if (checks.some((c) => c.status === 'remediation_in_progress')) return 'remediation_in_progress';
+  if (checks.some((c) => c.status === 'pending_review')) return 'pending_review';
+  if (checks.length > 0 && checks.every((c) => c.status === 'compliant' || c.status === 'exempt'))
+    return 'compliant';
   return 'pending_review';
 }
 
@@ -69,7 +75,7 @@ export function createCivicComplianceHandler(): TraitHandler<CivicComplianceConf
     defaultConfig,
     onAttach(node: HSPlusNode, config: CivicComplianceConfig, ctx: TraitContext) {
       // Seed initial checks based on declared frameworks
-      const checks: ComplianceCheck[] = config.frameworks.map(fw => ({
+      const checks: ComplianceCheck[] = config.frameworks.map((fw) => ({
         id: `${config.entityId}-${fw.toLowerCase()}`,
         framework: fw,
         requirement: `${fw} baseline compliance`,
@@ -86,7 +92,10 @@ export function createCivicComplianceHandler(): TraitHandler<CivicComplianceConf
         overdueFoiaCount: 0,
         nonCompliantCount: 0,
       } satisfies CivicComplianceState;
-      ctx.emit?.('compliance:initialized', { entityId: config.entityId, frameworks: config.frameworks });
+      ctx.emit?.('compliance:initialized', {
+        entityId: config.entityId,
+        frameworks: config.frameworks,
+      });
     },
     onDetach(node: HSPlusNode, _config: CivicComplianceConfig, ctx: TraitContext) {
       delete node.__complianceState;
@@ -109,8 +118,10 @@ export function createCivicComplianceHandler(): TraitHandler<CivicComplianceConf
       if (overdue > prevOverdue) {
         ctx.emit?.('compliance:foia_overdue', { entityId: config.entityId, overdueCount: overdue });
       }
-      s.openFoiaCount = s.foiaRequests.filter(r => r.status === 'received' || r.status === 'processing').length;
-      s.nonCompliantCount = s.checks.filter(c => c.status === 'non_compliant').length;
+      s.openFoiaCount = s.foiaRequests.filter(
+        (r) => r.status === 'received' || r.status === 'processing'
+      ).length;
+      s.nonCompliantCount = s.checks.filter((c) => c.status === 'non_compliant').length;
       s.overallStatus = computeOverallStatus(s.checks);
     },
     onEvent(node: HSPlusNode, config: CivicComplianceConfig, ctx: TraitContext, event: TraitEvent) {
@@ -118,8 +129,12 @@ export function createCivicComplianceHandler(): TraitHandler<CivicComplianceConf
       if (!s) return;
       switch (event.type) {
         case 'compliance:update_check': {
-          const { checkId, status, remediation } = event.payload as { checkId: string; status: ComplianceStatus; remediation?: string };
-          const check = s.checks.find(c => c.id === checkId);
+          const { checkId, status, remediation } = event.payload as {
+            checkId: string;
+            status: ComplianceStatus;
+            remediation?: string;
+          };
+          const check = s.checks.find((c) => c.id === checkId);
           if (check) {
             check.status = status;
             check.lastChecked = new Date().toISOString();
@@ -135,28 +150,51 @@ export function createCivicComplianceHandler(): TraitHandler<CivicComplianceConf
           if (!req?.requestId) return;
           const receivedAt = new Date();
           // Approx 20 business days = 28 calendar days
-          const dueAt = new Date(receivedAt.getTime() + config.foiaResponseDaysLimit * 1.4 * 86_400_000);
-          s.foiaRequests.push({ ...req, requestedAt: receivedAt.toISOString(), responseDueAt: dueAt.toISOString(), status: 'received' });
-          s.openFoiaCount = s.foiaRequests.filter(r => r.status === 'received' || r.status === 'processing').length;
-          ctx.emit?.('compliance:foia_received', { requestId: req.requestId, dueAt: dueAt.toISOString() });
+          const dueAt = new Date(
+            receivedAt.getTime() + config.foiaResponseDaysLimit * 1.4 * 86_400_000
+          );
+          s.foiaRequests.push({
+            ...req,
+            requestedAt: receivedAt.toISOString(),
+            responseDueAt: dueAt.toISOString(),
+            status: 'received',
+          });
+          s.openFoiaCount = s.foiaRequests.filter(
+            (r) => r.status === 'received' || r.status === 'processing'
+          ).length;
+          ctx.emit?.('compliance:foia_received', {
+            requestId: req.requestId,
+            dueAt: dueAt.toISOString(),
+          });
           break;
         }
         case 'compliance:foia_fulfill': {
           const requestId = event.payload?.requestId as string;
-          const req = s.foiaRequests.find(r => r.requestId === requestId);
+          const req = s.foiaRequests.find((r) => r.requestId === requestId);
           if (req) {
             req.status = 'fulfilled';
-            s.openFoiaCount = s.foiaRequests.filter(r => r.status === 'received' || r.status === 'processing').length;
+            s.openFoiaCount = s.foiaRequests.filter(
+              (r) => r.status === 'received' || r.status === 'processing'
+            ).length;
             ctx.emit?.('compliance:foia_fulfilled', { requestId });
           }
           break;
         }
         case 'compliance:audit_log': {
-          const { action, actor, details } = event.payload as { action: string; actor: string; details: string };
-          s.auditLog.push({ timestamp: new Date().toISOString(), action, actor, details: details ?? '' });
+          const { action, actor, details } = event.payload as {
+            action: string;
+            actor: string;
+            details: string;
+          };
+          s.auditLog.push({
+            timestamp: new Date().toISOString(),
+            action,
+            actor,
+            details: details ?? '',
+          });
           // Prune logs older than retention window
           const cutoff = Date.now() - config.auditLogRetentionDays * 86_400_000;
-          s.auditLog = s.auditLog.filter(e => new Date(e.timestamp).getTime() > cutoff);
+          s.auditLog = s.auditLog.filter((e) => new Date(e.timestamp).getTime() > cutoff);
           break;
         }
       }

package/src/traits/PermitTrait.ts

@@ -1,8 +1,23 @@
 /** @permit Trait — Building and business permit lifecycle management. @trait permit */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type PermitType = 'building' | 'business' | 'event' | 'demolition' | 'electrical' | 'plumbing' | 'sign' | 'zoning';
-export type PermitStatus = 'submitted' | 'under_review' | 'approved' | 'denied' | 'expired' | 'revoked' | 'withdrawn';
+export type PermitType =
+  | 'building'
+  | 'business'
+  | 'event'
+  | 'demolition'
+  | 'electrical'
+  | 'plumbing'
+  | 'sign'
+  | 'zoning';
+export type PermitStatus =
+  | 'submitted'
+  | 'under_review'
+  | 'approved'
+  | 'denied'
+  | 'expired'
+  | 'revoked'
+  | 'withdrawn';
 
 export interface PermitConfig {
   permitType: PermitType;
@@ -10,7 +25,7 @@ export interface PermitConfig {
   applicantName: string;
   projectAddress: string;
   submittedAt: string; // ISO date
-  expiresAt?: string;  // ISO date — when approved permit expires
+  expiresAt?: string; // ISO date — when approved permit expires
   reviewDeadlineDays: number;
   showStatusBadge: boolean;
 }
@@ -74,7 +89,10 @@ export function createPermitHandler(): TraitHandler<PermitConfig> {
       const prev = node.__permitState as PermitState | undefined;
       const next = computeState(config, prev);
       if (next.isOverdue && !prev?.isOverdue) {
-        ctx.emit?.('permit:overdue', { applicationNumber: config.applicationNumber, daysInReview: next.daysInReview });
+        ctx.emit?.('permit:overdue', {
+          applicationNumber: config.applicationNumber,
+          daysInReview: next.daysInReview,
+        });
       }
       if (next.isExpiringSoon && !prev?.isExpiringSoon) {
         ctx.emit?.('permit:expiring_soon', { applicationNumber: config.applicationNumber });
@@ -93,13 +111,20 @@ export function createPermitHandler(): TraitHandler<PermitConfig> {
         const prev = s.status;
         s.status = newStatus;
         s.lastUpdated = new Date().toISOString();
-        ctx.emit?.('permit:status_changed', { from: prev, to: newStatus, applicationNumber: config.applicationNumber });
+        ctx.emit?.('permit:status_changed', {
+          from: prev,
+          to: newStatus,
+          applicationNumber: config.applicationNumber,
+        });
       }
       if (event.type === 'permit:add_note') {
         const note = event.payload?.note as string;
         if (note) {
           s.reviewNotes.push(note);
-          ctx.emit?.('permit:note_added', { applicationNumber: config.applicationNumber, noteCount: s.reviewNotes.length });
+          ctx.emit?.('permit:note_added', {
+            applicationNumber: config.applicationNumber,
+            noteCount: s.reviewNotes.length,
+          });
         }
       }
     },

package/src/traits/PublicMeetingTrait.ts

@@ -1,8 +1,21 @@
 /** @public_meeting Trait — City council and public hearing management. @trait public_meeting */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type MeetingType = 'city_council' | 'planning_commission' | 'public_hearing' | 'zoning_board' | 'budget_session' | 'town_hall';
-export type MeetingStatus = 'scheduled' | 'in_session' | 'recess' | 'public_comment' | 'voting' | 'adjourned' | 'cancelled';
+export type MeetingType =
+  | 'city_council'
+  | 'planning_commission'
+  | 'public_hearing'
+  | 'zoning_board'
+  | 'budget_session'
+  | 'town_hall';
+export type MeetingStatus =
+  | 'scheduled'
+  | 'in_session'
+  | 'recess'
+  | 'public_comment'
+  | 'voting'
+  | 'adjourned'
+  | 'cancelled';
 
 export interface AgendaItem {
   id: string;
@@ -80,7 +93,9 @@ export function createPublicMeetingHandler(): TraitHandler<PublicMeetingConfig>
       const quorumMet = config.membersPresent >= config.quorumRequired;
       if (quorumMet !== s.quorumMet) {
         s.quorumMet = quorumMet;
-        ctx.emit?.(quorumMet ? 'meeting:quorum_met' : 'meeting:quorum_lost', { meetingId: config.meetingId });
+        ctx.emit?.(quorumMet ? 'meeting:quorum_met' : 'meeting:quorum_lost', {
+          meetingId: config.meetingId,
+        });
       }
       s.lastUpdated = new Date().toISOString();
     },
@@ -91,11 +106,16 @@ export function createPublicMeetingHandler(): TraitHandler<PublicMeetingConfig>
         case 'meeting:call_to_order':
           s.status = 'in_session';
           s.recordingActive = true;
-          ctx.emit?.('meeting:called_to_order', { meetingId: config.meetingId, quorumMet: s.quorumMet });
+          ctx.emit?.('meeting:called_to_order', {
+            meetingId: config.meetingId,
+            quorumMet: s.quorumMet,
+          });
           break;
         case 'meeting:open_public_comment':
           s.status = 'public_comment';
-          ctx.emit?.('meeting:public_comment_open', { speakersRegistered: s.publicSpeakersRegistered });
+          ctx.emit?.('meeting:public_comment_open', {
+            speakersRegistered: s.publicSpeakersRegistered,
+          });
           break;
         case 'meeting:register_speaker':
           s.publicSpeakersRegistered++;
@@ -103,19 +123,28 @@ export function createPublicMeetingHandler(): TraitHandler<PublicMeetingConfig>
           break;
         case 'meeting:next_speaker':
           s.publicSpeakersHeard++;
-          ctx.emit?.('meeting:speaker_started', { heard: s.publicSpeakersHeard, remaining: s.publicSpeakersRegistered - s.publicSpeakersHeard });
+          ctx.emit?.('meeting:speaker_started', {
+            heard: s.publicSpeakersHeard,
+            remaining: s.publicSpeakersRegistered - s.publicSpeakersHeard,
+          });
           break;
         case 'meeting:next_agenda_item':
           if (s.currentAgendaItemIndex < config.agenda.length - 1) {
             s.currentAgendaItemIndex++;
             const item = config.agenda[s.currentAgendaItemIndex];
-            ctx.emit?.('meeting:agenda_advanced', { index: s.currentAgendaItemIndex, item: item?.title });
+            ctx.emit?.('meeting:agenda_advanced', {
+              index: s.currentAgendaItemIndex,
+              item: item?.title,
+            });
           }
           break;
         case 'meeting:adjourn':
           s.status = 'adjourned';
           s.recordingActive = false;
-          ctx.emit?.('meeting:adjourned', { meetingId: config.meetingId, minutesElapsed: Math.round(s.minutesElapsed) });
+          ctx.emit?.('meeting:adjourned', {
+            meetingId: config.meetingId,
+            minutesElapsed: Math.round(s.minutesElapsed),
+          });
           break;
       }
     },

package/src/traits/ServiceRequestTrait.ts

@@ -1,8 +1,25 @@
 /** @service_request Trait — 311-style civic service request tracking. @trait service_request */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type ServiceCategory = 'pothole' | 'streetlight' | 'graffiti' | 'abandoned_vehicle' | 'code_violation' | 'tree_hazard' | 'water_main' | 'sidewalk' | 'noise_complaint' | 'other';
-export type RequestStatus = 'submitted' | 'acknowledged' | 'assigned' | 'in_progress' | 'resolved' | 'closed' | 'duplicate';
+export type ServiceCategory =
+  | 'pothole'
+  | 'streetlight'
+  | 'graffiti'
+  | 'abandoned_vehicle'
+  | 'code_violation'
+  | 'tree_hazard'
+  | 'water_main'
+  | 'sidewalk'
+  | 'noise_complaint'
+  | 'other';
+export type RequestStatus =
+  | 'submitted'
+  | 'acknowledged'
+  | 'assigned'
+  | 'in_progress'
+  | 'resolved'
+  | 'closed'
+  | 'duplicate';
 export type PriorityLevel = 'low' | 'medium' | 'high' | 'urgent';
 
 export interface ServiceRequestConfig {
@@ -11,7 +28,7 @@ export interface ServiceRequestConfig {
   description: string;
   location: string;
   coordinates?: { lat: number; lng: number };
-  submittedAt: string;  // ISO datetime
+  submittedAt: string; // ISO datetime
   priority: PriorityLevel;
   targetResolutionDays: number; // SLA days by priority
   department: string;
@@ -100,7 +117,11 @@ export function createServiceRequestHandler(): TraitHandler<ServiceRequestConfig
           const prev = s.status;
           s.status = newStatus;
           s.lastStatusChange = new Date().toISOString();
-          ctx.emit?.('sr:status_changed', { from: prev, to: newStatus, requestId: config.requestId });
+          ctx.emit?.('sr:status_changed', {
+            from: prev,
+            to: newStatus,
+            requestId: config.requestId,
+          });
           break;
         }
         case 'sr:add_update': {
@@ -108,7 +129,10 @@ export function createServiceRequestHandler(): TraitHandler<ServiceRequestConfig
           const author = (event.payload?.author as string) ?? 'staff';
           if (message) {
             s.updates.push({ timestamp: new Date().toISOString(), message, author });
-            ctx.emit?.('sr:update_added', { requestId: config.requestId, updateCount: s.updates.length });
+            ctx.emit?.('sr:update_added', {
+              requestId: config.requestId,
+              updateCount: s.updates.length,
+            });
           }
           break;
         }

package/src/traits/VotingRecordTrait.ts

@@ -1,7 +1,12 @@
 /** @voting_record Trait — Public voting record and election results display. @trait voting_record */
 import type { TraitHandler, HSPlusNode, TraitContext, TraitEvent } from './types';
 
-export type VoteType = 'council_vote' | 'ballot_measure' | 'election' | 'referendum' | 'committee_vote';
+export type VoteType =
+  | 'council_vote'
+  | 'ballot_measure'
+  | 'election'
+  | 'referendum'
+  | 'committee_vote';
 export type VoteOutcome = 'passed' | 'failed' | 'tabled' | 'withdrawn' | 'tied' | 'pending';
 
 export interface VoteCast {
@@ -71,7 +76,9 @@ export function createVotingRecordHandler(): TraitHandler<VotingRecordConfig> {
       node.__votingState = {
         outcome: 'pending' as VoteOutcome,
         votes: [],
-        ayeCount: 0, nayCount: 0, abstainCount: 0,
+        ayeCount: 0,
+        nayCount: 0,
+        abstainCount: 0,
         absentCount: config.eligibleVoters.length,
         totalEligible: config.eligibleVoters.length,
         participationRate: 0,
@@ -98,24 +105,35 @@ export function createVotingRecordHandler(): TraitHandler<VotingRecordConfig> {
           const cast = event.payload as unknown as VoteCast;
           if (!cast?.memberId || !cast?.vote) return;
           // Replace if already voted
-          const existing = s.votes.findIndex(v => v.memberId === cast.memberId);
+          const existing = s.votes.findIndex((v) => v.memberId === cast.memberId);
           if (existing >= 0) s.votes.splice(existing, 1);
           s.votes.push({ ...cast, timestamp: new Date().toISOString() });
           // Recount
-          s.ayeCount = s.votes.filter(v => v.vote === 'aye').length;
-          s.nayCount = s.votes.filter(v => v.vote === 'nay').length;
-          s.abstainCount = s.votes.filter(v => v.vote === 'abstain').length;
+          s.ayeCount = s.votes.filter((v) => v.vote === 'aye').length;
+          s.nayCount = s.votes.filter((v) => v.vote === 'nay').length;
+          s.abstainCount = s.votes.filter((v) => v.vote === 'abstain').length;
           s.absentCount = s.totalEligible - s.votes.length;
           s.participationRate = s.votes.length / (s.totalEligible || 1);
           s.quorumMet = s.participationRate > 0.5;
-          ctx.emit?.('vote:cast', { voteId: config.voteId, memberId: cast.memberId, vote: cast.vote, ayeCount: s.ayeCount, nayCount: s.nayCount });
+          ctx.emit?.('vote:cast', {
+            voteId: config.voteId,
+            memberId: cast.memberId,
+            vote: cast.vote,
+            ayeCount: s.ayeCount,
+            nayCount: s.nayCount,
+          });
           break;
         }
         case 'vote:close':
           s.isOpen = false;
           s.closedAt = new Date().toISOString();
           s.outcome = computeOutcome(s, config);
-          ctx.emit?.('vote:closed', { voteId: config.voteId, outcome: s.outcome, ayeCount: s.ayeCount, nayCount: s.nayCount });
+          ctx.emit?.('vote:closed', {
+            voteId: config.voteId,
+            outcome: s.outcome,
+            ayeCount: s.ayeCount,
+            nayCount: s.nayCount,
+          });
           break;
         case 'vote:table':
           s.isOpen = false;

package/src/traits/types.ts

@@ -1,4 +1,25 @@
-export interface HSPlusNode { id?: string; properties?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitContext { emit?: (event: string, payload?: unknown) => void; getState?: () => Record<string, unknown>; setState?: (updates: Record<string, unknown>) => void; [key: string]: unknown; }
-export interface TraitEvent { type: string; source?: string; payload?: Record<string, unknown>; [key: string]: unknown; }
-export interface TraitHandler<TConfig = unknown> { name: string; defaultConfig: TConfig; onAttach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void; onDetach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void; onUpdate(node: HSPlusNode, config: TConfig, ctx: TraitContext, delta: number): void; onEvent(node: HSPlusNode, config: TConfig, ctx: TraitContext, event: TraitEvent): void; }
+export interface HSPlusNode {
+  id?: string;
+  properties?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitContext {
+  emit?: (event: string, payload?: unknown) => void;
+  getState?: () => Record<string, unknown>;
+  setState?: (updates: Record<string, unknown>) => void;
+  [key: string]: unknown;
+}
+export interface TraitEvent {
+  type: string;
+  source?: string;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+export interface TraitHandler<TConfig = unknown> {
+  name: string;
+  defaultConfig: TConfig;
+  onAttach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void;
+  onDetach(node: HSPlusNode, config: TConfig, ctx: TraitContext): void;
+  onUpdate(node: HSPlusNode, config: TConfig, ctx: TraitContext, delta: number): void;
+  onEvent(node: HSPlusNode, config: TConfig, ctx: TraitContext, event: TraitEvent): void;
+}

package/tsconfig.json

@@ -1 +1,10 @@
-{ "extends": "../../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "declaration": true, "declarationMap": true }, "include": ["src"] }
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025-2026 HoloScript Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.