@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-HMLIGAU7.js

@@ -0,0 +1,395 @@
+// src/utils/tool-wire-compact.ts
+var TOOL_DESCRIPTION_MAX_CHARS = 400;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
+var compactCache = /* @__PURE__ */ new WeakMap();
+function compactToolDefinitionForWire(tool, opts = {}) {
+  const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    const cached = compactCache.get(tool);
+    if (cached) return cached;
+  }
+  const compact = {
+    name: tool.name,
+    description: compactDescription(
+      tool.description ?? "",
+      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
+    ),
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
+    )
+  };
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    compactCache.set(tool, compact);
+  }
+  return compact;
+}
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
+function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
+  const compact = compactSchemaNode(schema, maxDescriptionChars);
+  return isRecord(compact) ? compact : { type: "object", properties: {} };
+}
+function compactSchemaNode(node, maxDescriptionChars) {
+  if (Array.isArray(node)) {
+    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
+  }
+  if (!isRecord(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "description" && typeof value === "string") {
+      out[key] = compactDescription(value, maxDescriptionChars);
+    } else {
+      out[key] = compactSchemaNode(value, maxDescriptionChars);
+    }
+  }
+  return out;
+}
+function compactDescription(text, maxChars) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= 20) return normalized.slice(0, maxChars);
+  const hardLimit = maxChars - 12;
+  const boundary = findSemanticBoundary(normalized, hardLimit);
+  const head = normalized.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd();
+  return `${head} ...`;
+}
+function findSemanticBoundary(text, limit) {
+  const punctuation = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(": ", limit)
+  );
+  if (punctuation >= Math.floor(limit * 0.45)) return punctuation + 1;
+  const comma = text.lastIndexOf(", ", limit);
+  if (comma >= Math.floor(limit * 0.6)) return comma + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space >= Math.floor(limit * 0.6) ? space : limit;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/utils/token-estimate.ts
+var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
+var CAL_ALPHA = 0.3;
+var CALIBRATION_GLOBAL_KEY = "__global__";
+var _cals = /* @__PURE__ */ new Map();
+function calState(key) {
+  let state = _cals.get(key);
+  if (!state) {
+    state = { ratio: 1, count: 0, prevEst: 0 };
+    _cals.set(key, state);
+  }
+  return state;
+}
+var MIN_SAMPLES_FOR_CALIBRATION = 3;
+var MODEL_FAMILY_RATIO = {
+  // Anthropic: ~3.8-4.0 chars/token depending on model
+  claude: 3.8,
+  // OpenAI: ~4.0 chars/token
+  "gpt-4": 4,
+  "gpt-3.5": 4,
+  // Google: ~3.5 chars/token
+  gemini: 3.5,
+  // DeepSeek: ~3.5 chars/token
+  deepseek: 3.5
+};
+var PAYLOAD_TOKEN_MEMO = /* @__PURE__ */ new WeakMap();
+function memoizedPayloadTokens(payload) {
+  const cached = PAYLOAD_TOKEN_MEMO.get(payload);
+  if (cached !== void 0) return cached;
+  let str;
+  try {
+    str = JSON.stringify(payload) ?? "";
+  } catch {
+    str = String(payload);
+  }
+  const estimate = RoughTokenEstimate(str);
+  PAYLOAD_TOKEN_MEMO.set(payload, estimate);
+  return estimate;
+}
+function estimateToolInputTokens(input) {
+  if (typeof input === "string") return RoughTokenEstimate(input);
+  if (input === null || typeof input !== "object") {
+    return RoughTokenEstimate(String(input));
+  }
+  return memoizedPayloadTokens(input);
+}
+function estimateToolResultTokens(content) {
+  if (typeof content === "string") return RoughTokenEstimate(content);
+  if (content === null || typeof content !== "object") {
+    return RoughTokenEstimate(String(content));
+  }
+  return memoizedPayloadTokens(content);
+}
+function estimateTextTokens(text) {
+  return RoughTokenEstimate(text);
+}
+function computeMessageTokens(msg) {
+  if (typeof msg.content === "string") return estimateTextTokens(msg.content);
+  let total = 0;
+  for (const b of msg.content) {
+    if (b.type === "text") total += estimateTextTokens(b.text);
+    else if (b.type === "tool_use") total += estimateToolInputTokens(b.input);
+    else if (b.type === "tool_result") total += estimateToolResultTokens(b.content);
+    else {
+      let str;
+      try {
+        str = JSON.stringify(b) ?? "";
+      } catch {
+        str = String(b);
+      }
+      total += RoughTokenEstimate(str);
+    }
+  }
+  return total;
+}
+function estimateMessageTokens(messages) {
+  let total = 0;
+  for (const m of messages) {
+    if (typeof m._estTokens === "number" && m._estTokens > 0) {
+      total += m._estTokens;
+      continue;
+    }
+    total += computeMessageTokens(m);
+  }
+  return total;
+}
+function realAnchoredInputTokens(messages, anchorTokens, anchorMsgCount) {
+  if (typeof anchorTokens !== "number" || anchorTokens <= 0) return null;
+  if (typeof anchorMsgCount !== "number" || anchorMsgCount < 0) return null;
+  if (messages.length < anchorMsgCount) return null;
+  const delta = anchorMsgCount === messages.length ? 0 : estimateMessageTokens(messages.slice(anchorMsgCount));
+  return anchorTokens + delta;
+}
+function estimateToolDefTokens(tool) {
+  const cached = tool._estDefTokens;
+  if (typeof cached === "number" && cached > 0) return cached;
+  const compact = compactToolDefinitionForWire(tool);
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
+}
+function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  let messagesTokens = 0;
+  if (typeof messages === "string") {
+    messagesTokens = RoughTokenEstimate(messages);
+  } else if (Array.isArray(messages)) {
+    for (const m of messages) {
+      if (typeof m === "object" && m !== null && "content" in m) {
+        const cached = m._estTokens;
+        if (typeof cached === "number" && cached > 0) {
+          messagesTokens += cached;
+          continue;
+        }
+        const content = m.content;
+        if (typeof content === "string") {
+          messagesTokens += RoughTokenEstimate(content);
+        } else if (Array.isArray(content)) {
+          for (const b of content) {
+            if (typeof b === "object" && b !== null) {
+              if (b.type === "text") {
+                messagesTokens += RoughTokenEstimate(b.text);
+              } else {
+                messagesTokens += RoughTokenEstimate(JSON.stringify(b));
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  let systemTokens = 0;
+  if (typeof systemPrompt === "string") {
+    systemTokens = RoughTokenEstimate(systemPrompt);
+  } else if (Array.isArray(systemPrompt)) {
+    for (const b of systemPrompt) {
+      if (typeof b === "object" && b !== null && b.type === "text") {
+        systemTokens += RoughTokenEstimate(b.text);
+      }
+    }
+  }
+  let toolsTokens = 0;
+  for (const t of tools) {
+    toolsTokens += estimateToolDefTokens(t);
+  }
+  const total = messagesTokens + systemTokens + toolsTokens;
+  calState(calibrationKey).prevEst = total;
+  return {
+    messages: messagesTokens,
+    systemPrompt: systemTokens,
+    tools: toolsTokens,
+    total
+  };
+}
+function recordActualUsage(actualInputTokens, estimatedInputTokens, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  if (actualInputTokens <= 0) return;
+  const cal = calState(calibrationKey);
+  const est = estimatedInputTokens ?? cal.prevEst;
+  if (est <= 0) return;
+  const sampleRatio = actualInputTokens / est;
+  if (cal.count === 0) {
+    cal.ratio = sampleRatio;
+  } else {
+    cal.ratio = CAL_ALPHA * sampleRatio + (1 - CAL_ALPHA) * cal.ratio;
+  }
+  cal.ratio = Math.min(1.5, Math.max(0.5, cal.ratio));
+  cal.count++;
+}
+function getCalibrationState(calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const cal = calState(calibrationKey);
+  return {
+    ratio: cal.ratio,
+    count: cal.count,
+    calibrated: cal.count >= MIN_SAMPLES_FOR_CALIBRATION
+  };
+}
+function estimateRequestTokensCalibrated(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const result = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const cal = calState(calibrationKey);
+  if (cal.count >= MIN_SAMPLES_FOR_CALIBRATION) {
+    const safeRatio = Math.min(1.5, Math.max(0.5, cal.ratio));
+    return {
+      messages: Math.round(result.messages * safeRatio),
+      systemPrompt: Math.round(result.systemPrompt * safeRatio),
+      tools: Math.round(result.tools * safeRatio),
+      total: Math.round(result.total * safeRatio)
+    };
+  }
+  const fallbackRatio = getModelFamilyRatio(calibrationKey);
+  if (fallbackRatio !== null) {
+    return {
+      messages: Math.round(result.messages * fallbackRatio),
+      systemPrompt: Math.round(result.systemPrompt * fallbackRatio),
+      tools: Math.round(result.tools * fallbackRatio),
+      total: Math.round(result.total * fallbackRatio)
+    };
+  }
+  return result;
+}
+var DENSITY_SAMPLE_PER_BLOCK = 4096;
+var DENSITY_SAMPLE_TOTAL_CAP = 2e6;
+function textDensityMultiplier(messages) {
+  let sampled = 0;
+  let nonAscii = 0;
+  let maxRun = 0;
+  const consider = (s) => {
+    const n = Math.min(s.length, DENSITY_SAMPLE_PER_BLOCK);
+    let run = 0;
+    for (let i = 0; i < n; i++) {
+      const c = s.charCodeAt(i);
+      if (c > 127) nonAscii++;
+      if (c === 32 || c === 9 || c === 10 || c === 13) {
+        if (run > maxRun) maxRun = run;
+        run = 0;
+      } else {
+        run++;
+      }
+    }
+    if (run > maxRun) maxRun = run;
+    sampled += n;
+  };
+  for (const m of messages) {
+    if (typeof m.content === "string") {
+      consider(m.content);
+    } else if (Array.isArray(m.content)) {
+      for (const b of m.content) {
+        if (b.type === "text") consider(b.text);
+        else if (b.type === "tool_result" && typeof b.content === "string") consider(b.content);
+        else if (b.type === "thinking") consider(b.thinking);
+      }
+    }
+    if (sampled >= DENSITY_SAMPLE_TOTAL_CAP) break;
+  }
+  if (sampled === 0) return 1;
+  const nonAsciiRatio = nonAscii / sampled;
+  let charsPerToken = 3.5 - 2 * nonAsciiRatio;
+  if (maxRun > 2e3 && nonAsciiRatio < 0.1) charsPerToken = Math.min(charsPerToken, 3);
+  const multiplier = 3.5 / Math.max(1.4, charsPerToken);
+  return Math.min(2.5, Math.max(1, multiplier));
+}
+function estimateRequestTokensUpperBound(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
+  const base = estimateRequestTokens(messages, systemPrompt, tools, calibrationKey);
+  const density = Array.isArray(messages) ? textDensityMultiplier(messages) : 1;
+  const cal = calState(calibrationKey);
+  const calCeiling = cal.count >= MIN_SAMPLES_FOR_CALIBRATION ? Math.min(1.5, Math.max(1, cal.ratio)) : 1;
+  const mult = Math.max(density, calCeiling);
+  if (mult <= 1) return base;
+  return {
+    messages: Math.ceil(base.messages * mult),
+    systemPrompt: Math.ceil(base.systemPrompt * mult),
+    tools: Math.ceil(base.tools * mult),
+    total: Math.ceil(base.total * mult)
+  };
+}
+function getModelFamilyRatio(calibrationKey) {
+  const lower = calibrationKey.toLowerCase();
+  for (const [family, ratio] of Object.entries(MODEL_FAMILY_RATIO)) {
+    if (lower.includes(family)) return ratio / 3.5;
+  }
+  return null;
+}
+function resetCalibration(calibrationKey) {
+  if (calibrationKey === void 0) {
+    _cals.clear();
+    return;
+  }
+  _cals.delete(calibrationKey);
+}
+
+export {
+  compactToolDefinitionForWire,
+  normalizeTopLevelToolSchema,
+  compactSchemaDescriptions,
+  estimateToolInputTokens,
+  estimateToolResultTokens,
+  estimateTextTokens,
+  computeMessageTokens,
+  estimateMessageTokens,
+  realAnchoredInputTokens,
+  estimateToolDefTokens,
+  estimateRequestTokens,
+  recordActualUsage,
+  getCalibrationState,
+  estimateRequestTokensCalibrated,
+  estimateRequestTokensUpperBound,
+  resetCalibration
+};
+//# sourceMappingURL=chunk-HMLIGAU7.js.map

package/dist/chunk-HXKZ7OBQ.js

@@ -0,0 +1,303 @@
+import {
+  reportEventTypeFor,
+  validateReportTransition
+} from "./chunk-WP7BVANJ.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-6FHWXLPT.js";
+import {
+  atomicWrite,
+  withFileLock
+} from "./chunk-OSGLYW5J.js";
+
+// src/plugins/review-report-store.ts
+import { randomUUID } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var REPORT_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
+var REPORT_DEFAULT_PAGE_SIZE = 25;
+var NL = "\n";
+var REPORT_STORE_FILE = "review-reports.jsonl";
+function resolveReportStorePath(projectDir) {
+  return path.join(projectDir, REPORT_STORE_FILE);
+}
+var JsonlReportStore = class {
+  filePath;
+  constructor(projectDir) {
+    this.filePath = resolveReportStorePath(projectDir);
+  }
+  get storePath() {
+    return this.filePath;
+  }
+  // ── Persist (create or reopen) ───────────────────────────────────
+  async persist(input) {
+    return withFileLock(this.filePath, async () => {
+      const existing = await this._findRecord(input.id);
+      if (existing) {
+        const updated = {
+          ...existing,
+          counts: input.counts,
+          totalFindings: input.totalFindings,
+          unparseableCount: input.unparseableCount,
+          durationSeconds: input.durationSeconds ?? existing.durationSeconds,
+          rawText: input.rawText || existing.rawText,
+          files: input.files.length > 0 ? input.files : existing.files,
+          ...input.evidenceStatus !== void 0 ? { evidenceStatus: input.evidenceStatus } : {},
+          ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
+        };
+        await fsp.appendFile(this.filePath, JSON.stringify({ __report: 1, data: updated }) + NL, {
+          encoding: "utf8",
+          mode: SECRET_FILE_MODE
+        });
+        return updated;
+      }
+      const report = {
+        id: input.id,
+        reviewedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: input.sessionId,
+        agentId: input.agentId,
+        reviewerModel: input.reviewerModel,
+        source: input.source,
+        reviewStatus: input.reviewStatus,
+        lifecycle: "open",
+        files: input.files,
+        counts: input.counts,
+        totalFindings: input.totalFindings,
+        unparseableCount: input.unparseableCount,
+        durationSeconds: input.durationSeconds,
+        rawText: input.rawText,
+        ...input.cascadeDepth !== void 0 ? { cascadeDepth: input.cascadeDepth } : {},
+        ...input.evidenceStatus !== void 0 ? { evidenceStatus: input.evidenceStatus } : {},
+        ...input.evidenceChecks !== void 0 ? { evidenceChecks: input.evidenceChecks } : {}
+      };
+      const createdEvent = {
+        id: randomUUID(),
+        reportId: report.id,
+        eventType: "created",
+        fromLifecycle: null,
+        toLifecycle: "open",
+        actorId: "system",
+        actorKind: "system",
+        timestamp: report.reviewedAt
+      };
+      const lines = JSON.stringify({ __report: 1, data: report }) + NL + JSON.stringify({ __reportEvent: 1, data: createdEvent }) + NL;
+      await fsp.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      return report;
+    });
+  }
+  // ── Lifecycle transitions ────────────────────────────────────────
+  async transition(reportId, to, actor, opts) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const from = this._materialize(entry).lifecycle;
+      validateReportTransition(from, to);
+      const event = {
+        id: randomUUID(),
+        reportId,
+        eventType: reportEventTypeFor(to),
+        fromLifecycle: from,
+        toLifecycle: to,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: opts?.reason
+      };
+      entry.report.lifecycle = to;
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return { ...entry.report };
+    });
+  }
+  async updateEvidence(reportId, status, checks) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((candidate) => candidate.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const updated = {
+        ...this._materialize(entry),
+        evidenceStatus: status,
+        evidenceChecks: checks
+      };
+      await fsp.appendFile(
+        this.filePath,
+        `${JSON.stringify({ __report: 1, data: updated })}${NL}`,
+        { encoding: "utf8", mode: SECRET_FILE_MODE }
+      );
+      return updated;
+    });
+  }
+  async addNote(reportId, actor, note) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.report.id === reportId);
+      if (!entry) throw new Error(`Review report not found: ${reportId}`);
+      const materialized = this._materialize(entry);
+      const event = {
+        id: randomUUID(),
+        reportId,
+        eventType: "note_added",
+        fromLifecycle: materialized.lifecycle,
+        toLifecycle: materialized.lifecycle,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: note
+      };
+      await fsp.appendFile(this.filePath, JSON.stringify({ __reportEvent: 1, data: event }) + NL, {
+        encoding: "utf8",
+        mode: SECRET_FILE_MODE
+      });
+      return materialized;
+    });
+  }
+  // ── Query ────────────────────────────────────────────────────────
+  async list(opts) {
+    const all = await this._readAll();
+    let reports = all.map((e) => this._materialize(e));
+    if (opts?.statuses && opts.statuses.length > 0) {
+      const set = new Set(opts.statuses);
+      reports = reports.filter((r) => set.has(r.lifecycle));
+    }
+    if (opts?.sources && opts.sources.length > 0) {
+      const set = new Set(opts.sources);
+      reports = reports.filter((r) => set.has(r.source));
+    }
+    reports.sort((a, b) => b.reviewedAt.localeCompare(a.reviewedAt));
+    const limit = opts?.limit ?? REPORT_DEFAULT_PAGE_SIZE;
+    return reports.slice(0, limit);
+  }
+  async get(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  async getEvents(reportId) {
+    const all = await this._readAllLines();
+    const events = [];
+    for (const line of all) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isEventRecord(parsed) && parsed.data.reportId === reportId) {
+          events.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  // ── Compaction ───────────────────────────────────────────────────
+  async compact(opts) {
+    return withFileLock(this.filePath, async () => {
+      const maxAge = opts?.maxAgeMs ?? REPORT_RETENTION_MS;
+      const now = Date.now();
+      const all = await this._readAll();
+      const kept = [];
+      let removed = 0;
+      let eventsFolded = 0;
+      for (const entry of all) {
+        const age = now - new Date(entry.report.reviewedAt).getTime();
+        const materialized = this._materialize(entry);
+        const isTerminal = materialized.lifecycle === "completed" || materialized.lifecycle === "skipped";
+        if (isTerminal && age > maxAge) {
+          removed++;
+          eventsFolded += entry.events.length;
+          continue;
+        }
+        const oldEvents = entry.events.filter(
+          (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+        );
+        if (oldEvents.length > 1) {
+          eventsFolded += oldEvents.length - 1;
+          const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+          entry.events = [
+            newestOld,
+            ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+          ];
+        }
+        kept.push({ record: { __report: 1, data: entry.report }, events: entry.events });
+      }
+      const lines = [];
+      for (const { record, events } of kept) {
+        if (record) lines.push(JSON.stringify(record));
+        for (const ev of events) {
+          lines.push(JSON.stringify({ __reportEvent: 1, data: ev }));
+        }
+      }
+      lines.push(
+        JSON.stringify({
+          __reportCompact: 1,
+          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          removedReports: removed,
+          foldedEvents: eventsFolded
+        })
+      );
+      await atomicWrite(this.filePath, lines.join(NL) + NL, { mode: 384 });
+      return { removed, eventsFolded };
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  async _readAllLines() {
+    try {
+      const raw = await fsp.readFile(this.filePath, "utf8");
+      return raw.split(NL).filter((l) => l.trim().length > 0);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  _isReportRecord(v) {
+    return typeof v === "object" && v !== null && v["__report"] === 1;
+  }
+  _isEventRecord(v) {
+    return typeof v === "object" && v !== null && v["__reportEvent"] === 1;
+  }
+  async _readAll() {
+    const lines = await this._readAllLines();
+    const reports = /* @__PURE__ */ new Map();
+    const eventsMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isReportRecord(parsed)) {
+          reports.set(parsed.data.id, parsed.data);
+          if (!eventsMap.has(parsed.data.id)) eventsMap.set(parsed.data.id, []);
+        } else if (this._isEventRecord(parsed)) {
+          const list = eventsMap.get(parsed.data.reportId);
+          if (list) list.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return Array.from(reports.entries()).map(([id, report]) => ({
+      report,
+      events: eventsMap.get(id) ?? []
+    }));
+  }
+  async _findRecord(id) {
+    const all = await this._readAll();
+    const entry = all.find((e) => e.report.id === id);
+    return entry ? this._materialize(entry) : null;
+  }
+  _materialize(entry) {
+    if (entry.events.length === 0) return { ...entry.report };
+    const sorted = [...entry.events].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latest = sorted[sorted.length - 1];
+    if (latest.eventType !== "note_added") {
+      return { ...entry.report, lifecycle: latest.toLifecycle };
+    }
+    return { ...entry.report };
+  }
+};
+
+export {
+  REPORT_RETENTION_MS,
+  REPORT_DEFAULT_PAGE_SIZE,
+  REPORT_STORE_FILE,
+  resolveReportStorePath,
+  JsonlReportStore
+};
+//# sourceMappingURL=chunk-HXKZ7OBQ.js.map