typescript-data-attribution-write-path

Answer

Context: the target repo was not mounted in this environment (only /workspace/problem.json exists), so I implemented MAF-GAP-029 as a complete, strict-compiled, tested TypeScript module set in /workspace that mirrors the named architecture exactly: engine/TokenTracker + APITracker → collector/collectUsageByPlayer() → bridge done message carrying usageByPlayer → adapter/persistUsage per-player rows → read/player-attribution.ts two-branch read path. A Dockerfile + scripts/rebuild.sh enforce the MAF-GAP-014 mandatory rebuild.

Root cause: engine already knew per-call usage, but the write path summed it into per-model rows with playerId='ALL'; the per-player provider/model/tokensUsed/apiCalls columns were never written. The fix attributes at the source and carries attribution end-to-end.

1. Engine trackers — record usage keyed by real player id (src/engine/trackers.ts):

export class TokenTracker {
  private readonly tokens = new Map<string, number>();
  addTokens(playerId: string, provider: string, model: string, tokens: number): void {
    if (!Number.isFinite(tokens) || tokens <= 0) return;
    const key = usageKey({ playerId, provider, model });   // playerId IS part of the key
    this.tokens.set(key, (this.tokens.get(key) ?? 0) + tokens);
  }
  snapshot() { /* -> {playerId, provider, model, tokensUsed}[] */ }
}
export class APITracker { /* same shape; addCall(playerId, provider, model) -> {..., apiCalls}[] */ }

2. Collector — aggregate per real player (src/collector/usage.ts):

export const PSEUDO_PLAYER_IDS: ReadonlySet<string> = new Set(['ALL', 'SYSTEM', 'GLOBAL', '']);
export function isRealPlayerId(id: string) { return !PSEUDO_PLAYER_IDS.has(id); }

export function collectUsageByPlayer(tokenTracker: TokenTracker, apiTracker: APITracker): UsageByPlayer {
  const merged = new Map<string, UsageRow>();
  const put = (row: UsageRow) => {
    if (!isRealPlayerId(row.playerId)) return;           // never attribute to pseudo players
    const key = usageKey({ playerId: row.playerId, provider: row.provider, model: row.model });
    const prev = merged.get(key);
    if (prev) { prev.tokensUsed += row.tokensUsed; prev.apiCalls += row.apiCalls; }
    else merged.set(key, { ...row });
  };
  for (const e of tokenTracker.snapshot()) put({ ...e, apiCalls: 0 });
  for (const e of apiTracker.snapshot()) put({ ...e, tokensUsed: 0 });
  // group by player, sort each player's rows by model
  ...
}
// collectUsageByModel() keeps the legacy per-model 'ALL' totals for backward compat.

3. Bridge — done message carries usageByPlayer (src/bridge/message.ts):

export function buildDoneMessage(gameId, tokenTracker, apiTracker): DoneMessage {
  return { type: 'done', gameId,
           usageByPlayer: collectUsageByPlayer(tokenTracker, apiTracker), // <-- NEW
           usageByModel: collectUsageByModel(tokenTracker, apiTracker) }; // legacy, kept
}

4. Adapter — persistUsage writes per-player rows (src/adapter/persist.ts):

export function persistUsage(store: UsageStore, message: DoneMessage): PersistResult {
  const rows: UsageRow[] = [];
  for (const list of message.usageByPlayer.values()) rows.push(...list); // per-player rows (the fix)
  for (const row of message.usageByModel) rows.push(row);                // legacy ALL rows (compat)
  for (const row of rows) store.upsert(row);                             // PK (player_id, provider, model)
  return { players: message.usageByPlayer.size, rows: rows.length };
}

5. Read path — player-attribution.ts, two branches (src/read/player-attribution.ts):

export function getPlayerAttribution(store: UsageStore, playerId: string): PlayerAttribution[] {
  // Branch 1: per-player rows fully populated (provider/model + tokensUsed>0 + apiCalls>0)
  const perPlayer = store.query(playerId).filter(r =>
    r.provider !== '' && r.model !== '' && r.tokensUsed > 0 && r.apiCalls > 0);
  if (perPlayer.length > 0) return perPlayer.map(r => ({ ...r, source: 'per-player' }));

  // Branch 2: single-model ALL-row fallback — resolve provider/model, tokens HONESTLY 0
  const allRows = store.queryAllRows()
    .filter(r => r.playerId === 'ALL' && r.provider !== '' && r.model !== '')
    .sort((a, b) => b.tokensUsed - a.tokensUsed);
  const top = allRows[0];
  if (!top) return [];
  return [{ playerId, provider: top.provider, model: top.model,
            tokensUsed: 0, apiCalls: 0, source: 'ALL-fallback' }]; // never fabricate a split of ALL
}

6. Mandatory rebuild — Dockerfile (node:22-slim, npm install → clean tsc build → node --test) and scripts/rebuild.sh (docker build --no-cache, run tests in container, copy container-built dist/ out). If the daemon is unavailable it falls back to a strict clean-room rebuild (pristine staging dir, fresh npm ci, clean build, tests).