portable-agent-layer 0.71.0 → 0.72.0

package/src/tools/lib/self-model.ts

@@ -0,0 +1,499 @@
+/**
+ * The deterministic half of self-model synthesis: what is read, how it is
+ * summarised, and what the model is asked.
+ *
+ * The tool around this is only ever spawned, so none of it was reachable from a
+ * test — not the rating trend, not the note grammar, not the guard that keeps a
+ * failed synthesis from being fed back into the next prompt as if it were a
+ * model. Every reader here takes the path to read and the clock to read it
+ * against, which is what makes a fixed corpus at a fixed date assertable.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const SELF_MODEL_TTL_MS = 24 * 60 * 60 * 1000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const LOW_RATING = 3;
+const HIGH_RATING = 8;
+const OPINION_FLOOR = 0.6;
+const TREND_DELTA = 0.5;
+const TREND_MIN_HALF = 3;
+
+const MONTH_DIR = /^\d{4}-\d{2}$/;
+const OPINION_NOTE = /^O\(c=([\d.]+)\):\s*(.+)$/;
+const WISDOM_NOTE = /^W:\s*(.+)$/;
+const SESSION_NOTE = /^Session:\s*(.+)$/;
+const CRYSTAL_TAIL = /\s*\[CRYSTAL:.*$/;
+const LIST_MARKER = /^-\s*/;
+const META_FOOTER = /\n\n\*\d+ ratings[^\n]*\n?$/;
+
+/** The marker a fallback carries so the next run never mistakes it for a model. */
+export const FAILED_SYNTHESIS = "Synthesis failed — raw data below";
+
+export interface Opinion {
+  id: string;
+  statement: string;
+  confidence: number;
+  category: string;
+  evidence: { date: string; type: string; source: string }[];
+  created: string;
+  updated: string;
+}
+
+export interface Rating {
+  ts: string;
+  type: string;
+  rating: number;
+  context: string;
+  source: string;
+}
+
+export interface GraduatedPattern {
+  pattern: string;
+  domain: string;
+  confidence: number;
+  occurrences: number;
+  sources: string[];
+  graduatedAt: string;
+}
+
+export interface AlgorithmReflection {
+  timestamp: string;
+  cwd?: string;
+  task: string;
+  criteria_count: number;
+  criteria_passed: number;
+  criteria_failed: number;
+  sentiment: number;
+  q1: string;
+  q2: string;
+  q3: string;
+}
+
+export interface RelationshipNote {
+  type: "O" | "W" | "Session";
+  content: string;
+  confidence?: number;
+  date: string;
+}
+
+export interface WisdomFrame {
+  domain: string;
+  principles: string[];
+}
+
+export interface RatingSummary {
+  count: number;
+  avg: number;
+  recentAvg: number;
+  lowCount: number;
+  highCount: number;
+  trend: "improving" | "declining" | "stable";
+  recentContexts: string[];
+}
+
+export interface SelfModelData {
+  days: number;
+  now: string;
+  sessionCount: number;
+  opinions: Opinion[];
+  ratings: RatingSummary;
+  wisdomFrames: WisdomFrame[];
+  graduated: GraduatedPattern[];
+  reflections: AlgorithmReflection[];
+  behaviorNotes: string[];
+  wisdomNotes: string[];
+  selfObservations: string[];
+  algorithmObservations: string[];
+  passRate: number;
+  avgSentiment: number;
+}
+
+/** Where each slice of the corpus lives, so the readers never consult globals. */
+export interface SelfModelSources {
+  opinionsFile: string;
+  ratingsFile: string;
+  wisdomDir: string;
+  graduatedFile: string;
+  reflectionsFile: string;
+  relationshipDir: string;
+  sessionDir: string;
+}
+
+export function readJsonl<T>(path: string): T[] {
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, "utf-8")
+      .split("\n")
+      .filter((line) => line.trim())
+      .map((line) => JSON.parse(line) as T);
+  } catch {
+    return [];
+  }
+}
+
+function safeReadJson<T>(path: string, fallback: T): T {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+function safeReaddir(dir: string): string[] {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+export function daysAgo(days: number, now: Date = new Date()): Date {
+  return new Date(now.getTime() - days * DAY_MS);
+}
+
+export function round1(n: number): number {
+  return Math.round(n * 10) / 10;
+}
+
+const isoDay = (date: Date) => date.toISOString().slice(0, 10);
+
+/** The guard that stops a synthesis running more than once a day. */
+export function synthesisIsDue(meta: string | null, now: Date): boolean {
+  if (meta === null) return true;
+  try {
+    const { timestamp } = JSON.parse(meta) as { timestamp: string };
+    return now.getTime() - new Date(timestamp).getTime() > SELF_MODEL_TTL_MS;
+  } catch {
+    return true;
+  }
+}
+
+/** The archive is filed under the model it replaces, not the day it is replaced. */
+export function archiveDateOf(meta: { timestamp?: string }, now: Date): string {
+  return meta.timestamp ? meta.timestamp.slice(0, 10) : isoDay(now);
+}
+
+export function readOpinions(opinionsFile: string): Opinion[] {
+  const data = safeReadJson<{ opinions?: Opinion[] }>(opinionsFile, { opinions: [] });
+  return (data.opinions ?? []).sort((a, b) => b.confidence - a.confidence);
+}
+
+const emptyRatingSummary = (): RatingSummary => ({
+  count: 0,
+  avg: 0,
+  recentAvg: 0,
+  lowCount: 0,
+  highCount: 0,
+  trend: "stable",
+  recentContexts: [],
+});
+
+const mean = (ratings: Rating[]) =>
+  ratings.reduce((sum, r) => sum + r.rating, 0) / ratings.length;
+
+/**
+ * Compares the older half of the window against the newer one. Fewer than three
+ * ratings a side is noise, so the trend stays flat rather than swinging on one.
+ */
+function trendOf(ratings: Rating[]): RatingSummary["trend"] {
+  const mid = Math.floor(ratings.length / 2);
+  if (mid < TREND_MIN_HALF) return "stable";
+  const delta = mean(ratings.slice(mid)) - mean(ratings.slice(0, mid));
+  if (delta > TREND_DELTA) return "improving";
+  if (delta < -TREND_DELTA) return "declining";
+  return "stable";
+}
+
+export function summarizeRatings(all: Rating[], since: Date): RatingSummary {
+  const ratings = all.filter((r) => new Date(r.ts) >= since);
+  if (ratings.length === 0) return emptyRatingSummary();
+
+  return {
+    count: ratings.length,
+    avg: round1(mean(ratings)),
+    recentAvg: round1(mean(ratings.slice(-10))),
+    lowCount: ratings.filter((r) => r.rating <= LOW_RATING).length,
+    highCount: ratings.filter((r) => r.rating >= HIGH_RATING).length,
+    trend: trendOf(ratings),
+    recentContexts: ratings
+      .filter((r) => r.rating <= LOW_RATING && r.context)
+      .slice(-5)
+      .map((r) => r.context),
+  };
+}
+
+export function readRatings(ratingsFile: string, since: Date): RatingSummary {
+  return summarizeRatings(readJsonl<Rating>(ratingsFile), since);
+}
+
+export function crystallizedPrinciples(content: string): string[] {
+  return content
+    .split("\n")
+    .filter((line) => line.includes("[CRYSTAL:"))
+    .map((line) => line.replace(LIST_MARKER, "").replace(CRYSTAL_TAIL, "").trim());
+}
+
+export function readWisdomFrames(wisdomDir: string): WisdomFrame[] {
+  const frames: WisdomFrame[] = [];
+
+  for (const file of safeReaddir(wisdomDir).filter((f) => f.endsWith(".md"))) {
+    const principles = crystallizedPrinciples(
+      readFileSync(resolve(wisdomDir, file), "utf-8")
+    );
+    if (principles.length > 0) {
+      frames.push({ domain: file.replace(/\.md$/, ""), principles });
+    }
+  }
+
+  return frames;
+}
+
+export function readGraduatedPatterns(graduatedFile: string): GraduatedPattern[] {
+  return (
+    safeReadJson<{ graduated?: GraduatedPattern[] }>(graduatedFile, { graduated: [] })
+      .graduated ?? []
+  );
+}
+
+export function readAlgorithmReflections(
+  reflectionsFile: string,
+  since: Date
+): AlgorithmReflection[] {
+  return readJsonl<AlgorithmReflection>(reflectionsFile).filter(
+    (r) => new Date(r.timestamp) >= since
+  );
+}
+
+export function parseRelationshipNotes(
+  content: string,
+  date: string
+): RelationshipNote[] {
+  const notes: RelationshipNote[] = [];
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("- ")) continue;
+    const body = trimmed.substring(2);
+
+    const opinion = OPINION_NOTE.exec(body);
+    if (opinion) {
+      notes.push({
+        type: "O",
+        confidence: Number.parseFloat(opinion[1]),
+        content: opinion[2],
+        date,
+      });
+      continue;
+    }
+
+    const wisdom = WISDOM_NOTE.exec(body);
+    if (wisdom) {
+      notes.push({ type: "W", content: wisdom[1], date });
+      continue;
+    }
+
+    const session = SESSION_NOTE.exec(body);
+    if (session) notes.push({ type: "Session", content: session[1], date });
+  }
+
+  return notes;
+}
+
+export function readRelationshipNotes(
+  relationshipDir: string,
+  since: Date
+): RelationshipNote[] {
+  const sinceDay = isoDay(since);
+  const notes: RelationshipNote[] = [];
+
+  for (const monthDir of safeReaddir(relationshipDir).filter((d) => MONTH_DIR.test(d))) {
+    const monthPath = resolve(relationshipDir, monthDir);
+    for (const file of safeReaddir(monthPath).filter((f) => f.endsWith(".md"))) {
+      const date = file.replace(/\.md$/, "");
+      if (date < sinceDay) continue;
+      notes.push(
+        ...parseRelationshipNotes(readFileSync(resolve(monthPath, file), "utf-8"), date)
+      );
+    }
+  }
+
+  return notes;
+}
+
+/** Session transcripts are filed year/month/YYYYMMDD-*.md, so the day is the filename. */
+export function countSessions(sessionDir: string, since: Date): number {
+  const sinceDay = isoDay(since);
+  let count = 0;
+
+  for (const year of safeReaddir(sessionDir)) {
+    for (const month of safeReaddir(resolve(sessionDir, year))) {
+      const days = safeReaddir(resolve(sessionDir, year, month)).filter((f) =>
+        f.endsWith(".md")
+      );
+      for (const file of days) {
+        const stamp = file.slice(0, 8);
+        const day = `${stamp.slice(0, 4)}-${stamp.slice(4, 6)}-${stamp.slice(6, 8)}`;
+        if (day >= sinceDay) count++;
+      }
+    }
+  }
+
+  return count;
+}
+
+export function reflectionStats(reflections: AlgorithmReflection[]): {
+  passRate: number;
+  avgSentiment: number;
+} {
+  if (reflections.length === 0) return { passRate: 0, avgSentiment: 0 };
+  const criteria = reflections.reduce((sum, r) => sum + r.criteria_count, 0);
+  const passed = reflections.reduce((sum, r) => sum + r.criteria_passed, 0);
+  return {
+    passRate: criteria > 0 ? Math.round((passed / criteria) * 100) : 0,
+    avgSentiment: round1(
+      reflections.reduce((sum, r) => sum + r.sentiment, 0) / reflections.length
+    ),
+  };
+}
+
+export function gatherData(
+  sources: SelfModelSources,
+  days: number,
+  now: Date = new Date()
+): SelfModelData {
+  const since = daysAgo(days, now);
+  const reflections = readAlgorithmReflections(sources.reflectionsFile, since);
+  const notes = readRelationshipNotes(sources.relationshipDir, since);
+
+  return {
+    days,
+    now: isoDay(now),
+    sessionCount: countSessions(sources.sessionDir, since),
+    opinions: readOpinions(sources.opinionsFile),
+    ratings: readRatings(sources.ratingsFile, since),
+    wisdomFrames: readWisdomFrames(sources.wisdomDir),
+    graduated: readGraduatedPatterns(sources.graduatedFile),
+    reflections,
+    behaviorNotes: notes.filter((n) => n.type === "Session").map((n) => n.content),
+    wisdomNotes: notes.filter((n) => n.type === "W").map((n) => n.content),
+    selfObservations: reflections.map((r) => r.q1).filter(Boolean),
+    algorithmObservations: reflections.map((r) => r.q2).filter(Boolean),
+    ...reflectionStats(reflections),
+  };
+}
+
+function section(heading: string, items: string[]): string[] {
+  return items.length > 0 ? [heading, ...items] : [];
+}
+
+export function formatDataForInference(
+  data: SelfModelData,
+  principalName: string
+): string {
+  const confident = data.opinions.filter((o) => o.confidence >= OPINION_FLOOR);
+
+  return [
+    `## Raw Data — ${data.days}-day window, ${data.now}`,
+    `Sessions: ${data.sessionCount}`,
+    `Ratings: ${data.ratings.count} total, ${data.ratings.avg}/10 avg, recent ${data.ratings.recentAvg}/10, trend ${data.ratings.trend}`,
+    `${data.ratings.highCount} high (8+), ${data.ratings.lowCount} low (<=3)`,
+    ...(data.opinions.length > 0
+      ? [
+          `\n### Opinions about ${principalName} (confidence-scored)`,
+          ...confident.map(
+            (o) => `- [${o.category}] ${o.statement} (${Math.round(o.confidence * 100)}%)`
+          ),
+        ]
+      : []),
+    ...section(
+      "\n### Crystallized Principles",
+      data.wisdomFrames.flatMap((f) => f.principles.map((p) => `- [${f.domain}] ${p}`))
+    ),
+    ...section(
+      "\n### Graduated Failure Patterns",
+      data.graduated.map((g) => `- [${g.domain}] ${g.pattern} (${g.occurrences}x)`)
+    ),
+    ...section(
+      "\n### Recent Frustration Signals (rated <=3)",
+      data.ratings.recentContexts.map((ctx) => `- "${ctx}"`)
+    ),
+    ...section(
+      "\n### Self-Observations (Q1 from algorithm reflections)",
+      data.selfObservations.slice(-8).map((obs) => `- ${obs}`)
+    ),
+    ...section(
+      "\n### Algorithm Observations (Q2 from reflections)",
+      data.algorithmObservations.slice(-5).map((obs) => `- ${obs}`)
+    ),
+    ...section(
+      "\n### Behavioral Notes (from relationship tracking)",
+      data.behaviorNotes.slice(-8).map((note) => `- ${note}`)
+    ),
+    ...section(
+      "\n### World/Context Notes",
+      data.wisdomNotes.slice(-5).map((note) => `- ${note}`)
+    ),
+    ...(data.reflections.length > 0
+      ? [
+          `\n### Algorithm Performance: ${data.passRate}% pass rate, ${data.avgSentiment}/10 sentiment, ${data.reflections.length} reflections`,
+        ]
+      : []),
+  ].join("\n");
+}
+
+export function buildPrompt(aiName: string, principalName: string): string {
+  return `You are writing a self-model for an AI assistant named ${aiName}. You ARE ${aiName}. Write in first person.
+
+You will receive structured data about your performance, your user's preferences, and behavioral patterns over a time window.
+
+Produce a short, actionable self-model — not a data dump. Every sentence must change behavior, not just describe it.
+
+## Required Sections
+
+**# Self-Model — ${aiName}**
+Include synthesis date and window.
+
+**## Who ${principalName} Is**
+One paragraph. Synthesize the opinions and behavioral notes into a working portrait — how ${principalName} thinks, communicates, and what frustrates him. Do not list raw opinion statements. Write it as understanding, not inventory.
+
+**## My Priority Right Now**
+One sentence. The single most impactful behavioral change to make immediately, derived from the failure patterns and trajectory. Specific and actionable — not "be more careful" but "before generating output that names a command or path, verify it exists."
+
+## Rules
+- First person, present tense
+- No raw numbers anywhere — a footer carries them
+- Under 150 words total
+- Do not add extra sections
+- Do not write a footer or meta line — one is appended automatically after your output`;
+}
+
+/**
+ * A failed synthesis is a raw data dump, not a model. Feeding one back in bloats
+ * the prompt and drives the next run into the same timeout, so it is dropped.
+ */
+export function previousModelForPrompt(previous: string): string {
+  if (previous.includes(FAILED_SYNTHESIS)) return "";
+  return previous.replace(META_FOOTER, "").trimEnd();
+}
+
+export function inferenceUserContent(rawData: string, previous: string): string {
+  const prior = previousModelForPrompt(previous);
+  if (!prior) return rawData;
+  return `${rawData}\n\n---\n\n## Previous Self-Model (compare against this — what changed?)\n\n${prior}`;
+}
+
+/** The numbers the prompt forbids in the body, appended once underneath it. */
+export function metaFooter(data: SelfModelData, now: Date = new Date()): string {
+  return (
+    `\n\n*${data.ratings.count} ratings · ${data.sessionCount} sessions · ` +
+    `${data.reflections.length} reflections · window: ${isoDay(daysAgo(data.days, now))} → ${data.now}*`
+  );
+}
+
+export function failedSynthesisModel(aiName: string, rawData: string): string {
+  return `# Self-Model — ${aiName}\n*${FAILED_SYNTHESIS}*\n\n${rawData}`;
+}

package/src/tools/lib/session-usage.ts

@@ -0,0 +1,216 @@
+/**
+ * What a finished Claude Code session cost, read back off its transcript.
+ *
+ * The `pal` wrapper spawns the tool around this after the agent exits, so none
+ * of it was reachable from a test: not the search for the session's file, not
+ * the token arithmetic, not the formatting.
+ */
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { costOfUsage } from "../../hooks/lib/models";
+import { cacheWritesOf, type TranscriptUsage } from "./transcript-usage";
+
+export interface SessionUsage {
+  input: number;
+  output: number;
+  cacheWrite5m: number;
+  cacheWrite1h: number;
+  cacheRead: number;
+  cost: number;
+  calls: number;
+  models: Set<string>;
+  durationMs: number;
+}
+
+export interface SessionFile {
+  filepath: string;
+  project: string;
+}
+
+export function claudeProjectsDir(): string {
+  return resolve(homedir(), ".claude", "projects");
+}
+
+function projectDirsIn(claudeDir: string) {
+  return readdirSync(claudeDir, { withFileTypes: true }).filter((entry) =>
+    entry.isDirectory()
+  );
+}
+
+function projectNameOf(dirName: string): string {
+  return dirName.split("-").pop() ?? dirName;
+}
+
+/**
+ * The most recently written transcript, for when no file is named for the
+ * session. Claude Code renames a session's file when it is resumed, so the id
+ * on the command line does not always still exist as a filename.
+ */
+function mostRecentTranscript(claudeDir: string): SessionFile | null {
+  let latest: { file: SessionFile; mtime: number } | null = null;
+
+  for (const dir of projectDirsIn(claudeDir)) {
+    const projPath = resolve(claudeDir, dir.name);
+    let files: string[];
+    try {
+      files = readdirSync(projPath).filter((name) => name.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+
+    for (const name of files) {
+      const filepath = resolve(projPath, name);
+      try {
+        const mtime = Bun.file(filepath).lastModified;
+        if (!latest || mtime > latest.mtime) {
+          latest = { file: { filepath, project: projectNameOf(dir.name) }, mtime };
+        }
+      } catch {}
+    }
+  }
+
+  return latest?.file ?? null;
+}
+
+export function findSessionFile(
+  sessionId: string,
+  claudeDir: string
+): SessionFile | null {
+  if (!existsSync(claudeDir)) return null;
+
+  for (const dir of projectDirsIn(claudeDir)) {
+    const filepath = resolve(claudeDir, dir.name, `${sessionId}.jsonl`);
+    if (existsSync(filepath)) {
+      return { filepath, project: projectNameOf(dir.name) };
+    }
+  }
+
+  return mostRecentTranscript(claudeDir);
+}
+
+interface TranscriptLine {
+  type?: string;
+  timestamp?: string;
+  sessionId?: string;
+  message?: { model?: string; usage?: TranscriptUsage };
+}
+
+function emptyUsage(): SessionUsage {
+  return {
+    input: 0,
+    output: 0,
+    cacheWrite5m: 0,
+    cacheWrite1h: 0,
+    cacheRead: 0,
+    cost: 0,
+    calls: 0,
+    models: new Set(),
+    durationMs: 0,
+  };
+}
+
+export function accumulateUsage(transcript: string, sessionId: string): SessionUsage {
+  const total = emptyUsage();
+  let firstTs = "";
+  let lastTs = "";
+
+  for (const line of transcript.split("\n")) {
+    if (!line) continue;
+
+    let entry: TranscriptLine;
+    try {
+      entry = JSON.parse(line) as TranscriptLine;
+    } catch {
+      continue;
+    }
+
+    if (entry.sessionId !== sessionId) continue;
+
+    if (entry.timestamp) {
+      if (!firstTs) firstTs = entry.timestamp;
+      lastTs = entry.timestamp;
+    }
+
+    if (entry.type !== "assistant") continue;
+    const usage = entry.message?.usage;
+    const model = entry.message?.model;
+    if (!usage || !model) continue;
+
+    const input = usage.input_tokens ?? 0;
+    const output = usage.output_tokens ?? 0;
+    const cacheRead = usage.cache_read_input_tokens ?? 0;
+    const { cacheWrite5m, cacheWrite1h } = cacheWritesOf(usage);
+
+    total.cost += costOfUsage(model, {
+      input,
+      output,
+      cacheWrite5m,
+      cacheWrite1h,
+      cacheRead,
+    });
+    total.input += input;
+    total.output += output;
+    total.cacheWrite5m += cacheWrite5m;
+    total.cacheWrite1h += cacheWrite1h;
+    total.cacheRead += cacheRead;
+    total.calls++;
+    total.models.add(model);
+  }
+
+  if (firstTs && lastTs) {
+    total.durationMs = new Date(lastTs).getTime() - new Date(firstTs).getTime();
+  }
+
+  return total;
+}
+
+function parseSession(filepath: string, sessionId: string): SessionUsage {
+  return accumulateUsage(readFileSync(filepath, "utf-8"), sessionId);
+}
+
+export function fmtTokens(n: number): string {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
+  return String(n);
+}
+
+/** Two decimals reads as money; a sub-dollar session needs four to say anything. */
+export function fmtCost(n: number): string {
+  if (n >= 1) return `$${n.toFixed(2)}`;
+  return `$${n.toFixed(4)}`;
+}
+
+export function fmtDuration(ms: number): string {
+  const mins = Math.floor(ms / 60_000);
+  if (mins < 1) return "<1m";
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  const rem = mins % 60;
+  return rem > 0 ? `${hrs}h ${rem}m` : `${hrs}h`;
+}
+
+export function totalTokens(usage: SessionUsage): number {
+  return (
+    usage.input + usage.output + usage.cacheWrite5m + usage.cacheWrite1h + usage.cacheRead
+  );
+}
+
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const CYAN = "\x1b[36m";
+
+export function summaryLine(project: string, usage: SessionUsage): string {
+  const models = [...usage.models].map((m) => m.replace("claude-", "")).join(", ");
+  return `\n${DIM}Session: ${project} · ${models} · ${fmtDuration(usage.durationMs)} · ${fmtTokens(totalTokens(usage))} tokens · ${usage.calls} calls · ${CYAN}${fmtCost(usage.cost)}${RESET}`;
+}
+
+/** Nothing to say when the session was not found, or made no model calls at all. */
+export function sessionSummary(sessionId: string, claudeDir: string): string | null {
+  if (!sessionId) return null;
+  const file = findSessionFile(sessionId, claudeDir);
+  if (!file) return null;
+  const usage = parseSession(file.filepath, sessionId);
+  return usage.calls === 0 ? null : summaryLine(file.project, usage);
+}