pi2web 0.2.1 → 0.2.6

package/dist/collab/schemas.js

@@ -6,10 +6,23 @@ import { anyJson, arr, bool, num, obj, oneOf, optional, record, refine, str, wit
  * instead of guessing what the hub wanted.
  */
 const clientRequestId = () => str({ min: 8, max: 200 });
-const usage = () => optional(obj({ inputTokens: optional(num({ min: 0, max: 100_000_000, integer: true })), outputTokens: optional(num({ min: 0, max: 100_000_000, integer: true })), totalTokens: optional(num({ min: 0, max: 100_000_000, integer: true })) }));
-const codeLocation = () => obj({ path: str({ min: 1, max: 400 }), startLine: optional(num({ integer: true, min: 1 })), endLine: optional(num({ integer: true, min: 1 })) });
+const usage = () => optional(obj({
+    inputTokens: optional(num({ min: 0, max: 100_000_000, integer: true })),
+    outputTokens: optional(num({ min: 0, max: 100_000_000, integer: true })),
+    totalTokens: optional(num({ min: 0, max: 100_000_000, integer: true }))
+}));
+const codeLocation = () => obj({
+    path: str({ min: 1, max: 400 }),
+    startLine: optional(num({ integer: true, min: 1 })),
+    endLine: optional(num({ integer: true, min: 1 }))
+});
 /** Evidence must point at a file: an unanchored claim is indistinguishable from a hallucination. */
-const evidenceItem = () => obj({ path: str({ min: 1, max: 400 }), startLine: optional(num({ integer: true, min: 1 })), endLine: optional(num({ integer: true, min: 1 })), excerpt: optional(str({ max: 2000 })) });
+const evidenceItem = () => obj({
+    path: str({ min: 1, max: 400 }),
+    startLine: optional(num({ integer: true, min: 1 })),
+    endLine: optional(num({ integer: true, min: 1 })),
+    excerpt: optional(str({ max: 2000 }))
+});
 export const findingSchema = obj({
     externalId: optional(str({ max: 100 })),
     title: str({ min: 8, max: 200 }),
@@ -39,20 +52,32 @@ export const findingsRequest = obj({
 /** Batched after blind collection: one request validates every issue this reviewer did not report. */
 export const issueVotesRequest = obj({
     clientRequestId: clientRequestId(),
-    votes: arr(obj({ issueId: str({ min: 1, max: 100 }), stance: oneOf(['approve', 'reject']), rationale: optional(str({ max: 4000 })) }), { max: 200 }),
+    votes: arr(obj({
+        issueId: str({ min: 1, max: 100 }),
+        stance: oneOf(['approve', 'reject']),
+        rationale: optional(str({ max: 4000 }))
+    }), { max: 200 }),
     mergeProposals: withDefault(arr(obj({ issueIds: arr(str({ min: 1, max: 100 }), { min: 2, max: 20 }), rationale: str({ min: 10, max: 2000 }) }), { max: 50 }), () => []),
     complete: withDefault(bool(), () => true),
     usage: usage()
 });
 export const mergeVotesRequest = obj({
     clientRequestId: clientRequestId(),
-    votes: arr(obj({ proposalId: str({ min: 1, max: 100 }), stance: oneOf(['approve', 'reject']), rationale: optional(str({ max: 4000 })) }), { max: 100 }),
+    votes: arr(obj({
+        proposalId: str({ min: 1, max: 100 }),
+        stance: oneOf(['approve', 'reject']),
+        rationale: optional(str({ max: 4000 }))
+    }), { max: 100 }),
     complete: withDefault(bool(), () => true),
     usage: usage()
 });
 export const issueDiscussionsRequest = obj({
     clientRequestId: clientRequestId(),
-    discussions: withDefault(arr(obj({ issueId: str({ min: 1, max: 100 }), argument: str({ min: 20, max: 4000 }), respondingTo: optional(str({ max: 100 })) }), { max: 200 }), () => []),
+    discussions: withDefault(arr(obj({
+        issueId: str({ min: 1, max: 100 }),
+        argument: str({ min: 20, max: 4000 }),
+        respondingTo: optional(str({ max: 100 }))
+    }), { max: 200 }), () => []),
     /** The reporter's way out of a finding it no longer stands by, in the same call that defends the rest. */
     withdrawals: withDefault(arr(obj({ issueId: str({ min: 1, max: 100 }), rationale: str({ min: 10, max: 4000 }) }), { max: 200 }), () => []),
     complete: withDefault(bool(), () => true),
@@ -63,7 +88,11 @@ export const escalationRequest = obj({
     kind: oneOf(ESCALATION_KINDS),
     refId: optional(str({ max: 100 })),
     summary: str({ min: 20, max: 2000 }),
-    positions: withDefault(arr(obj({ participantId: str({ min: 1, max: 100 }), stance: str({ max: 200 }), rationale: str({ min: 10, max: 2000 }) }), { max: 20 }), () => []),
+    positions: withDefault(arr(obj({
+        participantId: str({ min: 1, max: 100 }),
+        stance: str({ max: 200 }),
+        rationale: str({ min: 10, max: 2000 })
+    }), { max: 20 }), () => []),
     question: str({ min: 10, max: 1000 }),
     options: withDefault(arr(str({ min: 1, max: 200 }), { max: 10 }), () => []),
     urgency: withDefault(oneOf(['low', 'normal', 'high']), () => 'normal'),
@@ -77,9 +106,19 @@ export const escalationRequest = obj({
 const scoringScale = refine(obj({ min: num({ min: 0, max: 1000 }), max: num({ min: 1, max: 1000 }), step: num({ min: 0.01, max: 100 }) }), scale => {
     const errors = [];
     if (scale.max <= scale.min)
-        errors.push({ path: 'max', code: 'OUT_OF_ORDER', message: `Expected max (${scale.max}) to be greater than min (${scale.min})`, expected: `> ${scale.min}` });
+        errors.push({
+            path: 'max',
+            code: 'OUT_OF_ORDER',
+            message: `Expected max (${scale.max}) to be greater than min (${scale.min})`,
+            expected: `> ${scale.min}`
+        });
     else if (scale.step > scale.max - scale.min)
-        errors.push({ path: 'step', code: 'TOO_LARGE', message: `Expected a step that fits inside the ${scale.min}-${scale.max} range`, expected: `<= ${scale.max - scale.min}` });
+        errors.push({
+            path: 'step',
+            code: 'TOO_LARGE',
+            message: `Expected a step that fits inside the ${scale.min}-${scale.max} range`,
+            expected: `<= ${scale.max - scale.min}`
+        });
     return errors;
 });
 const scoringPolicyPatch = refine(obj({
@@ -91,8 +130,17 @@ const scoringPolicyPatch = refine(obj({
     convergenceRange: optional(num({ min: 0, max: 1000 })),
     maxDebateRounds: optional(num({ integer: true, min: 0, max: 10 })),
     blindScoring: optional(bool())
-}), patch => patch.minCriteria !== undefined && patch.maxCriteria !== undefined && patch.minCriteria > patch.maxCriteria
-    ? [{ path: 'maxCriteria', code: 'OUT_OF_ORDER', message: `Expected maxCriteria (${patch.maxCriteria}) to be at least minCriteria (${patch.minCriteria})`, expected: `>= ${patch.minCriteria}` }]
+}), patch => patch.minCriteria !== undefined &&
+    patch.maxCriteria !== undefined &&
+    patch.minCriteria > patch.maxCriteria
+    ? [
+        {
+            path: 'maxCriteria',
+            code: 'OUT_OF_ORDER',
+            message: `Expected maxCriteria (${patch.maxCriteria}) to be at least minCriteria (${patch.minCriteria})`,
+            expected: `>= ${patch.minCriteria}`
+        }
+    ]
     : undefined);
 export const policyPatch = obj({
     maxIssueRounds: optional(num({ integer: true, min: 1, max: 20 })),
@@ -124,7 +172,11 @@ export const createSessionRequest = obj({
     title: str({ min: 3, max: 200 }),
     workspaceId: str({ min: 1, max: 200 }),
     relativeCwd: withDefault(str({ max: 400 }), () => '.'),
-    subject: obj({ type: oneOf(['diff', 'paths', 'commit_range', 'free']), value: str({ min: 1, max: 2000 }), notes: optional(str({ max: 4000 })) }),
+    subject: obj({
+        type: oneOf(['diff', 'paths', 'commit_range', 'free']),
+        value: str({ min: 1, max: 2000 }),
+        notes: optional(str({ max: 4000 }))
+    }),
     policy: optional(policyPatch)
 });
 export const createParticipantRequest = obj({
@@ -221,5 +273,9 @@ export const debateArgumentsRequest = obj({
 });
 export const finalizeRequest = obj({
     /** Human overrides for criteria the panel could not settle, keyed by criterionId. */
-    rulings: withDefault(arr(obj({ criterionId: str({ min: 1, max: 100 }), score: num({ min: 0, max: 1000 }), rationale: str({ min: 10, max: 2000 }) }), { max: 40 }), () => [])
+    rulings: withDefault(arr(obj({
+        criterionId: str({ min: 1, max: 100 }),
+        score: num({ min: 0, max: 1000 }),
+        rationale: str({ min: 10, max: 2000 })
+    }), { max: 40 }), () => [])
 });

package/dist/collab/scoring-flow.js

@@ -1,9 +1,16 @@
 import { COLLAB_ERRORS, can } from './types.js';
 import { flowError } from './review-flow.js';
 const mean = (values) => values.reduce((total, value) => total + value, 0) / values.length;
-const median = (values) => { const sorted = [...values].sort((a, b) => a - b), middle = sorted.length >> 1; return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2; };
-const stdev = (values) => { if (values.length < 2)
-    return 0; const average = mean(values); return Math.sqrt(values.reduce((total, value) => total + (value - average) ** 2, 0) / (values.length - 1)); };
+const median = (values) => {
+    const sorted = [...values].sort((a, b) => a - b), middle = sorted.length >> 1;
+    return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+const stdev = (values) => {
+    if (values.length < 2)
+        return 0;
+    const average = mean(values);
+    return Math.sqrt(values.reduce((total, value) => total + (value - average) ** 2, 0) / (values.length - 1));
+};
 const round2 = (value) => Math.round(value * 100) / 100;
 /** Only reviewers score. The implementer is recused so the party under review cannot grade itself. */
 export const scoringPanel = (snapshot) => snapshot.participants.filter(participant => participant.state !== 'left' && participant.role === 'reviewer');
@@ -27,7 +34,9 @@ export const contestedCriteria = (snapshot) => analyse(snapshot).filter(entry =>
 /** Everyone on the panel must submit before a phase closes; nothing is inferred from silence. */
 export function scoringWaitingOn(snapshot) {
     const panel = scoringPanel(snapshot).map(participant => participant.participantId);
-    const done = (phase, round = snapshot.round) => new Set(snapshot.completions.filter(entry => entry.phase === phase && entry.round === round).map(entry => entry.participantId));
+    const done = (phase, round = snapshot.round) => new Set(snapshot.completions
+        .filter(entry => entry.phase === phase && entry.round === round)
+        .map(entry => entry.participantId));
     switch (snapshot.phase) {
         case 'nominating': {
             const finished = done('nominating');
@@ -37,11 +46,15 @@ export function scoringWaitingOn(snapshot) {
             const candidates = candidateCriteria(snapshot);
             if (!candidates.length)
                 return [];
-            return panel.filter(id => candidates.some(criterion => !snapshot.votes.some(vote => vote.criterionId === criterion.criterionId && vote.participantId === id && vote.round === snapshot.round)));
+            return panel.filter(id => candidates.some(criterion => !snapshot.votes.some(vote => vote.criterionId === criterion.criterionId &&
+                vote.participantId === id &&
+                vote.round === snapshot.round)));
         }
         case 'scoring': {
             const criteria = approvedCriteria(snapshot);
-            return panel.filter(id => criteria.some(criterion => !snapshot.scores.some(score => score.criterionId === criterion.criterionId && score.participantId === id && score.round === snapshot.debateRound)));
+            return panel.filter(id => criteria.some(criterion => !snapshot.scores.some(score => score.criterionId === criterion.criterionId &&
+                score.participantId === id &&
+                score.round === snapshot.debateRound)));
         }
         case 'debating': {
             const open = snapshot.debates.filter(debate => debate.status === 'open' && debate.round === snapshot.debateRound);
@@ -49,10 +62,15 @@ export function scoringWaitingOn(snapshot) {
             return panel.filter(id => open.some(debate => snapshot.scores.some(score => score.criterionId === debate.criterionId && score.participantId === id) && !debate.arguments.some(entry => entry.participantId === id)));
         }
         case 'rescoring': {
-            const contested = snapshot.debates.filter(debate => debate.round === snapshot.debateRound).map(debate => debate.criterionId);
-            return panel.filter(id => contested.some(criterionId => !snapshot.scores.some(score => score.criterionId === criterionId && score.participantId === id && score.round === snapshot.debateRound + 1)));
+            const contested = snapshot.debates
+                .filter(debate => debate.round === snapshot.debateRound)
+                .map(debate => debate.criterionId);
+            return panel.filter(id => contested.some(criterionId => !snapshot.scores.some(score => score.criterionId === criterionId &&
+                score.participantId === id &&
+                score.round === snapshot.debateRound + 1)));
         }
-        default: return [];
+        default:
+            return [];
     }
 }
 /**
@@ -72,7 +90,9 @@ export function isScoringReadyToAdvance(snapshot) {
         return false;
     if (['consolidating', 'rubric_locked', 'analysis', 'awaiting_human'].includes(snapshot.phase))
         return true;
-    if (snapshot.phase === 'nominating' && !candidateCriteria(snapshot).length && !scoringWaitingOn(snapshot).length)
+    if (snapshot.phase === 'nominating' &&
+        !candidateCriteria(snapshot).length &&
+        !scoringWaitingOn(snapshot).length)
         return true;
     return scoringWaitingOn(snapshot).length === 0;
 }
@@ -85,9 +105,18 @@ export function tallyVotes(snapshot, round = snapshot.round) {
         const votes = snapshot.votes.filter(vote => vote.criterionId === criterion.criterionId && vote.round === round);
         const approve = votes.filter(vote => vote.stance === 'approve'), reject = votes.filter(vote => vote.stance === 'reject');
         const decided = approve.length + reject.length, ratio = decided ? approve.length / decided : 0;
-        const weights = approve.map(vote => vote.weight).filter((value) => typeof value === 'number' && value > 0);
-        return { criterionId: criterion.criterionId, approve: approve.length, reject: reject.length, abstain: votes.filter(vote => vote.stance === 'abstain').length,
-            ratio: round2(ratio), approved: ratio >= snapshot.policy.scoring.approvalThreshold && approve.length >= 2, weight: weights.length ? median(weights) : 1 };
+        const weights = approve
+            .map(vote => vote.weight)
+            .filter((value) => typeof value === 'number' && value > 0);
+        return {
+            criterionId: criterion.criterionId,
+            approve: approve.length,
+            reject: reject.length,
+            abstain: votes.filter(vote => vote.stance === 'abstain').length,
+            ratio: round2(ratio),
+            approved: ratio >= snapshot.policy.scoring.approvalThreshold && approve.length >= 2,
+            weight: weights.length ? median(weights) : 1
+        };
     });
 }
 /**
@@ -97,23 +126,38 @@ export function tallyVotes(snapshot, round = snapshot.round) {
  */
 export function lockRubric(snapshot) {
     const tallies = tallyVotes(snapshot), { minCriteria, maxCriteria, maxVotingRounds } = snapshot.policy.scoring;
-    const passed = tallies.filter(tally => tally.approved).sort((a, b) => b.ratio - a.ratio || b.approve - a.approve);
+    const passed = tallies
+        .filter(tally => tally.approved)
+        .sort((a, b) => b.ratio - a.ratio || b.approve - a.approve);
     const lastRound = snapshot.round >= maxVotingRounds;
     const withinRange = passed.length >= minCriteria && passed.length <= maxCriteria;
     if (withinRange)
-        return { criteria: normalizeWeights(passed), lockedBy: 'panel', reason: 'approved_by_panel', rejected: tallies.filter(tally => !tally.approved).map(tally => tally.criterionId) };
+        return {
+            criteria: normalizeWeights(passed),
+            lockedBy: 'panel',
+            reason: 'approved_by_panel',
+            rejected: tallies.filter(tally => !tally.approved).map(tally => tally.criterionId)
+        };
     if (!lastRound)
         return undefined;
     const fallback = (passed.length ? passed : [...tallies].sort((a, b) => b.ratio - a.ratio || b.approve - a.approve)).slice(0, maxCriteria);
     if (!fallback.length)
         return undefined;
-    return { criteria: normalizeWeights(fallback), lockedBy: 'policy',
+    return {
+        criteria: normalizeWeights(fallback),
+        lockedBy: 'policy',
         reason: passed.length > maxCriteria ? 'too_many_approved_criteria' : 'panel_never_reached_the_minimum',
-        rejected: tallies.filter(tally => !fallback.some(entry => entry.criterionId === tally.criterionId)).map(tally => tally.criterionId) };
+        rejected: tallies
+            .filter(tally => !fallback.some(entry => entry.criterionId === tally.criterionId))
+            .map(tally => tally.criterionId)
+    };
 }
 export function normalizeWeights(tallies) {
     const total = tallies.reduce((sum, tally) => sum + (tally.weight || 0), 0) || tallies.length;
-    return tallies.map(tally => ({ criterionId: tally.criterionId, weight: round2((tally.weight || 1) / total) }));
+    return tallies.map(tally => ({
+        criterionId: tally.criterionId,
+        weight: round2((tally.weight || 1) / total)
+    }));
 }
 /**
  * The scores that count for a criterion at `round`: each participant's latest submission at or before it.
@@ -137,11 +181,29 @@ export function analyse(snapshot, round = snapshot.debateRound) {
         const entries = effectiveScores(snapshot, criterion.criterionId, round);
         const values = entries.map(entry => entry.score);
         if (!values.length)
-            return { criterionId: criterion.criterionId, scores: [], min: 0, max: 0, mean: 0, median: 0, stdev: 0, range: 0, contested: false };
+            return {
+                criterionId: criterion.criterionId,
+                scores: [],
+                min: 0,
+                max: 0,
+                mean: 0,
+                median: 0,
+                stdev: 0,
+                range: 0,
+                contested: false
+            };
         const min = Math.min(...values), max = Math.max(...values);
-        return { criterionId: criterion.criterionId, scores: entries.map(entry => ({ participantId: entry.participantId, score: entry.score })),
-            min, max, mean: round2(mean(values)), median: round2(median(values)), stdev: round2(stdev(values)), range: round2(max - min),
-            contested: values.length > 1 && max - min > snapshot.policy.scoring.convergenceRange };
+        return {
+            criterionId: criterion.criterionId,
+            scores: entries.map(entry => ({ participantId: entry.participantId, score: entry.score })),
+            min,
+            max,
+            mean: round2(mean(values)),
+            median: round2(median(values)),
+            stdev: round2(stdev(values)),
+            range: round2(max - min),
+            contested: values.length > 1 && max - min > snapshot.policy.scoring.convergenceRange
+        };
     });
 }
 export function nextScoringPhase(snapshot, options = {}) {
@@ -155,22 +217,35 @@ export function nextScoringPhase(snapshot, options = {}) {
             throw flowError(COLLAB_ERRORS.wrongPhase, `${snapshot.pendingEscalations} escalation(s) still await a human ruling`);
         throw flowError(COLLAB_ERRORS.wrongPhase, `Still waiting on ${pending.length} participant(s): ${pending.join(', ')}`);
     }
-    const base = { round: snapshot.round, debateRound: snapshot.debateRound, ...(options.forced && pending.length ? { skipped: pending } : {}) };
+    const base = {
+        round: snapshot.round,
+        debateRound: snapshot.debateRound,
+        ...(options.forced && pending.length ? { skipped: pending } : {})
+    };
     switch (snapshot.phase) {
-        case 'nominating': return { ...base, phase: 'consolidating', reason: 'nominations_complete' };
-        case 'consolidating': return { ...base, phase: 'voting', reason: 'candidates_ready' };
+        case 'nominating':
+            return { ...base, phase: 'consolidating', reason: 'nominations_complete' };
+        case 'consolidating':
+            return { ...base, phase: 'voting', reason: 'candidates_ready' };
         case 'voting': {
             const rubric = lockRubric(snapshot);
             if (rubric)
-                return { ...base, phase: 'rubric_locked', reason: rubric.lockedBy === 'panel' ? 'rubric_approved' : 'rubric_forced_by_policy', rubric };
+                return {
+                    ...base,
+                    phase: 'rubric_locked',
+                    reason: rubric.lockedBy === 'panel' ? 'rubric_approved' : 'rubric_forced_by_policy',
+                    rubric
+                };
             const approved = tallyVotes(snapshot).filter(tally => tally.approved).length;
             // Too few criteria means the panel needs more proposals; too many means it needs to narrow down.
             return approved < snapshot.policy.scoring.minCriteria
                 ? { ...base, phase: 'nominating', round: snapshot.round + 1, reason: 'not_enough_approved_criteria' }
                 : { ...base, phase: 'voting', round: snapshot.round + 1, reason: 'too_many_approved_criteria' };
         }
-        case 'rubric_locked': return { ...base, phase: 'scoring', reason: 'rubric_locked' };
-        case 'scoring': return { ...base, phase: 'analysis', reason: 'scores_submitted' };
+        case 'rubric_locked':
+            return { ...base, phase: 'scoring', reason: 'rubric_locked' };
+        case 'scoring':
+            return { ...base, phase: 'analysis', reason: 'scores_submitted' };
         case 'analysis': {
             const contested = contestedCriteria(snapshot).map(entry => entry.criterionId);
             if (!contested.length)
@@ -179,10 +254,14 @@ export function nextScoringPhase(snapshot, options = {}) {
                 return { ...base, phase: 'awaiting_human', reason: 'scores_still_contested', contested };
             return { ...base, phase: 'debating', reason: 'contested_criteria', contested };
         }
-        case 'debating': return { ...base, phase: 'rescoring', reason: 'debate_complete' };
-        case 'rescoring': return { ...base, phase: 'analysis', debateRound: snapshot.debateRound + 1, reason: 'rescored' };
-        case 'awaiting_human': return { ...base, phase: 'finalized', reason: 'human_ruled' };
-        default: throw flowError(COLLAB_ERRORS.wrongPhase, `Phase ${snapshot.phase} cannot advance`);
+        case 'debating':
+            return { ...base, phase: 'rescoring', reason: 'debate_complete' };
+        case 'rescoring':
+            return { ...base, phase: 'analysis', debateRound: snapshot.debateRound + 1, reason: 'rescored' };
+        case 'awaiting_human':
+            return { ...base, phase: 'finalized', reason: 'human_ruled' };
+        default:
+            throw flowError(COLLAB_ERRORS.wrongPhase, `Phase ${snapshot.phase} cannot advance`);
     }
 }
 /**
@@ -197,24 +276,51 @@ export function finalizeScores(snapshot, rulings = {}) {
         const analysis = analyses.find(entry => entry.criterionId === criterion.criterionId);
         const ruled = rulings[criterion.criterionId];
         const finalScore = ruled !== undefined ? ruled : analysis?.scores.length ? analysis.median : 0;
-        return { criterionId: criterion.criterionId, name: criterion.name, weight: criterion.weight ?? round2(1 / Math.max(1, approvedCriteria(snapshot).length)),
+        return {
+            criterionId: criterion.criterionId,
+            name: criterion.name,
+            weight: criterion.weight ?? round2(1 / Math.max(1, approvedCriteria(snapshot).length)),
             finalScore: round2(finalScore),
-            method: (ruled !== undefined ? 'human_ruled' : analysis?.contested ? 'forced' : snapshot.debateRound > 0 ? 'debated' : 'converged'),
-            spread: analysis?.range ?? 0, perReviewer: Object.fromEntries((analysis?.scores ?? []).map(entry => [entry.participantId, entry.score])) };
+            method: (ruled !== undefined
+                ? 'human_ruled'
+                : analysis?.contested
+                    ? 'forced'
+                    : snapshot.debateRound > 0
+                        ? 'debated'
+                        : 'converged'),
+            spread: analysis?.range ?? 0,
+            perReviewer: Object.fromEntries((analysis?.scores ?? []).map(entry => [entry.participantId, entry.score]))
+        };
     });
     const weightTotal = criteria.reduce((sum, criterion) => sum + criterion.weight, 0) || 1;
     const totalScore = round2(criteria.reduce((sum, criterion) => sum + criterion.finalScore * criterion.weight, 0) / weightTotal);
     const spreads = analyses.filter(entry => entry.scores.length > 1).map(entry => entry.range / span);
     const dissents = criteria.flatMap(criterion => Object.entries(criterion.perReviewer)
-        .map(([participantId, score]) => ({ participantId, criterionId: criterion.criterionId, score, distanceFromFinal: round2(Math.abs(score - criterion.finalScore)) }))
+        .map(([participantId, score]) => ({
+        participantId,
+        criterionId: criterion.criterionId,
+        score,
+        distanceFromFinal: round2(Math.abs(score - criterion.finalScore))
+    }))
         .filter(entry => entry.distanceFromFinal > snapshot.policy.scoring.convergenceRange / 2));
-    return { criteria, totalScore, scale: { min: scale.min, max: scale.max }, agreement: round2(spreads.length ? 1 - mean(spreads) : 1), dissents };
+    return {
+        criteria,
+        totalScore,
+        scale: { min: scale.min, max: scale.max },
+        agreement: round2(spreads.length ? 1 - mean(spreads) : 1),
+        dissents
+    };
 }
 export function scoringProgress(snapshot) {
-    return { phase: snapshot.phase, round: snapshot.round, debateRound: snapshot.debateRound,
+    return {
+        phase: snapshot.phase,
+        round: snapshot.round,
+        debateRound: snapshot.debateRound,
         criteria: { candidates: candidateCriteria(snapshot).length, approved: approvedCriteria(snapshot).length },
         contested: contestedCriteria(snapshot).map(entry => entry.criterionId),
-        waitingOn: scoringWaitingOn(snapshot), readyToAdvance: isScoringReadyToAdvance(snapshot) };
+        waitingOn: scoringWaitingOn(snapshot),
+        readyToAdvance: isScoringReadyToAdvance(snapshot)
+    };
 }
 /** Blind scoring: nobody sees the distribution until every panelist has committed to a number. */
 export function scoresSealed(snapshot) {

package/dist/collab/similarity.js

@@ -0,0 +1,15 @@
+const words = (value) => new Set(value
+    .toLowerCase()
+    .split(/[^a-z0-9\u4e00-\u9fff]+/)
+    .filter(token => token.length > 1));
+/** Rough 0..1 score used to suggest possible duplicate findings. */
+export function similarity(a, b) {
+    const overlapping = a.location.path === b.location.path &&
+        (a.location.startLine === undefined ||
+            b.location.startLine === undefined ||
+            Math.max(a.location.startLine, b.location.startLine) <=
+                Math.min(a.location.endLine ?? a.location.startLine, b.location.endLine ?? b.location.startLine));
+    const left = words(`${a.title} ${a.suggestion ?? ''}`), right = words(`${b.title} ${b.suggestion ?? ''}`);
+    const shared = [...left].filter(token => right.has(token)).length, union = new Set([...left, ...right]).size;
+    return (overlapping ? 0.5 : 0) + (union ? 0.5 * (shared / union) : 0);
+}