@tangle-network/agent-eval 0.217.1 → 0.218.1

package/dist/index-9jJ2fKSX.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-9jJ2fKSX.d.ts","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/journal-file.ts","../src/ledger-core/trusted-head.ts","../src/ledger-core/journal.ts","../src/ledger-core/merkle.ts","../src/ledger-core/projector-snapshot.ts"],"mappings":";;;UAiBiB;WACN;WACA;WACA;;UAGM;WACN,OAAO;EAChB;;KAGU;WACG;WAA0B;WAAyB,QAAQ;;WAC3D;WAA0B;;KAE7B;WACG;WAAyB,MAAM;IAC1C;UAEa;WACN;WACA;;;;;;;;iBA8BK,yBACd,SAAS,wBACR;;;;;UCpDc;;EAEf;EACA,eAAe,iBAAiB;IAAY;MAAoB;;;;;iBAkDlD,0BACd,cACA,kBACA,SAAS;KA6CC,eAAe;EAAO;EAAgB,OAAO;;EAAQ;;iBAEjD,sBAAsB,GACpC,cACA,SAAS,mBACT,WAAW,IACV,eAAe;;;;UCnED;EACf;EACA,WAAW;;;UAII;EACf;EACA,WAAW;;;;;;;;KA8FD;EACN;EAAe,MAAM;EAAmB;;EACxC;EAAe;EAAY;EAAoB;;EAC/C;EAAgB;;;UAsCL;;EAEf;;;EAGA;;;;;UC7Ie;EACf;;;;;UAMe,kBAAkB,cAAc;EAC/C;EACA,cAAc;EACd,OAAO;EACP,WAAW;;KAGD,cAAc,uBAAuB,cAAc,mBAAmB,SAChF,kBAAkB;UAEH;EACf;EACA;;;;;;;;;;UAWe,gBAAgB,OAAO;EACtC,MAAM,OAAO,OAAO;;;;EAIpB,YAAY;;;;;;;;;;UAWG,6BAA6B,OAAO;EACnD,UAAU,YAAY;EACtB,QAAQ,sBAAsB,gBAAgB,OAAO;;UAGtC,mBACf,uBACA,cAAc,iBACd,oBACQ;;EAER,QAAQ;EACR,cAAc,kBAAkB;;;;;;EAMhC,WAAW,cAAc,SAAS,oBAAoB,cAAc,QAAQ;;EAE5E,iBAAiB,OAAO,cAAc,QAAQ,QAAQ;EACtD,mBAAmB,gBAAgB,cAAc,QAAQ,QAAQ;EACjE,qBAAqB,6BAA6B,cAAc,QAAQ,QAAQ;;UAGjE,mBAAmB,OAAO;EACzC,OAAO;;EAEP;EACA,YAAY;;UAGG;;;;;;;;;;;;;;EAcf;;UAGe;;;;;;;EAOf;;;;;;EAMA;IAAsB;;;;;;cA2CX,kBAAkB,uBAAuB,cAAc,iBAAiB;WAC1E;;WAEA;;;WAGA;mBACQ;mBACA;mBACA;mBACA;UACT;EAER,YACE,cACA,OAAO,mBAAmB,QAAQ,OAAO,aACzC,UAAS;EAcL,UAAU,QAAQ;EAIlB,OACJ,OAAO,OACP,UAAS,sBACR,QAAQ,mBAAmB,cAAc,QAAQ,QAAQ;;EA+CtD,eAAe,QAAQ;;;;EAWvB,kBAAkB,QAAQ;;;;;;;;EAkC1B,oBAAoB,QAAQ;;;;UAsB1B;;;;UAgBA;UAwCA;;;;;;;;;;;;;UA2CA;;;;;;;;UAuBA;;;;UAiBA;;;;;;;;;;;;;;;UAwBA;;;;;;UAqIA;;;;UA+CO;EACf,KAAK;EACL,MAAM,cAAc;;;;;UC9qBL;WACN;WACA;WACA,eAAe;;;UAIT;WACN;WACA;WACA,eAAe;;KAGd;WACG;;WACA;WAA0B;;;iBAWzB;;;;;iBAQA,eAAe,SAAS,qBAAqB,gBAAgB;;iBAU7D,WAAW,iBAAiB,eAAe;;iBAM3C,qBACd,iBAAiB,cACjB,oBACC;;iBAea,sBACd,MAAM,YACN,OAAO,sBACP,MAAM,aACL;;;;UCtDc;EACf,MAAM;;;;EAIN;;EAEA"}

package/dist/index-ZuWx52WG.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-ZuWx52WG.d.ts","names":["_$__external_optimizer_process0.ExternalTextEvaluationRequest","AgentProfile","AgentProfile"],"sources":["../src/campaign/search-ledger-errors.ts","../src/campaign/coverage.ts","../src/campaign/final-evidence.ts","../src/campaign/cell-schedule.ts","../src/campaign/cell-cache.ts","../src/campaign/plan-campaign-run.ts","../src/campaign/run-campaign.ts","../src/campaign/presets/run-eval.ts","../src/campaign/auto-pr.ts","../src/campaign/presets/run-optimization.ts","../src/campaign/presets/run-improvement-loop.ts","../src/campaign/transient-failure.ts","../src/llm-judge.ts","../src/reference-equivalence-judge.ts","../src/campaign/external-optimizer-observations.ts","../src/campaign/gepa-candidate-population.ts","../src/campaign/optimization-cost.ts","../src/campaign/optimization-method.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/presets/compare-optimization-methods.ts","../src/campaign/skillopt-optimization-method.ts","../src/campaign/gates/compose.ts","../src/canary.ts","../src/red-team.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/score-utils.ts","../src/campaign/provenance.ts","../src/campaign/analyst-surface.ts","../src/campaign/cross-surface-types.ts","../src/campaign/cross-surface-interaction.ts","../src/campaign/fixtures.ts","../src/campaign/gates/neutralization-gate.ts","../src/campaign/gepa-search-import.ts","../src/campaign/grounded-reflection.ts","../src/campaign/labeled-store/fs-adapter.ts","../src/campaign/neutralize.ts","../src/campaign/optimization-method-composition.ts","../src/artifact-validator.ts","../src/completion-verifier.ts","../src/produced-state.ts","../src/campaign/presets/playback.ts","../src/integrity/backend-integrity.ts","../src/campaign/presets/run-profile-matrix.ts","../src/campaign/presets/segmented-profile-matrix.ts","../src/campaign/retained-dispatch.ts","../src/campaign/run-dir.ts","../src/campaign/scenario-selection.ts","../src/campaign/search-campaign-cell.ts","../src/campaign/single-run-lock.ts","../src/campaign/surface-identity.ts","../src/campaign/upstream-evaluators.ts","../src/campaign/worktree/index.ts"],"mappings":"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"}

package/dist/integrity-DOd9Q86O.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrity-DOd9Q86O.js","names":[],"sources":["../src/supervisor-run/integrity-issues.ts","../src/supervisor-run/integrity-steer.ts","../src/supervisor-run/integrity-transcript.ts","../src/supervisor-run/integrity-source.ts","../src/supervisor-run/integrity-tree.ts","../src/supervisor-run/integrity-types.ts","../src/supervisor-run/rollout-nodes.ts","../src/supervisor-run/integrity.ts"],"sourcesContent":["import type { SupervisorRunIntegrityEvidence, SupervisorRunIntegrityIssue } from './integrity-types'\n\nexport const MAX_EXAMPLES = 20\n\nexport function evidence(path: string, value: unknown): SupervisorRunIntegrityEvidence {\n  return { path, value }\n}\n\nexport function issue(\n  init: Omit<SupervisorRunIntegrityIssue, 'evidence'> & {\n    evidence?: readonly SupervisorRunIntegrityEvidence[]\n  },\n): SupervisorRunIntegrityIssue {\n  return { ...init, evidence: init.evidence ?? [] }\n}\n","import { evidence, issue, MAX_EXAMPLES } from './integrity-issues'\nimport type { JoinedWorker } from './integrity-source'\nimport type { SupervisorRunIntegrityIssue } from './integrity-types'\n\nfunction idListDetail(ids: readonly string[]): string {\n  const examples = ids\n    .slice(0, MAX_EXAMPLES)\n    .map((id) => JSON.stringify(id))\n    .join(', ')\n  return ids.length <= MAX_EXAMPLES\n    ? examples\n    : `${examples}, and ${ids.length - MAX_EXAMPLES} more`\n}\n\nexport function steerIssues(\n  joined: JoinedWorker,\n  rootCompleted: boolean,\n): SupervisorRunIntegrityIssue[] {\n  const { facts } = joined\n  const subject = facts.workerId ?? joined.spawn.id\n  const prefix = `workers/${facts.sourceIndex}`\n  const out: SupervisorRunIntegrityIssue[] = []\n  if (\n    !facts.inboxCaptured ||\n    !facts.eventsCaptured ||\n    facts.inboxInvalidRows > 0 ||\n    facts.eventsInvalidRows > 0\n  ) {\n    const missing = [\n      ...(facts.inboxCaptured ? [] : ['inbox']),\n      ...(facts.eventsCaptured ? [] : ['events']),\n    ]\n    const malformed = [\n      ...(facts.inboxInvalidRows > 0 ? [`inbox:${facts.inboxInvalidRows}`] : []),\n      ...(facts.eventsInvalidRows > 0 ? [`events:${facts.eventsInvalidRows}`] : []),\n    ]\n    out.push(\n      issue({\n        code: 'worker-controls-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject,\n        claim:\n          'Steer delivery integrity is unavailable for a worker with missing control artifacts',\n        detail:\n          missing.length > 0\n            ? `${JSON.stringify(subject)} is missing ${missing.join(' and ')}.`\n            : `${JSON.stringify(subject)} has malformed control rows (${malformed.join(', ')}).`,\n        evidence: [\n          ...missing.map((artifact) => evidence(`${prefix}/${artifact}`, null)),\n          ...(facts.inboxInvalidRows > 0\n            ? [evidence(`${prefix}/inbox/malformed-rows/count`, facts.inboxInvalidRows)]\n            : []),\n          ...(facts.eventsInvalidRows > 0\n            ? [evidence(`${prefix}/events/malformed-rows/count`, facts.eventsInvalidRows)]\n            : []),\n        ],\n        recommendedAction:\n          'Retain both control artifacts and repair malformed rows before correlating requests.',\n        metadata: {\n          assessment: 'unavailable',\n          missing_artifacts: missing,\n          malformed_rows: malformed,\n        },\n      }),\n    )\n    return out\n  }\n\n  const requestsById = new Map<string, typeof facts.steerRequests>()\n  const unidentifiedRequests = facts.steerRequests.filter((request) => request.requestId === null)\n  for (const request of facts.steerRequests) {\n    if (request.requestId === null) continue\n    const rows = requestsById.get(request.requestId) ?? []\n    rows.push(request)\n    requestsById.set(request.requestId, rows)\n  }\n  if (unidentifiedRequests.length > 0) {\n    out.push(\n      issue({\n        code: 'steer-request-id-unavailable',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject,\n        claim: 'Some queued steer requests cannot be correlated because their ids are missing',\n        detail: `${unidentifiedRequests.length} queued request(s) omit id.`,\n        evidence: unidentifiedRequests\n          .slice(0, MAX_EXAMPLES)\n          .map((request) => evidence(`${prefix}/inbox/${request.row}/id`, null)),\n        recommendedAction: 'Assign one stable request id before appending a steer to the inbox.',\n        metadata: { assessment: 'unavailable', unavailable_count: unidentifiedRequests.length },\n      }),\n    )\n  }\n  const duplicateRequestIds = [...requestsById]\n    .filter(([, rows]) => rows.length > 1)\n    .map(([id]) => id)\n  if (duplicateRequestIds.length > 0) {\n    out.push(\n      issue({\n        code: 'duplicate-steer-request-id',\n        area: 'control-integrity',\n        severity: 'high',\n        subject,\n        claim: 'A worker inbox contains duplicate steer request ids',\n        detail: `${duplicateRequestIds.length} duplicate id(s): ${idListDetail(duplicateRequestIds)}.`,\n        evidence: [\n          evidence(\n            `${prefix}/inbox/duplicate-request-ids`,\n            duplicateRequestIds.slice(0, MAX_EXAMPLES),\n          ),\n        ],\n        recommendedAction: 'Generate a unique request id for every queued steer.',\n      }),\n    )\n  }\n\n  const acknowledgementsById = new Map<string, typeof facts.steerAcknowledgements>()\n  const unidentifiedAcks = facts.steerAcknowledgements.filter((ack) => ack.requestId === null)\n  for (const ack of facts.steerAcknowledgements) {\n    if (ack.requestId === null) continue\n    const rows = acknowledgementsById.get(ack.requestId) ?? []\n    rows.push(ack)\n    acknowledgementsById.set(ack.requestId, rows)\n  }\n  if (unidentifiedAcks.length > 0) {\n    out.push(\n      issue({\n        code: 'steer-ack-id-unavailable',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject,\n        claim: 'Some steer acknowledgements cannot be correlated because requestId is missing',\n        detail: `${unidentifiedAcks.length} down-leg event(s) omit requestId.`,\n        evidence: unidentifiedAcks\n          .slice(0, MAX_EXAMPLES)\n          .map((ack) => evidence(`${prefix}/events/${ack.row}/requestId`, null)),\n        recommendedAction: 'Echo the queued request id on every worker acknowledgement.',\n        metadata: { assessment: 'unavailable', unavailable_count: unidentifiedAcks.length },\n      }),\n    )\n  }\n\n  const unknownAckIds = [...acknowledgementsById.keys()].filter((id) => !requestsById.has(id))\n  if (unknownAckIds.length > 0) {\n    out.push(\n      issue({\n        code: 'unknown-steer-ack',\n        area: 'control-integrity',\n        severity: 'high',\n        subject,\n        claim: 'A worker acknowledged steer request ids absent from its captured inbox',\n        detail: `${unknownAckIds.length} unknown id(s): ${idListDetail(unknownAckIds)}.`,\n        evidence: [\n          evidence(`${prefix}/events/unknown-request-ids`, unknownAckIds.slice(0, MAX_EXAMPLES)),\n        ],\n        recommendedAction:\n          'Reject acknowledgements whose request id was not queued for this worker.',\n      }),\n    )\n  }\n\n  const duplicateAckIds = [...acknowledgementsById]\n    .filter(([, rows]) => rows.length > 1)\n    .map(([id]) => id)\n  if (duplicateAckIds.length > 0) {\n    out.push(\n      issue({\n        code: 'duplicate-steer-ack',\n        area: 'control-integrity',\n        severity: 'high',\n        subject,\n        claim: 'A worker emitted duplicate acknowledgements for steer request ids',\n        detail: `${duplicateAckIds.length} duplicated id(s): ${idListDetail(duplicateAckIds)}.`,\n        evidence: [\n          evidence(\n            `${prefix}/events/duplicate-request-ids`,\n            duplicateAckIds.slice(0, MAX_EXAMPLES),\n          ),\n        ],\n        recommendedAction: 'Make steer acknowledgement append idempotent by request id.',\n      }),\n    )\n  }\n\n  const missingAckIds = [...requestsById.keys()].filter((id) => !acknowledgementsById.has(id))\n  if (rootCompleted && missingAckIds.length > 0) {\n    out.push(\n      issue({\n        code: 'missing-steer-ack',\n        area: 'control-integrity',\n        severity: 'high',\n        subject,\n        claim: 'A completed supervisor run has queued steer requests without acknowledgements',\n        detail: `${missingAckIds.length}/${requestsById.size} request id(s) are unacknowledged: ${idListDetail(missingAckIds)}.`,\n        evidence: [\n          evidence(\n            `${prefix}/inbox/unacknowledged-request-ids`,\n            missingAckIds.slice(0, MAX_EXAMPLES),\n          ),\n        ],\n        recommendedAction:\n          'Record one delivered or failed acknowledgement for every queued request id.',\n      }),\n    )\n  }\n\n  const statusUnavailableIds: string[] = []\n  const notDeliveredIds: string[] = []\n  for (const [id, acknowledgements] of acknowledgementsById) {\n    if (!requestsById.has(id) || acknowledgements.length !== 1) continue\n    const delivered = acknowledgements[0]?.delivered\n    if (delivered === null || delivered === undefined) statusUnavailableIds.push(id)\n    else if (!delivered) notDeliveredIds.push(id)\n  }\n  if (statusUnavailableIds.length > 0) {\n    out.push(\n      issue({\n        code: 'steer-ack-status-unavailable',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject,\n        claim: 'Some steer acknowledgements omit delivery status',\n        detail: `${statusUnavailableIds.length} id(s): ${idListDetail(statusUnavailableIds)}.`,\n        evidence: [\n          evidence(\n            `${prefix}/events/status-unavailable-request-ids`,\n            statusUnavailableIds.slice(0, MAX_EXAMPLES),\n          ),\n        ],\n        recommendedAction: 'Record delivered: true or delivered: false on each acknowledgement.',\n        metadata: { assessment: 'unavailable', unavailable_count: statusUnavailableIds.length },\n      }),\n    )\n  }\n  if (notDeliveredIds.length > 0) {\n    out.push(\n      issue({\n        code: 'steer-not-delivered',\n        area: 'control-integrity',\n        severity: 'high',\n        subject,\n        claim: 'Queued steer requests were acknowledged but not delivered',\n        detail: `${notDeliveredIds.length} id(s): ${idListDetail(notDeliveredIds)}.`,\n        evidence: [\n          evidence(\n            `${prefix}/events/not-delivered-request-ids`,\n            notDeliveredIds.slice(0, MAX_EXAMPLES),\n          ),\n        ],\n        recommendedAction:\n          'Retry or explicitly fail the control request instead of treating it as delivered.',\n      }),\n    )\n  }\n  return out\n}\n","import { evidence, issue, MAX_EXAMPLES } from './integrity-issues'\nimport type { SupervisorRunIntegrityIssue } from './integrity-types'\nimport type { SupervisorTreeFacts } from './source-facts'\nimport type { SupervisorRunSources, WorkerLogSource } from './types'\n\n/**\n * Transcript coverage a tree row cannot show: turns a closed worker dispatched whose record was\n * not retained, and native harness sessions the store has no copy of. Both are judged only for\n * workers with a terminal event, because a live worker's current turn and session are still\n * being written. A worker whose store records neither fact is not counted either way.\n */\nexport function transcriptIssues(\n  source: SupervisorRunSources,\n  facts: SupervisorTreeFacts,\n): SupervisorRunIntegrityIssue[] {\n  if (source.workers === null) return []\n  const closed = new Set(facts.closes.map((close) => close.id).filter((id) => id.length > 0))\n  const closedWorkers = source.workers.filter(\n    (worker): worker is WorkerLogSource & { workerId: string } =>\n      worker.workerId !== undefined && closed.has(worker.workerId),\n  )\n  const out: SupervisorRunIntegrityIssue[] = []\n\n  const lost = closedWorkers.flatMap((worker) => {\n    const turns = worker.turns\n    if (turns == null || turns.retained >= turns.dispatched) return []\n    return [{ id: worker.workerId, lost: turns.dispatched - turns.retained, turns }]\n  })\n  if (lost.length > 0) {\n    const lostTurns = lost.reduce((sum, row) => sum + row.lost, 0)\n    out.push(\n      issue({\n        code: 'transcript-incomplete',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: 'turn-transcripts',\n        claim: 'Some closed workers dispatched turns whose record was not retained',\n        detail: `${lost.length}/${closedWorkers.length} closed worker(s) lost ${lostTurns} dispatched turn record(s).`,\n        evidence: [\n          evidence('capture/lost-turns/count', lostTurns),\n          ...lost\n            .slice(0, MAX_EXAMPLES)\n            .map((row) => evidence(`workers/${encodeURIComponent(row.id)}/turns`, row.turns)),\n        ],\n        recommendedAction:\n          \"Persist each turn's output before the worker settles, including a turn that ends in failure.\",\n        metadata: {\n          assessment: 'unavailable',\n          unavailable_count: lost.length,\n          lost_turns: lostTurns,\n        },\n      }),\n    )\n  }\n\n  const unavailable = closedWorkers.flatMap((worker) =>\n    worker.nativeSession?.status === 'unavailable'\n      ? [{ id: worker.workerId, reason: worker.nativeSession.reason }]\n      : [],\n  )\n  if (unavailable.length > 0) {\n    const reasons: Record<string, number> = {}\n    for (const row of unavailable) reasons[row.reason] = (reasons[row.reason] ?? 0) + 1\n    out.push(\n      issue({\n        code: 'native-session-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: 'native-harness-sessions',\n        claim: 'Some closed workers have no retained native harness session',\n        detail: `${unavailable.length}/${closedWorkers.length} closed worker(s) have no native session; reasons: ${Object.entries(\n          reasons,\n        )\n          .map(([reason, count]) => `${reason} ${count}`)\n          .join(', ')}. What their harness-native subagents did is unobserved.`,\n        evidence: [\n          evidence('capture/native-sessions-unavailable/reasons', reasons),\n          ...unavailable\n            .slice(0, MAX_EXAMPLES)\n            .map((row) =>\n              evidence(`workers/${encodeURIComponent(row.id)}/nativeSession/reason`, row.reason),\n            ),\n        ],\n        recommendedAction:\n          'Capture the harness session store from the box before it is released, at the path the harness actually wrote.',\n        metadata: { assessment: 'unavailable', unavailable_count: unavailable.length, reasons },\n      }),\n    )\n  }\n  return out\n}\n","import { evidence, issue, MAX_EXAMPLES } from './integrity-issues'\nimport { steerIssues } from './integrity-steer'\nimport { transcriptIssues } from './integrity-transcript'\nimport type { SupervisorRunIntegrityIssue } from './integrity-types'\nimport type { SpawnRow, SupervisorTreeFacts, WorkerLogFacts } from './source-facts'\nimport type { SupervisorRunSources, SupervisorRunTree } from './types'\n\nfunction sourceIdentityIssues(facts: SupervisorTreeFacts): SupervisorRunIntegrityIssue[] {\n  const out: SupervisorRunIntegrityIssue[] = []\n  const malformedSpawns = facts.spawns.filter((spawn) => !spawn.valid)\n  if (facts.journalInvalidRows > 0 || malformedSpawns.length > 0) {\n    out.push(\n      issue({\n        code: 'source-row-malformed',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject: 'journal-rows',\n        claim: 'Some supervisor journal rows could not be interpreted',\n        detail: `${facts.journalInvalidRows} of ${facts.journalRows} row(s) could not be interpreted (${facts.journalMalformedJsonRows} were not JSON objects) and ${malformedSpawns.length} malformed spawn row(s) were excluded from structural conclusions.`,\n        evidence: [\n          evidence('journal/uninterpretable-rows/count', facts.journalInvalidRows),\n          evidence('journal/malformed-json-rows/count', facts.journalMalformedJsonRows),\n          evidence('journal/rows/count', facts.journalRows),\n          evidence('journal/dialect', facts.journalDialect),\n          ...malformedSpawns\n            .slice(0, MAX_EXAMPLES)\n            .map((spawn) =>\n              evidence(`journal/spawns/${spawn.sourceRow}/invalid-fields`, spawn.invalidFields),\n            ),\n        ],\n        recommendedAction:\n          'Repair the rows, or teach the parser the shape they are in, before using the run for structural analysis. A row nobody can read must never be silently absent from the tree.',\n        metadata: {\n          assessment: 'unavailable',\n          journal_rows: facts.journalRows,\n          uninterpretable_rows: facts.journalInvalidRows,\n          malformed_json_rows: facts.journalMalformedJsonRows,\n          malformed_spawn_rows: malformedSpawns.length,\n          journal_dialect: facts.journalDialect,\n        },\n      }),\n    )\n  }\n  const unidentifiedSpawns = malformedSpawns.filter((spawn) => spawn.id.length === 0)\n  const unidentifiedCloses = facts.closes.filter((close) => close.id.length === 0)\n  if (unidentifiedSpawns.length + unidentifiedCloses.length > 0) {\n    out.push(\n      issue({\n        code: 'source-event-identity-unavailable',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject: 'journal-event-identity',\n        claim: 'Some supervisor journal events have no usable invocation id',\n        detail: `${unidentifiedSpawns.length} spawn and ${unidentifiedCloses.length} terminal event(s) lack an id.`,\n        evidence: [\n          evidence('journal/unidentified-spawns/count', unidentifiedSpawns.length),\n          evidence('journal/unidentified-terminals/count', unidentifiedCloses.length),\n        ],\n        recommendedAction: 'Reject or repair control events that omit their stable invocation id.',\n        metadata: { assessment: 'unavailable', checks: ['journal-event-linkage'] },\n      }),\n    )\n  }\n\n  const spawnCounts = new Map<string, number>()\n  for (const spawn of facts.spawns) {\n    if (!spawn.valid || spawn.id.length === 0) continue\n    spawnCounts.set(spawn.id, (spawnCounts.get(spawn.id) ?? 0) + 1)\n  }\n  for (const [id, count] of spawnCounts) {\n    if (count < 2) continue\n    out.push(\n      issue({\n        code: 'duplicate-spawn',\n        area: 'control-integrity',\n        severity: 'critical',\n        subject: id,\n        claim: 'An invocation has more than one spawned control event',\n        detail: `${count} spawned events name invocation ${JSON.stringify(id)}.`,\n        evidence: [evidence(`journal/spawn-count/${encodeURIComponent(id)}`, count)],\n        recommendedAction: 'Make spawn event append idempotent.',\n      }),\n    )\n  }\n\n  const closeCounts = new Map<string, number>()\n  for (const close of facts.closes) {\n    if (close.id.length === 0) continue\n    closeCounts.set(close.id, (closeCounts.get(close.id) ?? 0) + 1)\n  }\n  const uncertainSpawnIds = new Set(\n    malformedSpawns.filter((spawn) => spawn.id.length > 0).map((spawn) => spawn.id),\n  )\n  if (unidentifiedSpawns.length === 0 && facts.journalInvalidRows === 0) {\n    const orphanCloses = new Map<string, Array<(typeof facts.closes)[number]>>()\n    for (const close of facts.closes) {\n      if (close.id.length === 0 || spawnCounts.has(close.id) || uncertainSpawnIds.has(close.id)) {\n        continue\n      }\n      const rows = orphanCloses.get(close.id) ?? []\n      rows.push(close)\n      orphanCloses.set(close.id, rows)\n    }\n    for (const [id, closes] of orphanCloses) {\n      out.push(\n        issue({\n          code: 'orphan-terminal',\n          area: 'control-integrity',\n          severity: 'critical',\n          subject: id,\n          claim: 'A terminal control event names an invocation that was never spawned',\n          detail: `${closes.length} terminal event(s) for ${JSON.stringify(id)} have no matching spawn.`,\n          evidence: [\n            evidence(`journal/closes/${encodeURIComponent(id)}/count`, closes.length),\n            ...closes\n              .slice(0, MAX_EXAMPLES)\n              .map((close, index) =>\n                evidence(`journal/closes/${encodeURIComponent(id)}/${index}`, close),\n              ),\n          ],\n          recommendedAction: 'Retain the matching spawn event or reject the orphan terminal event.',\n        }),\n      )\n    }\n  }\n  for (const [id, count] of closeCounts) {\n    if (count < 2) continue\n    out.push(\n      issue({\n        code: 'duplicate-terminal',\n        area: 'control-integrity',\n        severity: 'critical',\n        subject: id,\n        claim: 'An invocation has more than one terminal control event',\n        detail: `${count} settled/cancelled events name invocation ${JSON.stringify(id)}.`,\n        evidence: [evidence(`journal/terminal-count/${encodeURIComponent(id)}`, count)],\n        recommendedAction: 'Make terminal event append idempotent.',\n      }),\n    )\n  }\n  return out\n}\n\nexport interface JoinedWorker {\n  readonly spawn: SpawnRow\n  readonly facts: WorkerLogFacts\n}\n\nfunction joinWorkerControls(facts: SupervisorTreeFacts): {\n  joined: JoinedWorker[]\n  issue: SupervisorRunIntegrityIssue | null\n} {\n  const spawnsById = new Map<string, SpawnRow[]>()\n  const spawnsByLabel = new Map<string, SpawnRow[]>()\n  for (const spawn of facts.workerSpawns) {\n    const ids = spawnsById.get(spawn.id) ?? []\n    ids.push(spawn)\n    spawnsById.set(spawn.id, ids)\n    const labels = spawnsByLabel.get(spawn.label) ?? []\n    labels.push(spawn)\n    spawnsByLabel.set(spawn.label, labels)\n  }\n  const rowsWithoutIdByLabel = new Map<string, WorkerLogFacts[]>()\n  for (const row of facts.workerLogRows) {\n    if (row.workerId !== null && row.workerId.length > 0) continue\n    const matches = rowsWithoutIdByLabel.get(row.label) ?? []\n    matches.push(row)\n    rowsWithoutIdByLabel.set(row.label, matches)\n  }\n\n  const rowsBySpawn = new Map<string, WorkerLogFacts[]>()\n  const unmatchedRows: number[] = []\n  const ambiguousRows: number[] = []\n  for (const row of facts.workerLogRows) {\n    const matches =\n      row.workerId !== null && row.workerId.length > 0\n        ? (spawnsById.get(row.workerId) ?? [])\n        : (rowsWithoutIdByLabel.get(row.label)?.length ?? 0) === 1\n          ? (spawnsByLabel.get(row.label) ?? [])\n          : []\n    if (matches.length === 0) {\n      unmatchedRows.push(row.sourceIndex)\n      continue\n    }\n    if (matches.length !== 1) {\n      ambiguousRows.push(row.sourceIndex)\n      continue\n    }\n    const spawn = matches[0] as SpawnRow\n    const joined = rowsBySpawn.get(spawn.id) ?? []\n    joined.push(row)\n    rowsBySpawn.set(spawn.id, joined)\n  }\n\n  const joined: JoinedWorker[] = []\n  const missingSpawnIds: string[] = []\n  const duplicateSpawnIds: string[] = []\n  for (const spawn of facts.workerSpawns) {\n    if ((spawnsById.get(spawn.id)?.length ?? 0) !== 1) continue\n    const rows = rowsBySpawn.get(spawn.id) ?? []\n    if (rows.length === 0) missingSpawnIds.push(spawn.id)\n    else if (rows.length > 1) duplicateSpawnIds.push(spawn.id)\n    else joined.push({ spawn, facts: rows[0] as WorkerLogFacts })\n  }\n\n  if (\n    missingSpawnIds.length === 0 &&\n    duplicateSpawnIds.length === 0 &&\n    unmatchedRows.length === 0 &&\n    ambiguousRows.length === 0\n  ) {\n    return { joined, issue: null }\n  }\n  return {\n    joined,\n    issue: issue({\n      code: 'worker-control-join-unavailable',\n      area: 'capture-integrity',\n      severity: 'high',\n      subject: 'worker-control-join',\n      claim: 'Worker control-log coverage does not match recorded child invocations',\n      detail: `${missingSpawnIds.length} spawn(s) have no log, ${duplicateSpawnIds.length} have duplicate logs, ${unmatchedRows.length} log row(s) match no spawn, and ${ambiguousRows.length} row(s) are ambiguous.`,\n      evidence: [\n        evidence('workers/join/missing-spawn-ids', missingSpawnIds.slice(0, MAX_EXAMPLES)),\n        evidence('workers/join/duplicate-spawn-ids', duplicateSpawnIds.slice(0, MAX_EXAMPLES)),\n        evidence('workers/join/unmatched-source-rows', unmatchedRows.slice(0, MAX_EXAMPLES)),\n        evidence('workers/join/ambiguous-source-rows', ambiguousRows.slice(0, MAX_EXAMPLES)),\n      ],\n      recommendedAction:\n        'Retain exactly one worker control row with workerId for every spawned invocation.',\n      metadata: {\n        assessment: 'unavailable',\n        missing_count: missingSpawnIds.length,\n        duplicate_count: duplicateSpawnIds.length,\n        unmatched_count: unmatchedRows.length,\n        ambiguous_count: ambiguousRows.length,\n      },\n    }),\n  }\n}\n\nexport function sourceIssues(\n  source: SupervisorRunSources,\n  facts: SupervisorTreeFacts,\n  tree: SupervisorRunTree,\n): SupervisorRunIntegrityIssue[] {\n  const out = sourceIdentityIssues(facts)\n  if (source.workers === null) {\n    const reason = source.workersMissingReason ?? 'worker control-log store was not captured'\n    out.push(\n      issue({\n        code: 'worker-controls-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: 'steer-delivery',\n        claim:\n          'Steer delivery integrity is unavailable because worker control logs were not captured',\n        detail: reason,\n        evidence: [evidence('sources/workers', null)],\n        recommendedAction: 'Retain each worker inbox and event stream.',\n        metadata: { assessment: 'unavailable', reason },\n      }),\n    )\n    return out\n  }\n\n  out.push(...transcriptIssues(source, facts))\n  const joined = joinWorkerControls(facts)\n  if (joined.issue !== null) out.push(joined.issue)\n  const rootCompleted =\n    tree.rootId !== null &&\n    tree.nodes.filter((node) => node.rollout_id === tree.rootId).length === 1 &&\n    tree.nodes.find((node) => node.rollout_id === tree.rootId)?.outcome.is_completed === true\n  for (const row of joined.joined) out.push(...steerIssues(row, rootCompleted))\n  return out\n}\n","import { validateRolloutLine } from '../rollout/schema'\nimport { evidence, issue, MAX_EXAMPLES } from './integrity-issues'\nimport type { SupervisorRunIntegrityEvidence, SupervisorRunIntegrityIssue } from './integrity-types'\nimport { nonEmptyString } from './source-facts'\nimport type { SupervisorRunTree } from './types'\n\nimport { isRecord } from '../llm-client/json'\ninterface NodeRecord {\n  readonly index: number\n  readonly raw: Record<string, unknown>\n  readonly errors: readonly string[]\n  readonly id: string | null\n  readonly parent: string | null | undefined\n  readonly runId: string | null\n  readonly role: string | null\n  readonly messages: readonly unknown[] | null\n  /** The row's declared transcript artifact; null when the source retained none. */\n  readonly transcriptRef: string | null\n  readonly profileId: string | null\n  readonly completed: boolean | null\n  readonly terminal: boolean | null\n}\n\nfunction parentValue(raw: Record<string, unknown>): string | null | undefined {\n  if (raw.parent_rollout_id === null) return null\n  return nonEmptyString(raw.parent_rollout_id) ?? undefined\n}\n\nfunction terminalValue(outcome: Record<string, unknown> | null): boolean | null {\n  if (outcome === null) return null\n  if (typeof outcome.is_completed !== 'boolean' || typeof outcome.is_truncated !== 'boolean') {\n    return null\n  }\n  if (outcome.error !== null && typeof outcome.error !== 'string') return null\n  return outcome.is_completed || outcome.is_truncated || outcome.error !== null\n}\n\nfunction nodeRecord(value: unknown, index: number): NodeRecord {\n  const raw = isRecord(value) ? value : {}\n  const policy = isRecord(raw.policy) ? raw.policy : null\n  const outcome = isRecord(raw.outcome) ? raw.outcome : null\n  const artifacts = isRecord(raw.artifacts) ? raw.artifacts : null\n  return {\n    index,\n    raw,\n    errors: validateRolloutLine(value),\n    id: nonEmptyString(raw.rollout_id),\n    parent: parentValue(raw),\n    runId: nonEmptyString(raw.run_id),\n    role: nonEmptyString(raw.role),\n    messages: Array.isArray(raw.messages) ? raw.messages : null,\n    transcriptRef: artifacts === null ? null : nonEmptyString(artifacts.transcript_ref),\n    profileId: policy === null ? null : nonEmptyString(policy.agent_profile_cell_id),\n    completed:\n      outcome !== null && typeof outcome.is_completed === 'boolean' ? outcome.is_completed : null,\n    terminal: terminalValue(outcome),\n  }\n}\n\nfunction metric(\n  record: NodeRecord,\n  keys: readonly string[],\n): { key: string; value: number } | null {\n  const outcome = isRecord(record.raw.outcome) ? record.raw.outcome : null\n  const metrics = outcome !== null && isRecord(outcome.metrics) ? outcome.metrics : null\n  if (metrics === null) return null\n  for (const key of keys) {\n    const value = metrics[key]\n    if (typeof value === 'number' && Number.isFinite(value)) return { key, value }\n  }\n  return null\n}\n\nfunction nodeEvidence(\n  record: NodeRecord,\n  path: string,\n  value: unknown,\n): SupervisorRunIntegrityEvidence {\n  const key = record.id ?? `index-${record.index}`\n  return evidence(`nodes/${encodeURIComponent(key)}/${path}`, value)\n}\n\nfunction unavailableNodeChecks(record: NodeRecord): string[] {\n  const checks: string[] = []\n  if (record.id === null) checks.push('identity', 'root-membership', 'parent-link', 'cycle')\n  if (record.parent === undefined) checks.push('parent-link', 'cycle')\n  if (record.runId === null) checks.push('cross-run-parent')\n  if (record.role === null) checks.push('root-role')\n  if (!isRecord(record.raw.outcome)) checks.push('timing', 'terminal-state')\n  return [...new Set(checks)]\n}\n\ninterface TreeIssueUncertainty {\n  readonly unknownIdentityRows?: number\n  readonly uncertainIds?: ReadonlySet<string>\n}\n\nexport function treeIssues(\n  tree: SupervisorRunTree,\n  uncertainty: TreeIssueUncertainty = {},\n): SupervisorRunIntegrityIssue[] {\n  const out: SupervisorRunIntegrityIssue[] = []\n  const records = (tree.nodes as readonly unknown[]).map(nodeRecord)\n  const malformedSourceRows = tree.gaps\n    .filter((gap) => gap.code === 'source-row-malformed')\n    .reduce((count, gap) => count + (gap.count ?? 1), 0)\n\n  for (const record of records) {\n    if (record.errors.length === 0) continue\n    out.push(\n      issue({\n        code: 'node-schema-invalid',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject: record.id ?? `node-${record.index}`,\n        claim: 'A supervisor-tree node fails canonical rollout validation',\n        detail: record.errors.join('; '),\n        evidence: [evidence(`nodes/${record.index}/validation`, record.errors)],\n        recommendedAction:\n          'Fix the producer so every node validates as the existing tangle.rollout.v1 shape before analysis.',\n        metadata: { validation_errors: record.errors },\n      }),\n    )\n    const unavailableChecks = unavailableNodeChecks(record)\n    if (unavailableChecks.length === 0) continue\n    out.push(\n      issue({\n        code: 'node-checks-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: record.id ?? `node-${record.index}`,\n        claim: 'Some integrity checks are unavailable for a malformed supervisor-tree node',\n        detail: `Unavailable checks: ${unavailableChecks.join(', ')}.`,\n        evidence: [evidence(`nodes/${record.index}/unavailable-checks`, unavailableChecks)],\n        recommendedAction:\n          'Retain the named identity and relationship fields with their canonical types.',\n        metadata: { assessment: 'unavailable', checks: unavailableChecks },\n      }),\n    )\n  }\n\n  const byId = new Map<string, NodeRecord[]>()\n  for (const record of records) {\n    if (record.id === null) continue\n    const matches = byId.get(record.id) ?? []\n    matches.push(record)\n    byId.set(record.id, matches)\n  }\n\n  for (const [rolloutId, matches] of byId) {\n    if (matches.length < 2) continue\n    out.push(\n      issue({\n        code: 'duplicate-rollout-id',\n        area: 'control-integrity',\n        severity: 'critical',\n        subject: rolloutId,\n        claim: 'A rollout id is duplicated within one supervisor tree',\n        detail: `${matches.length} nodes claim rollout_id ${JSON.stringify(rolloutId)}, so references are ambiguous.`,\n        evidence: [\n          evidence(`duplicates/${encodeURIComponent(rolloutId)}/count`, matches.length),\n          ...matches.slice(0, MAX_EXAMPLES).map((record) =>\n            evidence(`nodes/${record.index}/identity`, {\n              rollout_id: record.id,\n              parent_rollout_id: record.parent,\n              role: record.role,\n            }),\n          ),\n        ],\n        recommendedAction: 'Give every invocation one stable rollout id and regenerate the tree.',\n      }),\n    )\n  }\n\n  const unknownIdentityRows =\n    records.filter((record) => record.id === null).length +\n    Math.max(malformedSourceRows, uncertainty.unknownIdentityRows ?? 0)\n  const unique = records.filter(\n    (record): record is NodeRecord & { readonly id: string } =>\n      record.id !== null && byId.get(record.id)?.length === 1,\n  )\n\n  let root: NodeRecord | undefined\n  if (tree.rootId === null) {\n    out.push(\n      issue({\n        code: 'root-unavailable',\n        area: 'capture-integrity',\n        severity: 'high',\n        subject: 'tree-root',\n        claim: 'The supervisor-tree root is unavailable',\n        detail: `rootId is null while ${records.length} node row(s) were captured.`,\n        evidence: [evidence('rootId', null)],\n        recommendedAction: 'Capture the root spawned event and preserve its rollout id as rootId.',\n        metadata: { assessment: 'unavailable', node_rows: records.length },\n      }),\n    )\n  } else {\n    const rootRows = byId.get(tree.rootId) ?? []\n    if (rootRows.length === 1) {\n      root = rootRows[0]\n    } else if (rootRows.length === 0 && unknownIdentityRows > 0) {\n      out.push(\n        issue({\n          code: 'node-checks-unavailable',\n          area: 'capture-integrity',\n          severity: 'high',\n          subject: tree.rootId,\n          claim: 'Root membership is unavailable because a malformed node lost its rollout id',\n          detail: `${unknownIdentityRows} malformed node row(s) have no usable rollout_id, so absence of root ${JSON.stringify(tree.rootId)} cannot be established.`,\n          evidence: [evidence('rootId', tree.rootId)],\n          recommendedAction: 'Retain rollout_id even when another node field fails validation.',\n          metadata: { assessment: 'unavailable', checks: ['root-membership'] },\n        }),\n      )\n    } else if (rootRows.length === 0) {\n      out.push(\n        issue({\n          code: 'declared-root-missing',\n          area: 'control-integrity',\n          severity: 'critical',\n          subject: tree.rootId,\n          claim: 'The declared supervisor-tree root has no matching invocation node',\n          detail: `rootId ${JSON.stringify(tree.rootId)} is absent from ${records.length} node row(s).`,\n          evidence: [evidence('rootId', tree.rootId)],\n          recommendedAction: 'Restore the root rollout row or correct rootId.',\n        }),\n      )\n    }\n  }\n\n  if (root !== undefined) {\n    if (root.parent !== undefined && root.parent !== null) {\n      out.push(\n        issue({\n          code: 'root-has-parent',\n          area: 'control-integrity',\n          severity: 'critical',\n          subject: root.id ?? tree.rootId ?? 'tree-root',\n          claim: 'The declared supervisor-tree root has a parent',\n          detail: `Root points to parent ${JSON.stringify(root.parent)}.`,\n          evidence: [nodeEvidence(root, 'parent_rollout_id', root.parent)],\n          recommendedAction: 'Record the root with parent_rollout_id null.',\n        }),\n      )\n    }\n    if (root.role !== null && root.role !== 'supervisor') {\n      out.push(\n        issue({\n          code: 'root-role-invalid',\n          area: 'control-integrity',\n          severity: 'high',\n          subject: root.id ?? tree.rootId ?? 'tree-root',\n          claim: 'The declared supervisor-tree root is not labeled as a supervisor',\n          detail: `Root has role ${JSON.stringify(root.role)}.`,\n          evidence: [nodeEvidence(root, 'role', root.role)],\n          recommendedAction:\n            'Preserve the root invocation role as supervisor when minting rollout rows.',\n        }),\n      )\n    }\n  }\n\n  for (const record of unique) {\n    if (record.parent === undefined) continue\n    if (record.parent === null) {\n      if (record.id !== tree.rootId) {\n        out.push(\n          issue({\n            code: 'detached-node',\n            area: 'control-integrity',\n            severity: 'critical',\n            subject: record.id,\n            claim: 'A non-root invocation is recorded as a detached parentless root',\n            detail: `Node ${JSON.stringify(record.id)} is parentless while rootId is ${JSON.stringify(tree.rootId)}.`,\n            evidence: [\n              nodeEvidence(record, 'parent_rollout_id', null),\n              evidence('rootId', tree.rootId),\n            ],\n            recommendedAction:\n              'Attach the invocation to its spawning parent or record a separate run.',\n          }),\n        )\n      }\n      continue\n    }\n\n    const parentRows = byId.get(record.parent) ?? []\n    if (parentRows.length === 0) {\n      if (unknownIdentityRows > 0 || uncertainty.uncertainIds?.has(record.parent) === true) {\n        out.push(\n          issue({\n            code: 'node-checks-unavailable',\n            area: 'capture-integrity',\n            severity: 'high',\n            subject: record.id,\n            claim: 'Parent membership is unavailable because a malformed node lost its rollout id',\n            detail:\n              uncertainty.uncertainIds?.has(record.parent) === true\n                ? `Parent ${JSON.stringify(record.parent)} appears only in a malformed source row, so its absence cannot be established.`\n                : `Parent ${JSON.stringify(record.parent)} cannot be matched while ${unknownIdentityRows} row(s) have no usable rollout_id.`,\n            evidence: [nodeEvidence(record, 'parent_rollout_id', record.parent)],\n            recommendedAction: 'Retain rollout_id on every row before assessing detached children.',\n            metadata: { assessment: 'unavailable', checks: ['parent-membership'] },\n          }),\n        )\n      } else {\n        out.push(\n          issue({\n            code: 'parent-missing',\n            area: 'control-integrity',\n            severity: 'critical',\n            subject: record.id,\n            claim: 'An invocation points to a parent absent from the supervisor tree',\n            detail: `Node ${JSON.stringify(record.id)} names missing parent ${JSON.stringify(record.parent)}.`,\n            evidence: [nodeEvidence(record, 'parent_rollout_id', record.parent)],\n            recommendedAction: 'Retain the parent invocation or remove the dangling edge.',\n          }),\n        )\n      }\n      continue\n    }\n    if (parentRows.length !== 1) continue\n    const parent = parentRows[0] as NodeRecord\n\n    if (record.runId !== null && parent.runId !== null && record.runId !== parent.runId) {\n      out.push(\n        issue({\n          code: 'cross-run-parent',\n          area: 'control-integrity',\n          severity: 'critical',\n          subject: record.id,\n          claim: 'A parent-child edge crosses supervisor-run identities',\n          detail: `Child run_id ${JSON.stringify(record.runId)} differs from parent run_id ${JSON.stringify(parent.runId)}.`,\n          evidence: [\n            nodeEvidence(record, 'run_id', record.runId),\n            nodeEvidence(parent, 'run_id', parent.runId),\n          ],\n          recommendedAction:\n            'Keep one run_id across a supervision tree or remove the cross-run edge.',\n        }),\n      )\n    }\n\n    const childStart = metric(record, ['spawned_at', 'started_at'])\n    const parentStart = metric(parent, ['spawned_at', 'started_at'])\n    if (childStart !== null && parentStart !== null && childStart.value < parentStart.value) {\n      out.push(\n        issue({\n          code: 'child-before-parent',\n          area: 'control-integrity',\n          severity: 'high',\n          subject: record.id,\n          claim: 'A child invocation is timestamped before its parent started',\n          detail: `Child ${childStart.key} ${childStart.value} precedes parent ${parentStart.key} ${parentStart.value}.`,\n          evidence: [\n            nodeEvidence(record, `outcome.metrics.${childStart.key}`, childStart.value),\n            nodeEvidence(parent, `outcome.metrics.${parentStart.key}`, parentStart.value),\n          ],\n          recommendedAction: 'Use one ordered clock for spawn events or retain clock metadata.',\n        }),\n      )\n    }\n\n    const parentClose = metric(parent, ['settled_at', 'completed_at', 'finished_at'])\n    if (childStart !== null && parentClose !== null && childStart.value > parentClose.value) {\n      out.push(\n        issue({\n          code: 'child-after-parent-close',\n          area: 'control-integrity',\n          severity: 'critical',\n          subject: record.id,\n          claim: 'A child invocation is timestamped after its parent closed',\n          detail: `Child ${childStart.key} ${childStart.value} follows parent ${parentClose.key} ${parentClose.value}.`,\n          evidence: [\n            nodeEvidence(record, `outcome.metrics.${childStart.key}`, childStart.value),\n            nodeEvidence(parent, `outcome.metrics.${parentClose.key}`, parentClose.value),\n          ],\n          recommendedAction:\n            'Correct the causal timestamps or attach the child to its actual spawner.',\n        }),\n      )\n    }\n  }\n\n  for (const record of unique) {\n    const start = metric(record, ['spawned_at', 'started_at'])\n    const close = metric(record, ['settled_at', 'completed_at', 'finished_at'])\n    if (start === null || close === null || close.value >= start.value) continue\n    out.push(\n      issue({\n        code: 'close-before-start',\n        area: 'control-integrity',\n        severity: 'high',\n        subject: record.id,\n        claim: 'An invocation is timestamped as closing before it started',\n        detail: `${start.key} is ${start.value} and ${close.key} is ${close.value}.`,\n        evidence: [\n          nodeEvidence(record, `outcome.metrics.${start.key}`, start.value),\n          nodeEvidence(record, `outcome.metrics.${close.key}`, close.value),\n        ],\n        recommendedAction: 'Correct the event ordering or retain clock-domain metadata.',\n      }),\n    )\n  }\n\n  const emittedCycles = new Set<string>()\n  const resolved = new Set<string>()\n  for (const start of unique) {\n    if (resolved.has(start.id)) continue\n    const path: string[] = []\n    const positions = new Map<string, number>()\n    let current: string | null = start.id\n    while (current !== null) {\n      if (resolved.has(current)) break\n      const position = positions.get(current)\n      if (position !== undefined) {\n        const cycle = path.slice(position)\n        const key = [...cycle].sort().join('\\u0000')\n        if (!emittedCycles.has(key)) {\n          emittedCycles.add(key)\n          out.push(\n            issue({\n              code: 'parent-cycle',\n              area: 'control-integrity',\n              severity: 'critical',\n              subject: [...cycle].sort()[0] ?? 'cycle',\n              claim: 'The supervisor tree contains a parent cycle',\n              detail: `${cycle.join(' -> ')} -> ${cycle[0]}`,\n              evidence: cycle.slice(0, MAX_EXAMPLES).flatMap((id) => {\n                const rows = byId.get(id)\n                const record = rows?.length === 1 ? rows[0] : undefined\n                return record === undefined\n                  ? []\n                  : [nodeEvidence(record, 'parent_rollout_id', record.parent)]\n              }),\n              recommendedAction:\n                'Correct parent ids at ingestion; a cyclic graph is not a run tree.',\n            }),\n          )\n        }\n        break\n      }\n      positions.set(current, path.length)\n      path.push(current)\n      const rows = byId.get(current)\n      if (rows?.length !== 1) break\n      const parent = rows[0]?.parent\n      if (parent === undefined) break\n      current = parent\n    }\n    for (const id of path) resolved.add(id)\n  }\n\n  if (root?.completed === true) {\n    const missingTerminal = unique.filter(\n      (record) => record.id !== root?.id && record.terminal === false,\n    )\n    if (missingTerminal.length > 0) {\n      out.push(\n        issue({\n          code: 'child-terminal-unavailable',\n          area: 'capture-integrity',\n          severity: 'high',\n          subject: 'child-terminal-outcomes',\n          claim: 'A completed supervisor run has children with no captured terminal outcome',\n          detail: `${missingTerminal.length}/${Math.max(0, unique.length - 1)} child node(s) are neither completed, truncated, nor errored.`,\n          evidence: [\n            evidence('children/missing-terminal/count', missingTerminal.length),\n            ...missingTerminal\n              .slice(0, MAX_EXAMPLES)\n              .map((record) => nodeEvidence(record, 'outcome', record.raw.outcome)),\n          ],\n          recommendedAction: 'Retain each child settlement or cancellation event.',\n          metadata: { assessment: 'unavailable', unavailable_count: missingTerminal.length },\n        }),\n      )\n    }\n  }\n\n  // A row whose messages are not inlined still has its transcript when the source retained it\n  // by reference; only a row with neither is missing one.\n  const uninlined = records.filter((record) => record.messages?.length === 0)\n  const missingTranscripts = uninlined.filter((record) => record.transcriptRef === null)\n  if (missingTranscripts.length > 0) {\n    out.push(\n      issue({\n        code: 'transcript-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: 'decision-transcripts',\n        claim: 'Decision transcripts are unavailable for some supervisor-tree invocations',\n        detail: `${missingTranscripts.length}/${records.length} node row(s) have no inlined messages and no retained transcript; ${uninlined.length - missingTranscripts.length} more are retained by reference only.`,\n        evidence: [\n          evidence('capture/missing-transcripts/count', missingTranscripts.length),\n          ...missingTranscripts\n            .slice(0, MAX_EXAMPLES)\n            .map((record) => nodeEvidence(record, 'artifacts/transcript_ref', null)),\n        ],\n        recommendedAction:\n          'Retain each invocation transcript and name it in artifacts.transcript_ref.',\n        metadata: {\n          assessment: 'unavailable',\n          unavailable_count: missingTranscripts.length,\n          retained_by_reference_count: uninlined.length - missingTranscripts.length,\n        },\n      }),\n    )\n  }\n\n  const missingProfiles = records.filter((record) => record.profileId === null)\n  if (missingProfiles.length > 0) {\n    out.push(\n      issue({\n        code: 'profile-id-unavailable',\n        area: 'capture-integrity',\n        severity: 'medium',\n        subject: 'agent-profile-identity',\n        claim:\n          'Canonical agent-profile identity is unavailable for some supervisor-tree invocations',\n        detail: `${missingProfiles.length}/${records.length} node row(s) omit policy.agent_profile_cell_id.`,\n        evidence: [\n          evidence('capture/missing-agent-profile-cell-id/count', missingProfiles.length),\n          ...missingProfiles\n            .slice(0, MAX_EXAMPLES)\n            .map((record) => nodeEvidence(record, 'policy.agent_profile_cell_id', null)),\n        ],\n        recommendedAction:\n          'Record policy.agent_profile_cell_id on every invocation at dispatch time.',\n        metadata: { assessment: 'unavailable', unavailable_count: missingProfiles.length },\n      }),\n    )\n  }\n\n  return out\n}\n","import type { SupervisorRunTree } from './types'\n\nexport const SUPERVISOR_RUN_INTEGRITY_SCHEMA = 'tangle.supervisor-run-integrity@1'\n\nexport type SupervisorRunIntegritySeverity = 'critical' | 'high' | 'medium' | 'low' | 'info'\n\nexport type SupervisorRunSourceOnlyCheckCode =\n  | 'journal-event-cardinality'\n  | 'worker-control-join'\n  | 'steer-ack-correlation'\n\nexport type SupervisorRunIntegrityIssueCode =\n  | 'source-checks-unavailable'\n  | 'node-schema-invalid'\n  | 'node-checks-unavailable'\n  | 'root-unavailable'\n  | 'duplicate-rollout-id'\n  | 'declared-root-missing'\n  | 'root-has-parent'\n  | 'root-role-invalid'\n  | 'detached-node'\n  | 'parent-missing'\n  | 'cross-run-parent'\n  | 'child-before-parent'\n  | 'child-after-parent-close'\n  | 'close-before-start'\n  | 'parent-cycle'\n  | 'child-terminal-unavailable'\n  | 'transcript-unavailable'\n  | 'transcript-incomplete'\n  | 'native-session-unavailable'\n  | 'profile-id-unavailable'\n  | 'source-row-malformed'\n  | 'source-event-identity-unavailable'\n  | 'duplicate-spawn'\n  | 'orphan-terminal'\n  | 'duplicate-terminal'\n  | 'worker-controls-unavailable'\n  | 'worker-control-join-unavailable'\n  | 'steer-request-id-unavailable'\n  | 'steer-ack-id-unavailable'\n  | 'steer-ack-status-unavailable'\n  | 'duplicate-steer-request-id'\n  | 'missing-steer-ack'\n  | 'duplicate-steer-ack'\n  | 'unknown-steer-ack'\n  | 'steer-not-delivered'\n\nexport interface SupervisorRunIntegrityEvidence {\n  readonly path: string\n  readonly value: unknown\n}\n\nexport interface SupervisorRunIntegrityIssue {\n  readonly code: SupervisorRunIntegrityIssueCode\n  readonly area: 'control-integrity' | 'capture-integrity'\n  readonly severity: SupervisorRunIntegritySeverity\n  readonly subject: string\n  readonly claim: string\n  readonly detail: string\n  readonly evidence: readonly SupervisorRunIntegrityEvidence[]\n  readonly recommendedAction: string\n  readonly metadata?: Readonly<Record<string, unknown>>\n}\n\nexport interface SupervisorRunIntegrityReport {\n  readonly schema: typeof SUPERVISOR_RUN_INTEGRITY_SCHEMA\n  readonly runRef: string\n  readonly input: 'sources' | 'tree'\n  readonly tree: SupervisorRunTree\n  readonly issues: readonly SupervisorRunIntegrityIssue[]\n}\n\nexport interface SupervisorRunIntegrityOptions {\n  /** Pins rollout provenance when source input must be projected into a tree. */\n  readonly capturedAt?: string\n}\n","/**\n * The supervision tree as `tangle.rollout.v1` rows.\n *\n * A supervisor run IS a tree of rollouts, so its nodes are not a new shape:\n * the root becomes one `RolloutLine` with `role: 'supervisor'`, and every\n * spawned invocation keeps its explicit supervisor/worker role with\n * `parent_rollout_id` pointing at its spawner. The rows append to the same\n * ledger as solo-agent rollouts and join to them with the same keys.\n *\n * What the journal CANNOT supply is the transcript: a worker's messages live\n * in its harness store (opencode sqlite, Claude Code jsonl), which the\n * `src/rollout/readers/*` intake readers own. Rows minted here are therefore\n * GAP lines (`messages: []`, `provenance.gap` set) carrying identity,\n * structure, outcome and cost. Runtime workspace receipts remain attached in\n * `provenance.workspace_captures`; their archives stay at the recorded refs.\n * Hydrating messages is the intake readers' job, keyed on `artifacts.transcript_ref`.\n *\n * Timing lives in `outcome.metrics` (`spawned_at` / `settled_at` / `wall_ms`)\n * rather than a schema field: `tangle.rollout.v1` describes ONE invocation,\n * and the inter-invocation event timeline — which is what waves, concurrency,\n * idle and utilization are computed from — is a property of the journal, not\n * of any single row. The analyzer reads that timeline; these rows carry the\n * per-node facts.\n */\n\nimport { unscreenedRewardFields } from '../rollout/reward'\nimport {\n  isRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutLine,\n  type RolloutSplit,\n} from '../rollout/schema'\nimport { asRecord, parseJsonRecord, parseSupervisorTree, type SupervisorTreeFacts } from './source-facts'\nimport { readTerminalRecord } from './terminal-record'\nimport {\n  isUnavailable,\n  type SupervisorRunSources,\n  type SupervisorRunTree,\n  type SupervisorRunTreeGap,\n  type WorkerLogSource,\n} from './types'\n\nexport interface SupervisorRolloutOptions {\n  /** Benchmark/suite id for `task.suite`. Defaults to `'supervisor-run'`. */\n  readonly suite?: string\n  /** `task.split`. Defaults to `'search'` (the trainable pool). */\n  readonly split?: RolloutSplit\n  /** Replicate index. Defaults to 0. */\n  readonly rep?: number\n  /** Sampling seed the campaign pinned. Defaults to null (not recorded). */\n  readonly seed?: number | null\n  /** `run_id` for every node. Defaults to the supervisor root id, else `runRef`. */\n  readonly runId?: string\n  /** Harness that drove the supervisor. */\n  readonly supervisorHarness?: string | null\n  /** Harness that drove the workers. */\n  readonly workerHarness?: string | null\n  /** Model the supervisor ran on. */\n  readonly supervisorModel?: string | null\n  /** Model the workers ran on. */\n  readonly workerModel?: string | null\n  readonly experimentId?: string | null\n  readonly candidateId?: string | null\n  readonly generation?: number | null\n  readonly candidateIndex?: number | null\n  /** Pins `provenance.captured_at`; defaults to now. */\n  readonly capturedAt?: string\n}\n\nconst EMPTY_COST = {\n  usd: null,\n  tokens_in: null,\n  tokens_out: null,\n  tokens_reasoning: null,\n  cache_read: null,\n  cache_write: null,\n  wall_s: null,\n} as const\n\nfunction hasWorkerId(\n  worker: WorkerLogSource,\n): worker is WorkerLogSource & { readonly workerId: string } {\n  return worker.workerId !== undefined\n}\n\n/**\n * Mint the supervision tree as rollout rows. Returns the rows plus the gaps\n * that made any of them incomplete — same unavailable-vs-zero discipline as\n * the report: a row with no transcript says WHY, it never pretends to be empty.\n */\nexport function supervisorRunRolloutLines(\n  src: SupervisorRunSources,\n  opts: SupervisorRolloutOptions = {},\n): SupervisorRunTree {\n  return supervisorRunRolloutLinesFromFacts(src, parseSupervisorTree(src), opts)\n}\n\n/** Mint rollout rows from an already parsed source without reading its JSONL again. */\nexport function supervisorRunRolloutLinesFromFacts(\n  src: SupervisorRunSources,\n  tree: SupervisorTreeFacts,\n  opts: SupervisorRolloutOptions = {},\n): SupervisorRunTree {\n  const gaps: SupervisorRunTreeGap[] = []\n  if (src.journal === null) {\n    gaps.push({\n      code: 'journal-unavailable',\n      message: `${src.supRunDir === null ? 'no supervisor run dir' : 'journal absent'}; no nodes recoverable`,\n    })\n    return { rootId: null, nodes: [], gaps }\n  }\n  // `journalInvalidRows` covers rows the parser could not interpret at all, including JSON\n  // objects in a shape it does not recognize — so a journal it read but understood none of\n  // reports an explicit gap instead of an empty tree.\n  const malformedSourceRows =\n    tree.journalInvalidRows + tree.spawns.filter((spawn) => !spawn.valid).length\n  if (malformedSourceRows > 0) {\n    gaps.push({\n      code: 'source-row-malformed',\n      message: `${malformedSourceRows} of ${tree.journalRows} journal row(s) were unusable and excluded from the tree`,\n      count: malformedSourceRows,\n    })\n  }\n\n  const state = tree.state\n  const result = parseJsonRecord(src.result)\n  const judge = parseJsonRecord(src.judge)\n  const stateResult = asRecord(state?.result)\n  // One derivation with the analyzer, so the root row and the report never\n  // disagree about which record the status came from.\n  const terminal = readTerminalRecord({\n    state,\n    result,\n    failure: src.failure === undefined ? undefined : parseJsonRecord(src.failure),\n  })\n\n  const rootId = tree.rootId\n  const runId = opts.runId ?? rootId ?? src.runRef\n  const suite = opts.suite ?? 'supervisor-run'\n  const instanceId = src.instanceId ?? src.runRef\n  const split: RolloutSplit = opts.split ?? 'search'\n  const capturedAt = opts.capturedAt ?? new Date().toISOString()\n\n  const base = {\n    schema: ROLLOUT_SCHEMA,\n    run_id: runId,\n    experiment_id: opts.experimentId ?? null,\n    candidate_id: opts.candidateId ?? null,\n    generation: opts.generation ?? null,\n    candidate_index: opts.candidateIndex ?? null,\n    task: {\n      suite,\n      instance_id: instanceId,\n      split,\n      seed: opts.seed ?? null,\n      rep: opts.rep ?? 0,\n    },\n    messages: [] as RolloutLine['messages'],\n    tool_defs: [] as RolloutLine['tool_defs'],\n  } satisfies Partial<RolloutLine> & Record<string, unknown>\n\n  const nodes: RolloutLine[] = []\n  const noteCaptureGaps = (\n    owner: string,\n    nodeId: string,\n    captures: SupervisorRunSources['rootWorkspaceCaptures'],\n  ): string | null => {\n    if (captures === null || captures?.length === 0) {\n      gaps.push({\n        code: 'workspace-capture-unavailable',\n        message: `${owner} has no retained output capture evidence`,\n        nodeId,\n      })\n      return 'workspace capture evidence unavailable'\n    }\n    let incomplete = false\n    for (const [index, capture] of captures?.entries() ?? []) {\n      const reasons = [\n        capture.projectionGap,\n        capture.coverageComplete === false\n          ? (capture.incompleteReason ?? 'provider reported incomplete coverage')\n          : capture.coverageComplete === null\n            ? 'capture coverage was not recorded'\n            : null,\n      ].filter((reason): reason is string => reason !== null)\n      if (reasons.length > 0) {\n        incomplete = true\n        gaps.push({\n          code: 'workspace-capture-incomplete',\n          message: `${owner} result ${index + 1}: ${reasons.join('; ')}`,\n          nodeId,\n        })\n      }\n    }\n    return incomplete ? 'workspace capture evidence incomplete' : null\n  }\n\n  // ── root: the supervisor invocation ────────────────────────────────────\n  if (rootId !== null) {\n    const rootSpawn = tree.spawns.find((spawn) => spawn.valid && spawn.id === rootId)\n    const judgeResolved = typeof judge?.resolved === 'boolean' ? judge.resolved : null\n    const judgeScore = typeof judge?.score === 'number' ? judge.score : null\n    const reward = judgeScore ?? (judgeResolved === null ? null : judgeResolved ? 1 : 0)\n    if (reward === null) {\n      gaps.push({\n        code: 'root-reward-unavailable',\n        message: 'no judge verdict for this run',\n        nodeId: rootId,\n      })\n    }\n    const wallMs =\n      tree.startedAt !== null && tree.completedAt !== null && tree.completedAt >= tree.startedAt\n        ? tree.completedAt - tree.startedAt\n        : null\n    const captures = src.rootWorkspaceCaptures\n    const captureGap = noteCaptureGaps(`root ${JSON.stringify(rootId)}`, rootId, captures)\n    nodes.push({\n      ...base,\n      rollout_id: rootId,\n      parent_rollout_id: null,\n      role: rootSpawn?.role ?? 'supervisor',\n      policy: {\n        harness: opts.supervisorHarness ?? null,\n        harness_version: null,\n        model: opts.supervisorModel ?? null,\n        provider: null,\n        profile_commit: null,\n        agent_profile_cell_id: rootSpawn?.profileDigest ?? null,\n        sampling: null,\n      },\n      outcome: {\n        // `reward` and `realness_gated` are written by one call, in the module\n        // that owns the gate. This is the SECOND producer of rollout rewards —\n        // the judge verdict in the supervision run dir, not `mintRolloutRows` —\n        // and it wrote `reward` by hand while never stating the flag, so\n        // `isLineRealnessGated` was structurally false for every supervisor and\n        // worker row ever emitted here. `unscreenedRewardFields` is the honest\n        // name for what this producer can claim: a supervision journal carries\n        // no `RunRecord.outcome.realness`, so no authenticity gate has run on\n        // this score, and `realness_gated: false` states that rather than\n        // implying it by omission. These rows stay plain `RolloutLine`s, so a\n        // caller feeding them to a training exporter must `assertMinted` first.\n        ...unscreenedRewardFields(reward),\n        reward_source: src.judgeSource,\n        verdict: judge ?? null,\n        metrics: {\n          arm: src.arm,\n          sup_status: isUnavailable(terminal.supStatus) ? null : terminal.supStatus,\n          sup_verdict: typeof state?.verdict === 'string' ? state.verdict : null,\n          delivered: typeof stateResult.delivered === 'boolean' ? stateResult.delivered : null,\n          verify_pass: typeof result?.verify_pass === 'boolean' ? result.verify_pass : null,\n          started_at: tree.startedAt,\n          completed_at: tree.completedAt,\n          workers_spawned: tree.workerSpawns.length,\n          brain_metered_events: tree.brain.meteredCount,\n          runtime: rootSpawn?.runtime ?? null,\n          profile_digest: rootSpawn?.profileDigest ?? null,\n        },\n        is_completed: terminal.completed === true,\n        is_truncated: false,\n        // A recorded non-delivery names its cause: Runtime's no-winner reason,\n        // else the recorded error's message. A run with no terminal record has\n        // no error to report, and a delivered run has none.\n        error:\n          terminal.completed !== false\n            ? null\n            : !isUnavailable(terminal.supReason) && terminal.supReason !== null\n              ? terminal.supReason\n              : !isUnavailable(terminal.failure) && terminal.failure !== null\n                ? (terminal.failure.message ?? terminal.failure.name)\n                : null,\n        realness_gated: false,\n      },\n      cost: {\n        ...EMPTY_COST,\n        usd:\n          src.limits.spendUsd !== null\n            ? null\n            : typeof stateResult.spentUsd === 'number'\n              ? stateResult.spentUsd\n              : tree.brain.usd,\n        tokens_in: src.limits.managerTokens === null ? tree.brain.tokensIn : null,\n        tokens_out: src.limits.managerTokens === null ? tree.brain.tokensOut : null,\n        cache_read:\n          src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheRead : null,\n        cache_write:\n          src.limits.managerTokens === null && tree.brain.hasCache ? tree.brain.cacheWrite : null,\n        wall_s: wallMs === null ? null : wallMs / 1000,\n      },\n      artifacts: {\n        patch_path: typeof result?.patchPath === 'string' ? result.patchPath : null,\n        run_dir: src.supRunDir,\n        // Only a reader's declared artifact: a guessed path would read as retained evidence.\n        transcript_ref: src.rootTranscriptRef ?? null,\n      },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'backfill',\n        lossy_projection: true,\n        ...(captures === undefined ? {} : { workspace_captures: captures }),\n        gap: [\n          src.rootTranscriptRef == null\n            ? 'supervision journal carries structure and spend, not the brain transcript'\n            : 'brain transcript retained by reference; messages not inlined into this row',\n          captureGap,\n        ]\n          .filter((reason): reason is string => reason !== null)\n          .join('; '),\n      },\n    })\n  } else {\n    gaps.push({\n      code: 'root-spawn-unavailable',\n      message: 'no parentless spawned event in the journal',\n    })\n  }\n\n  // ── workers: one node per spawn, keyed to its spawner ───────────────────\n  const closeById = new Map(tree.closes.map((c) => [c.id, c]))\n  const sourceById = new Map(\n    (src.workers ?? []).filter(hasWorkerId).map((worker) => [worker.workerId, worker]),\n  )\n  const fallbackSourceByLabel = new Map(\n    (src.workers ?? [])\n      .filter((worker) => worker.workerId === undefined)\n      .map((worker) => [worker.label, worker]),\n  )\n  // Stable ids are authoritative. Labels are a compatibility join for stores\n  // that predate workerId and are only safe when the store keeps them unique.\n  for (const spawn of tree.workerSpawns) {\n    if (spawn.role === null) {\n      gaps.push({\n        code: 'node-role-unavailable',\n        message: `child ${JSON.stringify(spawn.label)} has no explicit invocation role`,\n        nodeId: spawn.id,\n      })\n      continue\n    }\n    const close = closeById.get(spawn.id) ?? null\n    const workerSource = sourceById.get(spawn.id) ?? fallbackSourceByLabel.get(spawn.label) ?? null\n    const facts =\n      tree.workerLogs.get(workerSource?.workerId ?? workerSource?.label ?? spawn.label) ?? null\n    const wallMs =\n      facts?.started != null && facts.finishedAt != null ? facts.finishedAt - facts.started : null\n    const score = close?.score ?? facts?.score ?? null\n    const passed = close?.valid ?? facts?.passed ?? null\n    const reward = score ?? (passed === null ? null : passed ? 1 : 0)\n    if (reward === null) {\n      gaps.push({\n        code: 'child-reward-unavailable',\n        message: `child ${JSON.stringify(spawn.label)} has no verify verdict`,\n        nodeId: spawn.id,\n      })\n    }\n    const isSupervisor = spawn.role === 'supervisor'\n    const captures = workerSource?.workspaceCaptures\n    const captureGap = noteCaptureGaps(`child ${JSON.stringify(spawn.label)}`, spawn.id, captures)\n    nodes.push({\n      ...base,\n      rollout_id: spawn.id,\n      parent_rollout_id: spawn.parent,\n      role: spawn.role,\n      policy: {\n        harness: isSupervisor ? (opts.supervisorHarness ?? null) : (opts.workerHarness ?? null),\n        harness_version: null,\n        model: isSupervisor ? (opts.supervisorModel ?? null) : (opts.workerModel ?? null),\n        provider: null,\n        profile_commit: null,\n        agent_profile_cell_id: spawn.profileDigest,\n        sampling: null,\n      },\n      outcome: {\n        // Same producer, same claim: a child reward is a self-verify verdict\n        // from the journal that no realness gate has seen.\n        ...unscreenedRewardFields(reward),\n        reward_source:\n          reward === null ? null : score === null ? 'worker-self-verify' : 'worker-verdict-score',\n        verdict:\n          close === null\n            ? null\n            : {\n                kind: close.kind,\n                status: close.status,\n                verdict: close.rawVerdict,\n                valid: close.valid,\n                score: close.score,\n              },\n        metrics: {\n          label: spawn.label,\n          spawned_at: spawn.at,\n          settled_at: close?.at ?? null,\n          started_at: facts?.started ?? null,\n          finished_at: facts?.finishedAt ?? null,\n          wall_ms: wallMs,\n          patch_bytes: workerSource?.patchBytes ?? facts?.finishedPatchBytes ?? null,\n          evidence_bytes: facts?.evidenceBytes ?? null,\n          steers_queued: facts?.steersQueued ?? null,\n          steers_delivered: facts?.steersDelivered ?? null,\n          questions: facts?.questions ?? null,\n          runtime: spawn.runtime,\n          profile_digest: spawn.profileDigest,\n        },\n        is_completed: close?.kind === 'settled' && close.status === 'done',\n        is_truncated: close?.kind === 'cancelled',\n        error:\n          close?.kind === 'cancelled'\n            ? (close.reason ?? 'cancelled')\n            : close?.status === 'down'\n              ? (close.reason ?? 'child down')\n              : null,\n        realness_gated: false,\n      },\n      // `close.spend` is only a measurement when the close event carried one;\n      // a store that never priced this worker must leave null, not 0.\n      cost: {\n        ...EMPTY_COST,\n        usd: src.limits.spendUsd !== null || !close?.hasSpend ? null : close.spend.usd,\n        tokens_in: workerSource?.tokensIn ?? (close?.hasSpend ? close.spend.tokens.input : null),\n        tokens_out: workerSource?.tokensOut ?? (close?.hasSpend ? close.spend.tokens.output : null),\n        // Mirror the tokens_in/out journal fallback so a source whose\n        // `settled` spend carries cache counters is not reported as null cache\n        // beside real tokens. Gate on `hasCache` — a spend object without cache\n        // counters must stay null, not a fabricated 0.\n        cache_read:\n          workerSource?.cacheRead ??\n          (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheRead : null),\n        cache_write:\n          workerSource?.cacheWrite ??\n          (close?.hasSpend && close.spend.tokens.hasCache ? close.spend.tokens.cacheWrite : null),\n        wall_s: wallMs === null ? null : wallMs / 1000,\n      },\n      // Only artifacts a reader declares: a guessed path would mint rows pointing at files that\n      // never existed, and a transcript reference reads as retained evidence.\n      artifacts: {\n        patch_path: workerSource?.patchPath ?? null,\n        run_dir: src.supRunDir,\n        transcript_ref: workerSource?.transcriptRef ?? null,\n      },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'backfill',\n        lossy_projection: true,\n        ...(captures === undefined ? {} : { workspace_captures: captures }),\n        gap: [\n          workerSource?.transcriptRef == null\n            ? 'no worker transcript was retained; messages unavailable'\n            : 'worker transcript retained by reference; messages not inlined into this row',\n          captureGap,\n        ]\n          .filter((reason): reason is string => reason !== null)\n          .join('; '),\n      },\n    })\n  }\n\n  const invalid = nodes.filter((n) => !isRolloutLine(n))\n  if (invalid.length > 0) {\n    gaps.push({\n      code: 'node-schema-invalid',\n      message: `${invalid.length} node(s) failed tangle.rollout.v1 validation`,\n      count: invalid.length,\n    })\n  }\n  return { rootId, nodes, gaps }\n}\n","import { evidence, issue } from './integrity-issues'\nimport { sourceIssues } from './integrity-source'\nimport { treeIssues } from './integrity-tree'\nimport {\n  SUPERVISOR_RUN_INTEGRITY_SCHEMA,\n  type SupervisorRunIntegrityOptions,\n  type SupervisorRunIntegrityReport,\n  type SupervisorRunSourceOnlyCheckCode,\n} from './integrity-types'\nimport { supervisorRunRolloutLinesFromFacts } from './rollout-nodes'\nimport { parseSupervisorTree } from './source-facts'\nimport type { SupervisorRunSources, SupervisorRunTree } from './types'\n\nexport {\n  SUPERVISOR_RUN_INTEGRITY_SCHEMA,\n  type SupervisorRunIntegrityEvidence,\n  type SupervisorRunIntegrityIssue,\n  type SupervisorRunIntegrityIssueCode,\n  type SupervisorRunIntegrityOptions,\n  type SupervisorRunIntegrityReport,\n  type SupervisorRunIntegritySeverity,\n  type SupervisorRunSourceOnlyCheckCode,\n} from './integrity-types'\n\nfunction isTree(input: SupervisorRunSources | SupervisorRunTree): input is SupervisorRunTree {\n  return 'nodes' in input && Array.isArray(input.nodes)\n}\n\nfunction treeRunRef(tree: SupervisorRunTree): string {\n  const runIds = [\n    ...new Set(\n      tree.nodes\n        .map((node) => node.run_id)\n        .filter((runId): runId is string => typeof runId === 'string' && runId.length > 0),\n    ),\n  ].sort()\n  if (runIds.length === 1) return runIds[0]!\n  if (runIds.length > 1) return `mixed-runs:${runIds.join(',')}`\n  return tree.rootId ?? 'unidentified-tree'\n}\n\n/**\n * Run deterministic integrity checks over source bytes or an already minted tree.\n * Source input is parsed exactly once and reused by projection and source-only checks.\n */\nexport function analyzeSupervisorRunIntegrity(\n  input: SupervisorRunSources | SupervisorRunTree,\n  options: SupervisorRunIntegrityOptions = {},\n): SupervisorRunIntegrityReport {\n  if (isTree(input)) {\n    const sourceOnlyChecks: readonly SupervisorRunSourceOnlyCheckCode[] = [\n      'journal-event-cardinality',\n      'worker-control-join',\n      'steer-ack-correlation',\n    ]\n    return {\n      schema: SUPERVISOR_RUN_INTEGRITY_SCHEMA,\n      runRef: treeRunRef(input),\n      input: 'tree',\n      tree: input,\n      issues: [\n        ...treeIssues(input),\n        issue({\n          code: 'source-checks-unavailable',\n          area: 'capture-integrity',\n          severity: 'medium',\n          subject: 'source-only-control-checks',\n          claim: 'Source-only control checks are unavailable for SupervisorRunTree input',\n          detail:\n            'Rollout rows do not retain journal event multiplicity or worker inbox and acknowledgement rows.',\n          evidence: [evidence('input/source-only-checks', sourceOnlyChecks)],\n          recommendedAction:\n            'Pass SupervisorRunSources when journal and worker control checks are required.',\n          metadata: { assessment: 'unavailable', checks: sourceOnlyChecks },\n        }),\n      ],\n    }\n  }\n\n  const facts = parseSupervisorTree(input)\n  const tree = supervisorRunRolloutLinesFromFacts(input, facts, {\n    capturedAt: options.capturedAt,\n  })\n  return {\n    schema: SUPERVISOR_RUN_INTEGRITY_SCHEMA,\n    runRef: input.runRef,\n    input: 'sources',\n    tree,\n    issues: [\n      ...treeIssues(tree, {\n        unknownIdentityRows:\n          facts.journalInvalidRows +\n          facts.spawns.filter((spawn) => !spawn.valid && spawn.id.length === 0).length,\n        uncertainIds: new Set(\n          facts.spawns\n            .filter((spawn) => !spawn.valid && spawn.id.length > 0)\n            .map((spawn) => spawn.id),\n        ),\n      }),\n      ...sourceIssues(input, facts, tree),\n    ],\n  }\n}\n"],"mappings":"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"}

package/dist/journal-CR4QikYp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"journal-CR4QikYp.js","names":[],"sources":["../src/ledger-core/atomic-file-lock.ts","../src/ledger-core/journal-file.ts","../src/concurrency.ts","../src/ledger-core/projector-snapshot.ts","../src/ledger-core/trusted-head.ts","../src/ledger-core/journal.ts"],"sourcesContent":["/** Crash-safe filesystem lock shared by campaign persistence and run exclusion. */\n\nimport { randomUUID } from 'node:crypto'\nimport {\n  closeSync,\n  constants,\n  existsSync,\n  fsyncSync,\n  linkSync,\n  openSync,\n  readFileSync,\n  renameSync,\n  unlinkSync,\n  writeFileSync,\n} from 'node:fs'\nimport { hostname } from 'node:os'\n\nexport interface AtomicFileLockOwner {\n  readonly pid: number\n  readonly host: string\n  readonly nonce: string\n}\n\nexport interface AtomicFileLock {\n  readonly owner: AtomicFileLockOwner\n  release(): void\n}\n\nexport type AtomicFileLockUnavailable =\n  | { readonly acquired: false; readonly reason: 'held'; readonly holder: AtomicFileLockOwner }\n  | { readonly acquired: false; readonly reason: 'recovery' }\n\nexport type AtomicFileLockAcquisition =\n  | { readonly acquired: true; readonly lock: AtomicFileLock }\n  | AtomicFileLockUnavailable\n\nexport interface AtomicFileLockOptions {\n  readonly lockPath: string\n  readonly pid?: number\n}\n\nexport class AtomicFileLockError extends Error {\n  override readonly name = 'AtomicFileLockError'\n}\n\ntype OwnerState =\n  | { readonly state: 'missing' }\n  | { readonly state: 'stale'; readonly owner: AtomicFileLockOwner }\n  | { readonly state: 'held'; readonly owner: AtomicFileLockOwner }\n\n/** Report whether another lock path prevents acquisition without modifying it. */\nexport function probeAtomicFileLock(\n  options: AtomicFileLockOptions,\n): AtomicFileLockUnavailable | null {\n  if (existsSync(recoveryPath(options.lockPath))) return { acquired: false, reason: 'recovery' }\n  const state = ownerState(options.lockPath)\n  if (state.state === 'held') {\n    return { acquired: false, reason: 'held', holder: state.owner }\n  }\n  return null\n}\n\n/**\n * Try to acquire a complete, uniquely-owned lock inode.\n *\n * A hard link publishes fully-written owner metadata atomically. Stale-owner\n * removal is serialized so one reclaimer cannot delete a new owner's lock.\n */\nexport function tryAcquireAtomicFileLock(\n  options: AtomicFileLockOptions,\n): AtomicFileLockAcquisition {\n  const pid = options.pid ?? process.pid\n  if (!Number.isSafeInteger(pid) || pid <= 0) {\n    throw new AtomicFileLockError('atomic file lock pid must be a positive integer')\n  }\n  const owner: AtomicFileLockOwner = { pid, host: hostname(), nonce: randomUUID() }\n  for (let attempt = 0; attempt < 8; attempt += 1) {\n    if (existsSync(recoveryPath(options.lockPath))) {\n      const recovery = tryAcquireRecoveryLease(options.lockPath, owner, attempt)\n      if (!recovery) return { acquired: false, reason: 'recovery' }\n      try {\n        return recoverLock(options.lockPath, owner, attempt)\n      } finally {\n        recovery.release()\n      }\n    }\n    if (tryLinkOwner(options.lockPath, owner, `acquire.${attempt}`)) {\n      return acquired(options.lockPath, owner)\n    }\n\n    const holder = ownerState(options.lockPath)\n    if (holder.state === 'missing') continue\n    if (holder.state === 'held') {\n      return { acquired: false, reason: 'held', holder: holder.owner }\n    }\n\n    const recovery = tryAcquireRecoveryLease(options.lockPath, owner, attempt)\n    if (!recovery) return { acquired: false, reason: 'recovery' }\n    try {\n      return recoverLock(options.lockPath, owner, attempt)\n    } finally {\n      recovery.release()\n    }\n  }\n\n  throw new AtomicFileLockError(`could not acquire atomic file lock ${options.lockPath}`)\n}\n\ninterface RecoveryLease {\n  release(): void\n}\n\nfunction tryAcquireRecoveryLease(\n  lockPath: string,\n  owner: AtomicFileLockOwner,\n  attempt: number,\n): RecoveryLease | null {\n  let leasePath = recoveryPath(lockPath)\n  const staleOwners: Array<{ path: string; owner: AtomicFileLockOwner }> = []\n\n  for (let depth = 0; depth < 64; depth += 1) {\n    const state = ownerState(leasePath)\n    if (state.state === 'missing') {\n      if (!tryLinkOwner(leasePath, owner, `reclaim.${attempt}.${depth}`)) continue\n      return {\n        release: () => {\n          for (const stale of staleOwners) releaseOwnedPath(stale.path, stale.owner)\n          releaseOwnedPath(leasePath, owner)\n        },\n      }\n    }\n    if (state.state === 'held') return null\n    staleOwners.push({ path: leasePath, owner: state.owner })\n    leasePath = `${leasePath}.next.${state.owner.nonce}`\n  }\n\n  throw new AtomicFileLockError(`atomic file lock recovery chain is too deep (${lockPath})`)\n}\n\nfunction recoverLock(\n  lockPath: string,\n  owner: AtomicFileLockOwner,\n  attempt: number,\n): AtomicFileLockAcquisition {\n  const current = ownerState(lockPath)\n  if (current.state === 'held') {\n    return { acquired: false, reason: 'held', holder: current.owner }\n  }\n  if (current.state === 'stale') {\n    const tombstone = `${lockPath}.stale.${owner.nonce}.${attempt}`\n    try {\n      renameSync(lockPath, tombstone)\n      unlinkSync(tombstone)\n    } catch (error) {\n      if (!isMissing(error)) throw error\n    }\n  }\n  if (tryLinkOwner(lockPath, owner, `recovered.${attempt}`)) {\n    return acquired(lockPath, owner)\n  }\n  const holder = ownerState(lockPath)\n  if (holder.state === 'held') {\n    return { acquired: false, reason: 'held', holder: holder.owner }\n  }\n  return { acquired: false, reason: 'recovery' }\n}\n\nfunction acquired(lockPath: string, owner: AtomicFileLockOwner): AtomicFileLockAcquisition {\n  return {\n    acquired: true,\n    lock: {\n      owner,\n      release: () => releaseOwnedPath(lockPath, owner),\n    },\n  }\n}\n\nfunction tryLinkOwner(lockPath: string, owner: AtomicFileLockOwner, suffix: string): boolean {\n  const ownerPath = `${lockPath}.${owner.pid}.${owner.nonce}.${suffix}.owner`\n  const descriptor = openSync(\n    ownerPath,\n    constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,\n    0o600,\n  )\n  try {\n    writeFileSync(descriptor, `${canonicalOwner(owner)}\\n`, 'utf8')\n    fsyncSync(descriptor)\n  } catch (error) {\n    closeSync(descriptor)\n    unlinkIfExists(ownerPath)\n    throw error\n  }\n  closeSync(descriptor)\n\n  try {\n    linkSync(ownerPath, lockPath)\n    return true\n  } catch (error) {\n    if (!isAlreadyExists(error)) throw error\n    return false\n  } finally {\n    unlinkIfExists(ownerPath)\n  }\n}\n\nfunction ownerState(lockPath: string): OwnerState {\n  const owner = readOwner(lockPath)\n  if (!owner) return { state: 'missing' }\n  if (owner.host !== hostname()) return { state: 'held', owner }\n  try {\n    process.kill(owner.pid, 0)\n    return { state: 'held', owner }\n  } catch (error) {\n    if (isNoSuchProcess(error)) return { state: 'stale', owner }\n    return { state: 'held', owner }\n  }\n}\n\nfunction readOwner(lockPath: string): AtomicFileLockOwner | undefined {\n  let contents: string\n  try {\n    contents = readFileSync(lockPath, 'utf8').trim()\n  } catch (error) {\n    if (isMissing(error)) return undefined\n    throw error\n  }\n\n  let value: unknown\n  try {\n    value = JSON.parse(contents)\n  } catch (error) {\n    throw invalidOwner(lockPath, error)\n  }\n  if (!isOwner(value)) throw invalidOwner(lockPath)\n  return value\n}\n\nfunction isOwner(value: unknown): value is AtomicFileLockOwner {\n  if (typeof value !== 'object' || value === null || Array.isArray(value)) return false\n  const record = value as Record<string, unknown>\n  return (\n    Object.keys(record).length === 3 &&\n    Number.isSafeInteger(record.pid) &&\n    Number(record.pid) > 0 &&\n    typeof record.host === 'string' &&\n    record.host.trim().length > 0 &&\n    typeof record.nonce === 'string' &&\n    record.nonce.trim().length > 0\n  )\n}\n\nfunction invalidOwner(lockPath: string, cause?: unknown): AtomicFileLockError {\n  const error = new AtomicFileLockError(\n    `atomic file lock has an invalid owner (${lockPath}); refusing unsafe recovery`,\n  )\n  if (cause !== undefined) Object.defineProperty(error, 'cause', { value: cause })\n  return error\n}\n\nfunction releaseOwnedPath(lockPath: string, owner: AtomicFileLockOwner): void {\n  const current = readOwner(lockPath)\n  if (!current) return\n  if (canonicalOwner(current) !== canonicalOwner(owner)) {\n    throw new AtomicFileLockError(`atomic file lock owner changed before release (${lockPath})`)\n  }\n  try {\n    unlinkSync(lockPath)\n  } catch (error) {\n    if (!isMissing(error)) throw error\n  }\n}\n\nfunction canonicalOwner(owner: AtomicFileLockOwner): string {\n  return JSON.stringify({ host: owner.host, nonce: owner.nonce, pid: owner.pid })\n}\n\nfunction recoveryPath(lockPath: string): string {\n  return `${lockPath}.reclaim`\n}\n\nfunction isAlreadyExists(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'EEXIST'\n}\n\nfunction isMissing(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'ENOENT'\n}\n\nfunction isNoSuchProcess(error: unknown): boolean {\n  return error instanceof Error && 'code' in error && error.code === 'ESRCH'\n}\n\nfunction unlinkIfExists(path: string): void {\n  try {\n    unlinkSync(path)\n  } catch (error) {\n    if (!isMissing(error)) throw error\n  }\n}\n","/** Filesystem durability and cross-process exclusion for append-only journal files. */\n\nimport {\n  closeSync,\n  constants,\n  fstatSync,\n  fsyncSync,\n  mkdirSync,\n  openSync,\n  readSync,\n  renameSync,\n  rmSync,\n  writeSync,\n} from 'node:fs'\nimport { dirname } from 'node:path'\nimport { AtomicFileLockError, tryAcquireAtomicFileLock } from './atomic-file-lock'\n\n/** How a journal binding reports file-layer faults in its own error taxonomy. */\nexport interface LedgerFileContext {\n  /** Noun used in error messages, e.g. 'search ledger'. */\n  subject: string\n  integrityError(message: string, options?: { cause?: unknown }): Error\n}\n\n/** Append one already-serialized line; the write is fsynced (file and directory)\n * before returning so an acknowledged append survives a crash. */\nexport function appendLedgerLine(path: string, line: string, context: LedgerFileContext): void {\n  mkdirSync(dirname(path), { recursive: true })\n  recoverTornFinalWrite(path, context)\n  const fd = openSync(path, constants.O_CREAT | constants.O_WRONLY | constants.O_APPEND, 0o600)\n  try {\n    writeAll(fd, Buffer.from(line, 'utf8'), context)\n    fsyncSync(fd)\n  } finally {\n    closeSync(fd)\n  }\n  fsyncDirectory(dirname(path))\n}\n\nfunction recoverTornFinalWrite(path: string, context: LedgerFileContext): void {\n  let fd: number\n  try {\n    fd = openSync(path, constants.O_RDWR)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return\n    throw context.integrityError(`${context.subject} ${path} could not be opened for recovery`, {\n      cause: error,\n    })\n  }\n\n  try {\n    const size = fstatSync(fd).size\n    if (size === 0 || readByte(fd, size - 1) === 0x0a) return\n    const tailStart = findFinalLineStart(fd, size)\n    const replacement = Buffer.alloc(size - tailStart, 0x20)\n    replacement[replacement.length - 1] = 0x0a\n    writeAllAt(fd, replacement, tailStart, context)\n    fsyncSync(fd)\n  } catch (error) {\n    throw context.integrityError(\n      `${context.subject} ${path} has an unrecoverable final journal write`,\n      { cause: error },\n    )\n  } finally {\n    closeSync(fd)\n  }\n}\n\n/** Replace a small sidecar file whole: write a temporary sibling, fsync it,\n * then rename over the target. A reader therefore sees the previous contents\n * or the new ones, never a partial file. */\nexport function writeLedgerFileAtomically(\n  path: string,\n  contents: string,\n  context: LedgerFileContext,\n): void {\n  const directory = dirname(path)\n  mkdirSync(directory, { recursive: true })\n  const temporaryPath = `${path}.tmp`\n  const fd = openSync(\n    temporaryPath,\n    constants.O_CREAT | constants.O_WRONLY | constants.O_TRUNC,\n    0o600,\n  )\n  try {\n    writeAll(fd, Buffer.from(contents, 'utf8'), context)\n    fsyncSync(fd)\n  } finally {\n    closeSync(fd)\n  }\n  renameSync(temporaryPath, path)\n  fsyncDirectory(directory)\n}\n\n/** Remove whatever occupies a sidecar path and fsync its directory, so the\n * removal is as durable as the write that created it. False when the path was\n * already empty. Recursive because a sidecar path holding a directory is one of\n * the states this has to be able to clear, not one it can refuse. */\nexport function removeLedgerFile(path: string, context: LedgerFileContext): boolean {\n  try {\n    rmSync(path, { recursive: true })\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return false\n    throw context.integrityError(`${context.subject} ${path} could not be removed`, {\n      cause: error,\n    })\n  }\n  fsyncDirectory(dirname(path))\n  return true\n}\n\nexport function withLedgerFileLock<T>(path: string, context: LedgerFileContext, run: () => T): T {\n  const result = tryWithLedgerFileLock(path, context, run)\n  if (!result.acquired) {\n    throw context.integrityError(`${context.subject} lock is held (${path})`)\n  }\n  return result.value\n}\n\nexport type FileLockResult<T> = { acquired: true; value: T } | { acquired: false }\n\nexport function tryWithLedgerFileLock<T>(\n  path: string,\n  context: LedgerFileContext,\n  run: () => T,\n): FileLockResult<T> {\n  mkdirSync(dirname(path), { recursive: true })\n  const lockPath = `${path}.lock`\n  try {\n    const acquisition = tryAcquireAtomicFileLock({ lockPath })\n    if (!acquisition.acquired) return { acquired: false }\n    try {\n      return { acquired: true, value: run() }\n    } finally {\n      acquisition.lock.release()\n    }\n  } catch (error) {\n    if (error instanceof AtomicFileLockError) {\n      throw context.integrityError(error.message, { cause: error })\n    }\n    throw error\n  }\n}\n\nfunction writeAll(fd: number, bytes: Buffer, context: LedgerFileContext): void {\n  let offset = 0\n  while (offset < bytes.byteLength) {\n    const written = writeSync(fd, bytes, offset, bytes.byteLength - offset)\n    if (written <= 0) throw context.integrityError('filesystem wrote zero bytes')\n    offset += written\n  }\n}\n\nfunction writeAllAt(fd: number, bytes: Buffer, position: number, context: LedgerFileContext): void {\n  let offset = 0\n  while (offset < bytes.byteLength) {\n    const written = writeSync(fd, bytes, offset, bytes.byteLength - offset, position + offset)\n    if (written <= 0) throw context.integrityError('filesystem wrote zero bytes')\n    offset += written\n  }\n}\n\nfunction findFinalLineStart(fd: number, size: number): number {\n  const chunk = Buffer.alloc(Math.min(4_096, size))\n  let cursor = size\n  while (cursor > 0) {\n    const length = Math.min(chunk.byteLength, cursor)\n    cursor -= length\n    const read = readSync(fd, chunk, 0, length, cursor)\n    for (let index = read - 1; index >= 0; index -= 1) {\n      if (chunk[index] === 0x0a) return cursor + index + 1\n    }\n  }\n  return 0\n}\n\nfunction readByte(fd: number, position: number): number {\n  const byte = Buffer.allocUnsafe(1)\n  const read = readSync(fd, byte, 0, 1, position)\n  return read === 1 ? byte[0]! : -1\n}\n\nfunction fsyncDirectory(path: string): void {\n  const fd = openSync(path, constants.O_RDONLY)\n  try {\n    fsyncSync(fd)\n  } finally {\n    closeSync(fd)\n  }\n}\n","/**\n * concurrency — small primitives the evolution loop needs.\n *\n * `Mutex` is a zero-dep async lock with FIFO fairness. The evolution loop\n * uses it to serialise checkout/build/commit sequences inside a single\n * pool slot, and to gate concurrent JSONL writers (see\n * `lockedJsonlReferenceReplayStore`).\n *\n * Deliberately minimal — no priority queue, no timeouts. If you need\n * those, swap to `async-mutex` at the call site.\n */\n\nexport class Mutex {\n  private locked = false\n  private readonly waiters: Array<() => void> = []\n\n  async acquire(): Promise<() => void> {\n    if (!this.locked) {\n      this.locked = true\n      return () => this.release()\n    }\n    return new Promise<() => void>((resolve) => {\n      this.waiters.push(() => {\n        resolve(() => this.release())\n      })\n    })\n  }\n\n  private release(): void {\n    const next = this.waiters.shift()\n    if (next) {\n      next()\n    } else {\n      this.locked = false\n    }\n  }\n\n  async runExclusive<T>(fn: () => Promise<T> | T): Promise<T> {\n    const release = await this.acquire()\n    try {\n      return await fn()\n    } finally {\n      release()\n    }\n  }\n\n  /** True iff someone holds the lock right now. Diagnostics only. */\n  get isLocked(): boolean {\n    return this.locked\n  }\n\n  /** Pending waiter count. Diagnostics only. */\n  get pending(): number {\n    return this.waiters.length\n  }\n}\n\ninterface MapConcurrentRangeOptions<R> {\n  count: number\n  maxConcurrency: number\n  label: string\n  signal?: AbortSignal\n  map(index: number, signal: AbortSignal): Promise<R>\n}\n\n/** Map an integer range with bounded work, cancellation, and first-error cleanup. */\nexport async function mapConcurrentRange<R>(options: MapConcurrentRangeOptions<R>): Promise<R[]> {\n  if (!Number.isSafeInteger(options.count) || options.count < 0) {\n    throw new Error(`${options.label} count must be a non-negative integer`)\n  }\n  if (!Number.isSafeInteger(options.maxConcurrency) || options.maxConcurrency < 1) {\n    throw new Error(`${options.label} maxConcurrency must be a positive integer`)\n  }\n\n  const controller = new AbortController()\n  const abortFromCaller = () => controller.abort(options.signal?.reason)\n  if (options.signal?.aborted) abortFromCaller()\n  else options.signal?.addEventListener('abort', abortFromCaller, { once: true })\n\n  const results = new Array<R>(options.count)\n  let nextIndex = 0\n  let failed = false\n  let firstFailure: unknown\n  const workers = Array.from(\n    { length: Math.min(options.maxConcurrency, options.count) },\n    async () => {\n      while (!controller.signal.aborted) {\n        const index = nextIndex\n        nextIndex += 1\n        if (index >= options.count) return\n        try {\n          results[index] = await options.map(index, controller.signal)\n        } catch (error) {\n          if (!failed) {\n            failed = true\n            firstFailure = error\n            controller.abort(error)\n          }\n          return\n        }\n      }\n    },\n  )\n\n  try {\n    await Promise.all(workers)\n    if (options.signal?.aborted) throw abortError(options.signal, options.label)\n    if (failed) throw firstFailure\n    if (controller.signal.aborted) throw abortError(controller.signal, options.label)\n    return results\n  } finally {\n    options.signal?.removeEventListener('abort', abortFromCaller)\n  }\n}\n\n/**\n * Map independent work with a fixed worker count while preserving input order.\n * After the first rejection, no new items start; already-running work is allowed\n * to settle before the returned promise rejects. Partial results are discarded.\n */\nexport async function mapConcurrent<T, R>(\n  items: readonly T[],\n  concurrency: number,\n  map: (item: T, index: number, signal: AbortSignal) => Promise<R>,\n  signal?: AbortSignal,\n): Promise<R[]> {\n  return mapConcurrentRange({\n    count: items.length,\n    maxConcurrency: concurrency,\n    label: 'mapConcurrent',\n    signal,\n    map(index, signal) {\n      return map(items[index]!, index, signal)\n    },\n  })\n}\n\nfunction abortError(signal: AbortSignal, label: string): Error {\n  return signal.reason instanceof Error ? signal.reason : new Error(`${label} aborted`)\n}\n","/**\n * Projector snapshot — the cache that lets opening a large journal replay\n * only its tail.\n *\n * `trusted-head.ts`'s pin proves a journal's length and prefix content\n * without trusting a producer's summary; it does not make PROVING that\n * cheap. Every open still walks every row from sequence 0, parses it through\n * the domain codec, and applies it to a fresh projector, because that was the\n * only way this module knew to rebuild `Projection`.\n *\n * This file adds one more sidecar: `<journal>.snapshot` holds a `Projection`\n * a codec that opts in (`snapshotProjection` on its `LedgerJournalCodec`)\n * serialized, alongside the `(sequence, entryHash)` it was taken after. A\n * reader that finds one still verifies the generic hash chain of every row up\n * to that checkpoint — self-consistency and chain linkage, the same two\n * checks `journal.ts`'s `admitEntry` runs on every row — because that\n * verification is what the pin's guarantee actually rests on (see\n * `trusted-head.ts`'s module comment: an entry hash commits to its whole\n * prefix, so there is no way to prove a prefix unchanged without touching\n * every byte of it at least once). What the cache lets a reader skip is the\n * codec's OWN parsing (`parseEntry`, typically zod validation) and the domain\n * projector's `apply` for every row before the checkpoint: rows that already\n * passed both once, at write time, and whose bytes the chain walk has just\n * proven are unchanged since. Only the checkpoint row itself, and every row\n * after it, go through the full domain path — exactly as an already-open\n * instance that had verified up to there would already do.\n *\n * A snapshot that does not match the journal's actual bytes — a chain that\n * does not reach the claimed hash, a wrong entry count for its byte range —\n * fails loudly with the same kind of `integrityError` a full replay would\n * raise for the same tampered bytes; the tampering is real regardless of\n * which path found it, so it is never swallowed in favor of a fallback that\n * would silently re-read the same bytes a different way. Only a MISSING\n * cache file, or one this journal's current pin cannot vouch for at all\n * (§`journal.ts`'s `seedFromSnapshot`), is treated as \"no cache\" and falls\n * back to full verification.\n */\n\nimport { readFileSync } from 'node:fs'\nimport { LEDGER_HASH_PATTERN, type LedgerHash } from './canonical'\nimport { type LedgerFileContext, removeLedgerFile, writeLedgerFileAtomically } from './journal-file'\nimport type { LedgerTrustedHead } from './trusted-head'\n\n/** A cached projection and the pinned entry it was taken after. */\nexport interface LedgerProjectorSnapshot {\n  head: LedgerTrustedHead\n  /** Byte length of the journal file up to and including the pinned entry's\n   * own row. Where the rows this snapshot covers end and the tail it did not\n   * cover begins. */\n  byteLength: number\n  /** The codec's serialized projection. Opaque to this module. */\n  projection: unknown\n}\n\n/** Sibling cache file for a journal, alongside its `.head` pin. */\nexport function projectorSnapshotPathFor(journalPath: string): string {\n  return `${journalPath}.snapshot`\n}\n\nconst RECOVERY =\n  ' Restore the file, or remove it and let the journal rebuild it at its next checkpoint.'\n\n/** The cached snapshot, or null when none has been written. Present but\n * unparseable is corruption of the cache itself, not its absence, and fails\n * loudly for the same reason `readTrustedHeadFile` does: silently treating it\n * as \"no cache\" would just make the next read replay from scratch without\n * ever explaining why the cache stopped working. */\nexport function readProjectorSnapshotFile(\n  path: string,\n  context: LedgerFileContext,\n): LedgerProjectorSnapshot | null {\n  let text: string\n  try {\n    text = readFileSync(path, 'utf8')\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} could not be read.${RECOVERY}`,\n      { cause: error },\n    )\n  }\n  let raw: unknown\n  try {\n    raw = JSON.parse(text)\n  } catch (error) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} is not valid JSON.${RECOVERY}`,\n      { cause: error },\n    )\n  }\n  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} is not an object.${RECOVERY}`,\n    )\n  }\n  const record = raw as Record<string, unknown>\n  const keys = Object.keys(record).sort()\n  if (\n    keys.length !== 3 ||\n    keys[0] !== 'byteLength' ||\n    keys[1] !== 'head' ||\n    keys[2] !== 'projection'\n  ) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} has keys [${keys.join(', ')}], expected [byteLength, head, projection].${RECOVERY}`,\n    )\n  }\n  const { byteLength, head, projection } = record\n  if (typeof byteLength !== 'number' || !Number.isSafeInteger(byteLength) || byteLength <= 0) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} byteLength is not a positive integer.${RECOVERY}`,\n    )\n  }\n  if (typeof head !== 'object' || head === null || Array.isArray(head)) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} head is not an object.${RECOVERY}`,\n    )\n  }\n  const headRecord = head as Record<string, unknown>\n  const headKeys = Object.keys(headRecord).sort()\n  if (headKeys.length !== 2 || headKeys[0] !== 'entryHash' || headKeys[1] !== 'sequence') {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} head has keys [${headKeys.join(', ')}], expected [entryHash, sequence].${RECOVERY}`,\n    )\n  }\n  const { sequence, entryHash } = headRecord\n  if (typeof sequence !== 'number' || !Number.isSafeInteger(sequence) || sequence < 0) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} head.sequence is not a non-negative integer.${RECOVERY}`,\n    )\n  }\n  if (typeof entryHash !== 'string' || !LEDGER_HASH_PATTERN.test(entryHash)) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} head.entryHash is not a sha256 digest.${RECOVERY}`,\n    )\n  }\n  return {\n    head: { sequence, entryHash: entryHash as LedgerHash },\n    byteLength,\n    projection,\n  }\n}\n\n/** Publish a snapshot by write-then-rename, so a crash leaves either the\n * previous cache or the new one and never a torn file a reader would have to\n * refuse. Not re-exported from the package's public surface, for the same\n * reason `writeTrustedHeadFile` is not: it takes no lock and enforces no\n * monotonicity against the journal it caches. `FileLedgerJournal` is the only\n * writer, always immediately after its own `sync()` has verified the exact\n * state it is about to cache. */\nexport function writeProjectorSnapshotFile(\n  path: string,\n  snapshot: LedgerProjectorSnapshot,\n  context: LedgerFileContext,\n): void {\n  const body = JSON.stringify({\n    byteLength: snapshot.byteLength,\n    head: snapshot.head,\n    projection: snapshot.projection,\n  })\n  try {\n    writeLedgerFileAtomically(path, `${body}\\n`, context)\n  } catch (error) {\n    throw context.integrityError(\n      `${context.subject} projector snapshot ${path} could not be written`,\n      { cause: error },\n    )\n  }\n}\n\n/** Discard a journal's cached snapshot. A missing cache is not an error: this\n * is how `clearTrustedHead()` keeps the two sidecars from disagreeing about\n * what the journal's writer has vouched for, and it is safe to call whether\n * or not a cache ever existed. */\nexport function removeProjectorSnapshotFile(path: string, context: LedgerFileContext): void {\n  removeLedgerFile(path, context)\n  removeLedgerFile(`${path}.tmp`, context)\n}\n","/**\n * Trusted head — the pin that makes deletion detectable.\n *\n * ## What the chain binds\n *\n * Every entry hashes the journal header, its sequence, the previous entry's\n * hash, and its event, so editing, reordering, or removing an entry in the\n * middle of a journal invalidates every hash after it. What a hash chain\n * cannot bind is its own length. Dropping entries off the END leaves a shorter\n * journal that is internally perfect, and rebuilding a journal from sequence 0\n * with recomputed hashes produces a different, equally perfect chain. For an\n * audit log of candidate registrations and promotion decisions that is the\n * difference between a record of a search that happened and a record of one\n * that did not.\n *\n * ## What the pin binds\n *\n * `<journal>.head` holds `{sequence, entryHash}` for one entry a writer\n * actually appended, in a file separate from the journal it attests. Each\n * entry hash commits to the entire prefix before it, so checking that the\n * entry at exactly `sequence` still carries `entryHash` proves two things at\n * once: the journal is at least `sequence + 1` entries long, and those entries\n * are byte-for-byte the ones the writer saw. A journal that merely grew past\n * the pin still verifies; a truncated, rolled-back, or wholesale-rewritten one\n * cannot.\n *\n * ## What the pin does NOT defend against\n *\n * The pin is a second file, not a signature. A writer with access to BOTH the\n * journal and its pin can rewrite both consistently, and the result verifies.\n * Pinning raises the cost of undetected tampering from one file to two and\n * nothing more; defending against a writer who holds both requires an anchor\n * outside this store entirely — a signed head, or a digest published to an\n * append-only service the tamperer does not control.\n *\n * Deleting the pin file downgrades a pinned journal to an unpinned one, which\n * cannot be distinguished from a journal written before pinning existed. That\n * is what `requireTrustedHead` is for: a journal opened under it refuses to\n * read at all once a non-empty journal has no pin.\n *\n * ## Abandoning a pin\n *\n * A pin outlives the journal it attests: deleting or rebuilding the journal\n * leaves a pin naming history the file no longer carries, and every read is\n * refused because that is precisely the deletion the pin exists to catch. The\n * refusal names the pin file, and `clearTrustedHeadFile` is the explicit way to\n * discard it — the same downgrade a writer with filesystem access could already\n * perform with `rm`, made reachable through the API so it is a decision in the\n * code rather than an undocumented manual step. It returns the guarantee it\n * gave up and writes no record of its own; a caller that needs the discard on\n * the record has to write one.\n */\n\nimport { readFileSync } from 'node:fs'\nimport { canonicalString, LEDGER_HASH_PATTERN, type LedgerHash } from './canonical'\nimport { type LedgerFileContext, removeLedgerFile, writeLedgerFileAtomically } from './journal-file'\n\n/** A `(sequence, entryHash)` pair a writer pinned outside the journal. */\nexport interface LedgerTrustedHead {\n  sequence: number\n  entryHash: LedgerHash\n}\n\n/** Minimum entry shape the anchor check needs. */\nexport interface LedgerAnchoredEntry {\n  sequence: number\n  entryHash: LedgerHash\n}\n\n/** Sibling pin file for a journal — deliberately NOT the journal, so rewriting\n * the log is not enough to rewrite the trust recorded about it. */\nexport function trustedHeadPathFor(journalPath: string): string {\n  return `${journalPath}.head`\n}\n\nconst TRUSTED_HEAD_RECOVERY =\n  ' Restore the file, or discard the pin it held with clearTrustedHead().'\n\n/** The pin, or null when this journal has never been pinned. A pin that exists\n * but does not parse is corruption or tamper of the trust record itself and\n * fails loudly: reporting it as \"no pin\" would silently downgrade what the\n * journal can prove. */\nexport function readTrustedHeadFile(\n  path: string,\n  context: LedgerFileContext,\n): LedgerTrustedHead | null {\n  let text: string\n  try {\n    text = readFileSync(path, 'utf8')\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} could not be read.${TRUSTED_HEAD_RECOVERY}`,\n      { cause: error },\n    )\n  }\n  let raw: unknown\n  try {\n    raw = JSON.parse(text)\n  } catch (error) {\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} is not valid JSON.${TRUSTED_HEAD_RECOVERY}`,\n      { cause: error },\n    )\n  }\n  if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} is not an object.${TRUSTED_HEAD_RECOVERY}`,\n    )\n  }\n  const record = raw as Record<string, unknown>\n  const keys = Object.keys(record).sort()\n  if (keys.length !== 2 || keys[0] !== 'entryHash' || keys[1] !== 'sequence') {\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} has keys [${keys.join(', ')}], expected [entryHash, sequence].${TRUSTED_HEAD_RECOVERY}`,\n    )\n  }\n  const { sequence, entryHash } = record\n  if (typeof sequence !== 'number' || !Number.isSafeInteger(sequence) || sequence < 0) {\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} sequence is not a non-negative integer.${TRUSTED_HEAD_RECOVERY}`,\n    )\n  }\n  if (typeof entryHash !== 'string' || !LEDGER_HASH_PATTERN.test(entryHash)) {\n    throw context.integrityError(\n      `${context.subject} trusted head ${path} entryHash is not a sha256 digest.${TRUSTED_HEAD_RECOVERY}`,\n    )\n  }\n  return { sequence, entryHash: entryHash as LedgerHash }\n}\n\n/** Publish a pin by write-then-rename, so a crash leaves either the previous\n * pin or the new one and never a torn file that would lock a journal out of\n * its own trust record.\n *\n * Not re-exported from the package's public surface. It takes no lock, checks no\n * chain, and enforces no monotonicity, so a public form would be the one call\n * able to move a pin BACKWARD onto a journal it never read — which is the\n * truncation the pin exists to refuse. `FileLedgerJournal.pinTrustedHead` is\n * the public writer: locked, chain-verified, forward-only. */\nexport function writeTrustedHeadFile(\n  path: string,\n  head: LedgerTrustedHead,\n  context: LedgerFileContext,\n): void {\n  try {\n    writeLedgerFileAtomically(path, `${canonicalString(head)}\\n`, context)\n  } catch (error) {\n    throw context.integrityError(`${context.subject} trusted head ${path} could not be written`, {\n      cause: error,\n    })\n  }\n}\n\n/** Outcome of discarding a pin: the guarantee that was given up. `unreadable`\n * carries why the discarded pin could not be named — corruption, a permission\n * fault, a wrong file type — so a caller recording the decision never has to\n * treat \"no pin was there\" and \"the pin could not be read\" as one state.\n * `cleanupError` reports a stale atomic-write sibling that remains after the\n * actual pin was cleared. */\nexport type LedgerTrustedHeadRemoval =\n  | { removed: true; head: LedgerTrustedHead; cleanupError?: string }\n  | { removed: true; head: null; unreadable: string; cleanupError?: string }\n  | { removed: false; cleanupError?: string }\n\n/** Discard a journal's pin, reporting what was discarded. The journal file is\n * untouched and reads as unpinned afterwards, so the next pinning append opens\n * a new pin at the entry it writes. This gives up the deletion guarantee for\n * every entry the pin covered; it is the recovery for a pin whose journal was\n * deliberately deleted or rebuilt, and the only way past a pin file that can no\n * longer be read at all. */\nexport function clearTrustedHeadFile(\n  path: string,\n  context: LedgerFileContext,\n): LedgerTrustedHeadRemoval {\n  let head: LedgerTrustedHead | null = null\n  let unreadable = ''\n  try {\n    head = readTrustedHeadFile(path, context)\n  } catch (error) {\n    // A pin nobody can read is precisely what clearing has to get past, so the\n    // fault is reported on a removal that still happens rather than raised —\n    // but it is reported, never flattened into \"there was no pin\".\n    unreadable = error instanceof Error ? error.message : String(error)\n  }\n  const removed = removeLedgerFile(path, context)\n  let cleanupError: string | undefined\n  try {\n    // Cleanup cannot block the requested trust-state change. Report a stale\n    // atomic-write sibling so the caller can repair it before the next write.\n    removeLedgerFile(`${path}.tmp`, context)\n  } catch (error) {\n    cleanupError = error instanceof Error ? error.message : String(error)\n  }\n  const cleanup = cleanupError === undefined ? {} : { cleanupError }\n  if (!removed) return { removed: false, ...cleanup }\n  if (head === null) return { removed: true, head: null, unreadable, ...cleanup }\n  return { removed: true, head, ...cleanup }\n}\n\n/** How a journal is named when a trusted-head check refuses it. */\nexport interface LedgerTrustedHeadSubject {\n  /** The journal in error messages, e.g. `search ledger /runs/a/ledger.jsonl`. */\n  subject: string\n  /** The sibling pin file, named in every refusal so the operator can see which\n   * of the two files carries the claim being enforced. */\n  trustedHeadPath: string\n}\n\n/** The entry at exactly `head.sequence` must still carry `head.entryHash`.\n * Entries must already have passed chain verification, which is what makes\n * index and sequence interchangeable here. An array serves as `entries`; a\n * journal that keeps no entries in memory passes a reader with the same\n * `length` and `at`. */\nexport function verifyEntriesAgainstTrustedHead(\n  entries: Pick<readonly LedgerAnchoredEntry[], 'length' | 'at'>,\n  head: LedgerTrustedHead,\n  context: LedgerFileContext,\n  naming: LedgerTrustedHeadSubject,\n): void {\n  // A caller passing the bare subject string an untyped build would accept\n  // destructures into two undefineds, which would corrupt the text of a\n  // security refusal rather than fail. Refuse instead.\n  if (typeof naming !== 'object' || naming === null) {\n    throw new TypeError(\n      'verifyEntriesAgainstTrustedHead expects { subject, trustedHeadPath } as its fourth argument',\n    )\n  }\n  const { subject, trustedHeadPath } = naming\n  const pinned = entries.at(head.sequence)\n  if (pinned === undefined) {\n    throw context.integrityError(\n      `${subject} trusted head ${trustedHeadPath} pins sequence ${head.sequence} (${head.entryHash}) but the journal has ${entries.length} entries — pinned history is missing (truncation, rollback, or rewrite). Restore the journal, or abandon the pinned history on purpose with clearTrustedHead().`,\n    )\n  }\n  if (pinned.sequence !== head.sequence) {\n    throw context.integrityError(\n      `${subject} entry at index ${head.sequence} carries sequence ${pinned.sequence}; the chain was not verified before the trusted head ${trustedHeadPath}`,\n    )\n  }\n  if (pinned.entryHash !== head.entryHash) {\n    throw context.integrityError(\n      `${subject} entry at pinned sequence ${head.sequence} carries ${pinned.entryHash} but the trusted head ${trustedHeadPath} recorded ${head.entryHash} — the journal was rewritten. Restore the journal, or abandon the pinned history on purpose with clearTrustedHead().`,\n    )\n  }\n}\n","/**\n * Generic durable append-only journal with a SHA-256 hash chain.\n *\n * The file format is canonical JSONL: every row is the canonical JSON encoding\n * (RFC 8785, object keys sorted recursively) of one entry, and every entry\n * hashes the previous entry's hash so the log is tamper-evident. Appends are\n * serialized in-process per path and across processes via a lock file, fsynced\n * before acknowledgement, and idempotent by `eventId`. A malformed,\n * non-canonical, truncated, reordered, or conflicting log fails loudly; a bad\n * row is never skipped.\n *\n * A hash chain binds each entry to its predecessor, which cannot prove that no\n * entry was removed from the end: a valid shorter prefix is still a valid\n * chain. `pinHead` records the appended entry in a sibling `<journal>.head`\n * file and every read re-verifies the journal against a pin that is present,\n * so truncation and wholesale rewrite are refused. `trusted-head.ts` carries\n * the full threat model, including what a pin does not defend against.\n *\n * Verification is incremental. A journal instance verifies its whole file once,\n * on its first call, and keeps the verified head, the live projector, and an\n * eventId index. Every later call checks that the head line it verified is\n * still in place, then reads, verifies, and projects only the bytes past it, so\n * an append reads one entry however long the journal is. Rows another writer\n * appended are verified as that tail. A file that was replaced, shrank, or no\n * longer carries the verified head is verified whole again. What an open\n * instance cannot see is a same-length rewrite of rows before its head; a new\n * instance verifies every row and refuses one.\n *\n * That \"whole file once\" is still every row, however long ago it was already\n * proven unchanged. A codec that opts into `snapshotProjection` lets a fresh\n * instance shortcut it: `projector-snapshot.ts`'s cache still walks the whole\n * hash chain up to its checkpoint — nothing is exempted from tamper detection\n * — but only the checkpoint row and the true tail after it go through the\n * codec's own parsing and projector; the FileLedgerJournalOptions.projectorSnapshot\n * option controls how often a pinning append refreshes it.\n *\n * Domain vocabulary lives entirely in the consumer's codec: entry schema\n * validation, the constant header fields stamped into every entry, the error\n * taxonomy, and the state machine replayed over verified entries.\n */\n\nimport { closeSync, constants, fstatSync, openSync, readSync } from 'node:fs'\nimport { resolve } from 'node:path'\nimport { Mutex } from '../concurrency'\nimport { canonicalString, hashCanonical, type LedgerHash } from './canonical'\nimport { deepFreezeCanonicalJson } from './deep-freeze'\nimport { appendLedgerLine, type LedgerFileContext, withLedgerFileLock } from './journal-file'\nimport {\n  type LedgerProjectorSnapshot,\n  projectorSnapshotPathFor,\n  readProjectorSnapshotFile,\n  removeProjectorSnapshotFile,\n  writeProjectorSnapshotFile,\n} from './projector-snapshot'\nimport {\n  clearTrustedHeadFile,\n  type LedgerTrustedHead,\n  type LedgerTrustedHeadRemoval,\n  readTrustedHeadFile,\n  trustedHeadPathFor,\n  verifyEntriesAgainstTrustedHead,\n  writeTrustedHeadFile,\n} from './trusted-head'\n\n/** Minimum shape of a journal event: the idempotency key. */\nexport interface LedgerEventBase {\n  eventId: string\n}\n\n/** Chain envelope every entry carries in addition to the journal's constant\n * header fields. `entryHash` covers the header, sequence, previous hash, and\n * event, so any rewrite of history invalidates every later entry. */\nexport interface LedgerChainFields<Event extends LedgerEventBase> {\n  sequence: number\n  previousHash: LedgerHash | null\n  event: Event\n  entryHash: LedgerHash\n}\n\nexport type LedgerEntryOf<Header extends object, Event extends LedgerEventBase> = Header &\n  LedgerChainFields<Event>\n\nexport interface LedgerLineContext {\n  path: string\n  line: number\n}\n\n/** Domain state machine applied to chain-verified entries in order.\n *\n * One projector lives as long as its journal instance's verified state: the\n * journal applies each entry once, including entries appended later, and asks\n * for `snapshot()` after any number of them. `apply` throws (via the codec's\n * error taxonomy) on an invalid transition; after a throw the journal discards\n * the projector and replays the file into a new one, so `apply` need not undo\n * a partial update. Entries are deep-frozen before `apply` sees them. */\nexport interface LedgerProjector<Entry, Projection> {\n  apply(entry: Entry, index: number): void\n  /** The projection of every entry applied so far. A later `apply` must not\n   * change a projection already returned, so a snapshot copies any state the\n   * projector keeps mutating. */\n  snapshot(): Projection\n}\n\n/** Serialize a projection into JSON-safe cache data, and rebuild a projector\n * from it whose next `apply` continues right after the entry it was taken\n * after — as if that projector had been live since sequence 0. Supplying\n * both opts a codec into the projector snapshot cache (`projector-snapshot.ts`):\n * a fresh journal open can then verify the generic hash chain of the rows\n * before a cached checkpoint without parsing or applying any of them through\n * this codec. Omit to disable the cache for this codec; every open then\n * fully replays through `createProjector`, exactly as before. */\nexport interface LedgerProjectorSnapshotCodec<Entry, Projection> {\n  serialize(projection: Projection): unknown\n  restore(serialized: unknown): LedgerProjector<Entry, Projection>\n}\n\nexport interface LedgerJournalCodec<\n  Header extends object,\n  Event extends LedgerEventBase,\n  Projection,\n> extends LedgerFileContext {\n  /** Constant fields stamped into every entry and covered by its hash. */\n  header: Header\n  conflictError(message: string): Error\n  /** Validate one parsed JSON row into a typed entry. Must reject malformed\n   * rows and non-canonical event encodings with the binding's own errors;\n   * the journal itself verifies the stored bytes and the hash chain. A new\n   * entry passes through the same parse before it is written, so the journal\n   * never writes a row it would refuse to read. */\n  parseEntry(raw: unknown, context: LedgerLineContext): LedgerEntryOf<Header, Event>\n  /** Reject an entry whose constant header fields do not match this journal. */\n  checkEntryHeader(entry: LedgerEntryOf<Header, Event>, index: number): void\n  createProjector(): LedgerProjector<LedgerEntryOf<Header, Event>, Projection>\n  snapshotProjection?: LedgerProjectorSnapshotCodec<LedgerEntryOf<Header, Event>, Projection>\n}\n\nexport interface LedgerAppendResult<Entry, Projection> {\n  entry: Entry\n  /** False when the exact event was already durably present. */\n  appended: boolean\n  projection: Projection\n}\n\nexport interface LedgerAppendOptions {\n  /** Record the appended entry as this journal's trusted head, so a later read\n   * can prove nothing was deleted from the end.\n   *\n   * On the idempotent path — the event is already durable — the pin moves up to\n   * that entry only when the entry is ahead of it, along a chain this call has\n   * just verified. So a pin write that failed after its row was fsynced is\n   * repaired by the retry that idempotency already asks the caller for, and the\n   * pin still only ever moves forward over history it has checked.\n   *\n   * A strict journal whose first pin write failed still refuses the retry\n   * because it cannot distinguish that failure from a deleted pin. Recover it\n   * explicitly with `pinTrustedHead()`; silently adopting the current file\n   * would defeat `requireTrustedHead`. */\n  pinHead?: boolean\n}\n\nexport interface FileLedgerJournalOptions {\n  /** Refuse to read a non-empty journal that has no trusted head.\n   *\n   * Off by default because journals written before pinning have no pin and\n   * must keep opening. Turn it on for a journal this process pins: without it,\n   * deleting the sibling pin file silently downgrades the journal back to a\n   * chain that cannot detect deletion. */\n  requireTrustedHead?: boolean\n  /** Cache a projector snapshot at the trusted head, refreshed once at least\n   * this many entries have appended past the last cached one, so the cost\n   * amortizes and a fresh open's tail stays bounded by this interval however\n   * large the journal grows. Requires the codec's `snapshotProjection`; a\n   * codec without it ignores this option and every open fully replays. */\n  projectorSnapshot?: { everyEntries: number }\n}\n\n/** The part of a journal file one instance has verified. It is valid only\n * between successful locked calls: any failure discards it, and the next call\n * verifies the whole file again. */\ninterface VerifiedJournal<Entry, Projection> {\n  /** Device and inode of the verified file; null until the file exists. */\n  identity: { dev: bigint; ino: bigint } | null\n  /** Verified byte length, which is where the next entry starts. */\n  size: number\n  /** Byte offset of each entry's row, indexed by sequence. */\n  offsets: number[]\n  /** The last entry and its row bytes, newline included. Finding these bytes\n   * at the end of the verified length is what lets a call trust every row\n   * before them without reading them. */\n  head: { entry: Entry; row: Buffer } | null\n  sequenceByEventId: Map<string, number>\n  projector: LedgerProjector<Entry, Projection>\n  /** The pin last verified against this chain, or null when there was none. */\n  pin: LedgerTrustedHead | null\n  /** Sequence of the last projector snapshot this instance wrote or seeded\n   * from, or null when it has not cached one. Tracked in memory so a run of\n   * pinning appends checks whether a refresh is due without re-reading the\n   * cache file on every one of them. */\n  snapshotSequence: number | null\n}\n\n// One async mutex per resolved journal path so concurrent appends from a single\n// process queue up instead of failing on the held cross-process lock file.\nconst journalMutexes = new Map<string, Mutex>()\n\nfunction mutexFor(path: string): Mutex {\n  const existing = journalMutexes.get(path)\n  if (existing) return existing\n  const mutex = new Mutex()\n  journalMutexes.set(path, mutex)\n  return mutex\n}\n\n/** Durable filesystem journal. Construction performs no I/O. The first call\n * verifies the complete file under the locks; later calls verify the retained\n * head and only the bytes past it (see the module comment). */\nexport class FileLedgerJournal<Header extends object, Event extends LedgerEventBase, Projection> {\n  readonly path: string\n  /** Sibling file holding this journal's trusted head. */\n  readonly trustedHeadPath: string\n  /** Sibling file holding this journal's cached projector snapshot, if its\n   * codec opts in. */\n  readonly projectorSnapshotPath: string\n  private readonly codec: LedgerJournalCodec<Header, Event, Projection>\n  private readonly mutex: Mutex\n  private readonly requireTrustedHead: boolean\n  private readonly snapshotEvery: number | null\n  private verified: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection> | null = null\n\n  constructor(\n    path: string,\n    codec: LedgerJournalCodec<Header, Event, Projection>,\n    options: FileLedgerJournalOptions = {},\n  ) {\n    this.path = resolve(path)\n    this.trustedHeadPath = trustedHeadPathFor(this.path)\n    this.projectorSnapshotPath = projectorSnapshotPathFor(this.path)\n    this.codec = codec\n    this.mutex = mutexFor(this.path)\n    this.requireTrustedHead = options.requireTrustedHead === true\n    this.snapshotEvery =\n      codec.snapshotProjection !== undefined && options.projectorSnapshot !== undefined\n        ? options.projectorSnapshot.everyEntries\n        : null\n  }\n\n  async replay(): Promise<Projection> {\n    return this.locked(() => this.sync(this.requireTrustedHead).projector.snapshot())\n  }\n\n  async append(\n    event: Event,\n    options: LedgerAppendOptions = {},\n  ): Promise<LedgerAppendResult<LedgerEntryOf<Header, Event>, Projection>> {\n    return this.locked(() => {\n      const state = this.sync(this.requireTrustedHead)\n      const existingSequence = state.sequenceByEventId.get(event.eventId)\n      if (existingSequence !== undefined) {\n        const existing = this.entryAt(state, existingSequence)!\n        if (canonicalString(existing.event) !== canonicalString(event)) {\n          throw this.codec.conflictError(\n            `eventId ${event.eventId} already exists with different content`,\n          )\n        }\n        if (options.pinHead === true) this.pinAcknowledged(state, existing)\n        return { entry: existing, appended: false, projection: state.projector.snapshot() }\n      }\n\n      const sequence = state.offsets.length\n      const material = {\n        ...this.codec.header,\n        sequence,\n        previousHash: state.head?.entry.entryHash ?? null,\n        event,\n      }\n      const text = canonicalString({ ...material, entryHash: hashCanonical(material) })\n      // The new row goes through the reader's own parse and the projector's\n      // transition before it is written: a row the journal would refuse to\n      // read, or an entry the projector rejects, never reaches the file.\n      const entry = parseRow(text, { path: this.path, line: sequence + 1 }, this.codec)\n      const row = Buffer.from(`${text}\\n`, 'utf8')\n      admitEntry(state, entry, row, this.codec)\n      appendLedgerLine(this.path, `${text}\\n`, this.codec)\n      if (options.pinHead === true) {\n        // Journal first, pin second: a crash or a failed pin write between\n        // them leaves the pin one entry behind, which still verifies and is\n        // repaired by the next pinning append, including the idempotent\n        // retry of this same event. The reverse order would leave a pin\n        // naming an entry the journal does not carry, locking the journal\n        // out of its own history.\n        const head = { sequence: entry.sequence, entryHash: entry.entryHash }\n        writeTrustedHeadFile(this.trustedHeadPath, head, this.codec)\n        state.pin = head\n        this.maybeWriteProjectorSnapshot(state)\n      }\n      return { entry, appended: true, projection: state.projector.snapshot() }\n    })\n  }\n\n  /** The pinned head, or null when this journal has never been pinned. */\n  async trustedHead(): Promise<LedgerTrustedHead | null> {\n    return this.mutex.runExclusive(() =>\n      withLedgerFileLock(this.path, this.codec, () =>\n        readTrustedHeadFile(this.trustedHeadPath, this.codec),\n      ),\n    )\n  }\n\n  /** Pin the current verified head. The chain and any existing pin are checked\n   * first, so the pin only ever moves forward along a journal that still\n   * carries the history it already recorded. */\n  async pinTrustedHead(): Promise<LedgerTrustedHead> {\n    return this.locked(() => {\n      // `requireTrustedHead` is deliberately not applied here: pinning is how\n      // a journal that lacks a pin acquires one.\n      const state = this.sync(false)\n      if (state.head === null) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} is empty; there is no head to pin`,\n        )\n      }\n      const head: LedgerTrustedHead = {\n        sequence: state.head.entry.sequence,\n        entryHash: state.head.entry.entryHash,\n      }\n      writeTrustedHeadFile(this.trustedHeadPath, head, this.codec)\n      state.pin = head\n      // An explicit pin is already a deliberate, infrequent checkpoint call,\n      // so — when the caller opted into the cache at all — it always\n      // refreshes it rather than waiting for the interval. Gated on\n      // `snapshotEvery`, not just the codec's support, so a journal that\n      // never asked for `projectorSnapshot` never gets a cache file from\n      // this path either; caching stays one on/off decision, not two.\n      if (this.snapshotEvery !== null) this.writeProjectorSnapshotNow(state)\n      return head\n    })\n  }\n\n  /** Discard this journal's pin, reporting what was discarded. The journal file\n   * is untouched and reads as unpinned afterwards, so the next pinning append\n   * opens a new pin at the entry it writes. It is the way out of a pin whose\n   * journal was deliberately deleted or rebuilt — every read of such a path is\n   * refused, correctly, because a pin naming history the file no longer carries\n   * is indistinguishable from a deletion. Clearing removes the deletion\n   * guarantee for every entry the pin covered. */\n  async clearTrustedHead(): Promise<LedgerTrustedHeadRemoval> {\n    return this.locked(() => {\n      const removal = clearTrustedHeadFile(this.trustedHeadPath, this.codec)\n      // A cached snapshot that survived would be pinned to a head this\n      // journal no longer vouches for, indistinguishable from a stale one a\n      // future re-pin could seed from without earning it. It is not\n      // security-critical to remove it — a reader only ever trusts a cached\n      // checkpoint the current pin can vouch for — but keeping the sidecars\n      // in agreement about what has been given up is the honest state to\n      // leave on disk.\n      removeProjectorSnapshotFile(this.projectorSnapshotPath, this.codec)\n      if (this.verified !== null) {\n        this.verified.pin = null\n        this.verified.snapshotSequence = null\n      }\n      return removal\n    })\n  }\n\n  /** Run under both locks. Any failure discards the verified state, because a\n   * throw can leave it describing bytes the file does not hold: a projector\n   * half way through a rejected transition, or a row whose write failed. */\n  private locked<T>(run: () => T): Promise<T> {\n    return this.mutex.runExclusive(() =>\n      withLedgerFileLock(this.path, this.codec, () => {\n        try {\n          return run()\n        } catch (error) {\n          this.verified = null\n          throw error\n        }\n      }),\n    )\n  }\n\n  /** Bring the verified state up to the file: keep it when its head row is\n   * still where it was verified, else start over from byte 0; then verify and\n   * apply every row past it, and check the pin. */\n  private sync(requirePin: boolean): VerifiedJournal<LedgerEntryOf<Header, Event>, Projection> {\n    let state = this.verified\n    const fd = openForReading(this.path, this.codec)\n    if (fd === null) {\n      // A missing file is an empty journal, whatever this instance saw before.\n      if (state === null || state.size > 0) state = emptyJournal(this.codec)\n      this.verified = state\n      this.verifyPin(state, requirePin)\n      return state\n    }\n    try {\n      const stats = fstatSync(fd, { bigint: true })\n      const size = Number(stats.size)\n      const identity = { dev: stats.dev, ino: stats.ino }\n      if (\n        state === null ||\n        (state.identity !== null &&\n          (state.identity.dev !== identity.dev || state.identity.ino !== identity.ino)) ||\n        size < state.size ||\n        !headInPlace(fd, state.size, state.head?.row ?? null)\n      ) {\n        // This is the case a full verification exists to catch — a fresh\n        // instance, or one whose retained head is no longer where it was\n        // verified — so a cached checkpoint is only ever a shortcut to the\n        // SAME conclusion a full replay would reach, never a substitute for\n        // reaching it.\n        state = (size > 0 ? this.seedFromSnapshot(fd, size) : null) ?? emptyJournal(this.codec)\n      }\n      state.identity = identity\n      this.verified = state\n      if (size > state.size) {\n        extendJournal(state, readRange(fd, state.size, size), this.path, this.codec)\n      }\n    } finally {\n      closeSync(fd)\n    }\n    this.verifyPin(state, requirePin)\n    return state\n  }\n\n  private verifyPin(\n    state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n    requirePin: boolean,\n  ): void {\n    const pinned = readTrustedHeadFile(this.trustedHeadPath, this.codec)\n    const count = state.offsets.length\n    if (pinned === null) {\n      state.pin = null\n      if (requirePin && count > 0) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has ${count} entries but no trusted head at ${this.trustedHeadPath} — without its pin the journal cannot prove nothing was deleted. Restore the pin file, or adopt the current head with pinTrustedHead().`,\n        )\n      }\n      return\n    }\n    // A pin already verified against this chain stays verified while the\n    // chain's head is in place; sync has just checked that.\n    if (state.pin?.sequence === pinned.sequence && state.pin.entryHash === pinned.entryHash) {\n      return\n    }\n    // The anchor is meaningful only over a chain that already verified, so it\n    // is checked after sync — and on every call, so a violated pin is refused\n    // before an append can extend the journal over it.\n    const chain = { length: count, at: (sequence: number) => this.entryAt(state, sequence) }\n    verifyEntriesAgainstTrustedHead(chain, pinned, this.codec, {\n      subject: `${this.codec.subject} ${this.path}`,\n      trustedHeadPath: this.trustedHeadPath,\n    })\n    state.pin = pinned\n  }\n\n  /** Move the pin up to an entry this caller just acknowledged on the\n   * idempotent path, when a pin write that failed after its row was already\n   * fsynced left the pin behind. The move is safe because it is forward-only\n   * along a chain `sync` has just verified: every entry up to this one is bound\n   * to it by hash, so the pin can only ever come to name more history than it\n   * did, never different history.\n   *\n   * With no pin at all this only pins the journal's current head. An entry in\n   * the middle would publish a pin that reads as protection while leaving every\n   * later entry silently truncatable, which is a worse state to hand an auditor\n   * than the honest absence of a pin; `pinTrustedHead()` is the way to pin an\n   * unpinned journal on purpose. */\n  private pinAcknowledged(\n    state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n    entry: LedgerEntryOf<Header, Event>,\n  ): void {\n    const pinned = state.pin\n    if (pinned === null) {\n      if (entry.sequence !== state.offsets.length - 1) return\n    } else if (pinned.sequence >= entry.sequence) {\n      return\n    }\n    const head = { sequence: entry.sequence, entryHash: entry.entryHash }\n    writeTrustedHeadFile(this.trustedHeadPath, head, this.codec)\n    state.pin = head\n    this.maybeWriteProjectorSnapshot(state)\n  }\n\n  /** Refresh the cached projector snapshot once the current pin has moved at\n   * least `snapshotEvery` entries past the last one cached, so the write cost\n   * amortizes across many appends and a fresh open's uncached tail stays\n   * bounded by that interval no matter how large the journal grows. A no-op\n   * when the codec does not support the cache, the option is off, or the\n   * head this call just pinned is not actually new (the idempotent-append\n   * path can call this after re-acknowledging an already-durable entry). */\n  private maybeWriteProjectorSnapshot(\n    state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n  ): void {\n    if (this.codec.snapshotProjection === undefined || this.snapshotEvery === null) return\n    if (state.pin === null || state.pin.sequence !== state.head?.entry.sequence) return\n    if (\n      state.snapshotSequence !== null &&\n      state.pin.sequence - state.snapshotSequence < this.snapshotEvery\n    ) {\n      return\n    }\n    this.writeProjectorSnapshotNow(state)\n  }\n\n  /** Serialize the live projector and write it as the cache, unconditionally.\n   * Callers have already established that `state.pin` names `state.head`, so\n   * the cache and the pin agree on the checkpoint by construction. */\n  private writeProjectorSnapshotNow(\n    state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n  ): void {\n    const head = state.pin!\n    const projection = this.codec.snapshotProjection!.serialize(state.projector.snapshot())\n    const snapshot: LedgerProjectorSnapshot = { head, byteLength: state.size, projection }\n    writeProjectorSnapshotFile(this.projectorSnapshotPath, snapshot, this.codec)\n    state.snapshotSequence = head.sequence\n  }\n\n  /** Seed a fresh verified state from the cached projector snapshot, or null\n   * when there is none this reader can use — a missing or out-of-reach\n   * cache, never something this instance found actually wrong. Everything it\n   * DOES accept is checked against the real bytes: rows 0 through the\n   * checkpoint are read and chain-verified exactly as `admitEntry` would\n   * verify them (self-consistent hash, correct sequence, linked previousHash,\n   * unique eventId), just without this codec's own `parseEntry` or\n   * `apply` — the checkpoint row itself still goes through both, through the\n   * ordinary `parseRow`, so it is exactly as trustworthy as any entry a full\n   * replay would produce. Any mismatch found along the way throws the same\n   * `integrityError` a full replay of the same bytes would raise, because it\n   * is the same tampering either path would have found; this is never turned\n   * into a quiet fallback that would just re-read the same bytes differently\n   * and risk reporting a different, more confusing failure — or none. */\n  private seedFromSnapshot(\n    fd: number,\n    size: number,\n  ): VerifiedJournal<LedgerEntryOf<Header, Event>, Projection> | null {\n    const restore = this.codec.snapshotProjection\n    if (restore === undefined) return null\n    const cached = readProjectorSnapshotFile(this.projectorSnapshotPath, this.codec)\n    if (cached === null) return null\n    // Only a cache the CURRENT pin can vouch for is trusted. A pin moves\n    // forward only past history that has already chain-verified (sync\n    // verifies every appended row before a pinning append can move it), so a\n    // cache at or behind the pin names a real, already-proven checkpoint; one\n    // ahead of it — or present with no pin at all — names history nothing\n    // external currently vouches for, and is ignored rather than trusted.\n    const pin = readTrustedHeadFile(this.trustedHeadPath, this.codec)\n    if (pin === null || cached.head.sequence > pin.sequence) return null\n    if (cached.byteLength <= 0 || cached.byteLength > size) return null\n\n    const prefix = readRange(fd, 0, cached.byteLength)\n    const rows = splitRows(prefix, this.path, this.codec)\n    if (rows.length !== cached.head.sequence + 1) {\n      throw this.codec.integrityError(\n        `${this.codec.subject} ${this.path} projector snapshot ${this.projectorSnapshotPath} expects ${cached.head.sequence + 1} entries in its first ${cached.byteLength} bytes but the journal has ${rows.length}`,\n      )\n    }\n\n    const offsets: number[] = []\n    const sequenceByEventId = new Map<string, number>()\n    let previousHash: LedgerHash | null = null\n    for (let index = 0; index < rows.length - 1; index += 1) {\n      const row = rows[index]!\n      offsets.push(row.start)\n      let raw: unknown\n      try {\n        raw = JSON.parse(row.text)\n      } catch (error) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has invalid JSON at line ${index + 1}`,\n          { cause: error },\n        )\n      }\n      if (canonicalString(raw) !== row.text) {\n        throw this.codec.integrityError(\n          `${this.codec.subject} ${this.path} has non-canonical bytes at line ${index + 1}`,\n        )\n      }\n      const fields = raw as {\n        sequence?: unknown\n        previousHash?: unknown\n        entryHash?: unknown\n        event?: { eventId?: unknown }\n      }\n      if (fields.sequence !== index) {\n        throw this.codec.integrityError(\n          `entry at line ${index + 1} has sequence ${String(fields.sequence)}, expected ${index}`,\n        )\n      }\n      if ((fields.previousHash ?? null) !== previousHash) {\n        throw this.codec.integrityError(\n          `entry at line ${index + 1} does not extend the previous hash`,\n        )\n      }\n      const { entryHash, ...material } = raw as Record<string, unknown>\n      const expected = hashCanonical(material)\n      if (entryHash !== expected) {\n        throw this.codec.integrityError(\n          `entry at line ${index + 1} hash mismatch: expected ${expected}, got ${String(entryHash)}`,\n        )\n      }\n      const eventId = fields.event?.eventId\n      if (typeof eventId !== 'string' || eventId === '') {\n        throw this.codec.integrityError(`entry at line ${index + 1} has no eventId`)\n      }\n      if (sequenceByEventId.has(eventId)) {\n        throw this.codec.integrityError(`duplicate eventId ${eventId} in durable ledger`)\n      }\n      sequenceByEventId.set(eventId, index)\n      previousHash = entryHash as LedgerHash\n    }\n\n    // The checkpoint row itself carries this codec's own validation, exactly\n    // like any other entry — the cache never substitutes for parsing it.\n    const boundary = rows[rows.length - 1]!\n    offsets.push(boundary.start)\n    const entry = parseRow(\n      boundary.text,\n      { path: this.path, line: cached.head.sequence + 1 },\n      this.codec,\n    )\n    const { entryHash: _boundaryHash, ...boundaryMaterial } = entry\n    if (\n      entry.sequence !== cached.head.sequence ||\n      entry.previousHash !== previousHash ||\n      entry.entryHash !== cached.head.entryHash ||\n      hashCanonical(boundaryMaterial) !== cached.head.entryHash\n    ) {\n      throw this.codec.integrityError(\n        `${this.codec.subject} ${this.path} projector snapshot ${this.projectorSnapshotPath} does not match the journal at sequence ${cached.head.sequence}`,\n      )\n    }\n    this.codec.checkEntryHeader(entry, cached.head.sequence)\n    if (sequenceByEventId.has(entry.event.eventId)) {\n      throw this.codec.integrityError(`duplicate eventId ${entry.event.eventId} in durable ledger`)\n    }\n    sequenceByEventId.set(entry.event.eventId, entry.sequence)\n\n    let projector: LedgerProjector<LedgerEntryOf<Header, Event>, Projection>\n    try {\n      projector = restore.restore(cached.projection)\n    } catch (error) {\n      throw this.codec.integrityError(\n        `${this.codec.subject} ${this.path} projector snapshot ${this.projectorSnapshotPath} could not be restored`,\n        { cause: error },\n      )\n    }\n\n    return {\n      identity: null,\n      size: cached.byteLength,\n      offsets,\n      head: { entry, row: Buffer.from(`${boundary.text}\\n`, 'utf8') },\n      sequenceByEventId,\n      projector,\n      pin: null,\n      snapshotSequence: cached.head.sequence,\n    }\n  }\n\n  /** The verified entry at `sequence`, read back from the file. The rows from\n   * it to the head are re-read and must chain to the verified head hash, which\n   * binds the returned entry to the history this instance verified. Callers ask\n   * for recent entries — an idempotent retry, a pin one entry behind — so this\n   * usually reads nothing or one row. */\n  private entryAt(\n    state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n    sequence: number,\n  ): LedgerEntryOf<Header, Event> | undefined {\n    const count = state.offsets.length\n    if (!Number.isSafeInteger(sequence) || sequence < 0 || sequence >= count) return undefined\n    if (sequence === count - 1) return state.head!.entry\n    const changed = () =>\n      this.codec.integrityError(\n        `${this.codec.subject} ${this.path} changed at or after sequence ${sequence} since this reader verified it`,\n      )\n    const fd = openForReading(this.path, this.codec)\n    if (fd === null) throw changed()\n    let bytes: Buffer\n    try {\n      bytes = readRange(fd, state.offsets[sequence]!, state.size)\n    } finally {\n      closeSync(fd)\n    }\n    const rows = splitRows(bytes, this.path, this.codec)\n    if (rows.length !== count - sequence) throw changed()\n    let first: LedgerEntryOf<Header, Event> | undefined\n    let previous: LedgerEntryOf<Header, Event> | undefined\n    for (let index = 0; index < rows.length; index += 1) {\n      const entry = parseRow(\n        rows[index]!.text,\n        { path: this.path, line: sequence + index + 1 },\n        this.codec,\n      )\n      const { entryHash, ...material } = entry\n      if (\n        entry.sequence !== sequence + index ||\n        hashCanonical(material) !== entryHash ||\n        (previous !== undefined && entry.previousHash !== previous.entryHash)\n      ) {\n        throw changed()\n      }\n      first ??= entry\n      previous = entry\n    }\n    if (previous?.entryHash !== state.head!.entry.entryHash) throw changed()\n    return first\n  }\n}\n\n/** Where a memory journal keeps its text: an in-process store keyed by path,\n * such as an in-memory `CampaignStorage`. */\nexport interface LedgerTextStore {\n  read(path: string): string | undefined\n  write(path: string, text: string): void\n}\n\n/**\n * A journal for runs without a filesystem. It keeps its rows as text in a\n * store and applies the file journal's rules: the same row parse, hash chain,\n * idempotent append by `eventId`, and projector transition before a row is\n * kept. It has no lock, fsync or trusted head, because its rows live and die\n * with the process that holds the store.\n */\nexport class MemoryLedgerJournal<Header extends object, Event extends LedgerEventBase, Projection> {\n  readonly path: string\n  private readonly codec: LedgerJournalCodec<Header, Event, Projection>\n  private readonly store: LedgerTextStore\n  private verified: {\n    text: string\n    journal: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>\n    entries: LedgerEntryOf<Header, Event>[]\n  } | null = null\n\n  constructor(\n    path: string,\n    codec: LedgerJournalCodec<Header, Event, Projection>,\n    store: LedgerTextStore,\n  ) {\n    this.path = path\n    this.codec = codec\n    this.store = store\n  }\n\n  async replay(): Promise<Projection> {\n    return this.guarded(() => this.sync().journal.projector.snapshot())\n  }\n\n  async append(\n    event: Event,\n  ): Promise<LedgerAppendResult<LedgerEntryOf<Header, Event>, Projection>> {\n    return this.guarded(() => {\n      const verified = this.sync()\n      const { journal, entries } = verified\n      const existingSequence = journal.sequenceByEventId.get(event.eventId)\n      if (existingSequence !== undefined) {\n        const existing = entries[existingSequence]!\n        if (canonicalString(existing.event) !== canonicalString(event)) {\n          throw this.codec.conflictError(\n            `eventId ${event.eventId} already exists with different content`,\n          )\n        }\n        return { entry: existing, appended: false, projection: journal.projector.snapshot() }\n      }\n      const sequence = entries.length\n      const material = {\n        ...this.codec.header,\n        sequence,\n        previousHash: journal.head?.entry.entryHash ?? null,\n        event,\n      }\n      const text = canonicalString({ ...material, entryHash: hashCanonical(material) })\n      const entry = parseRow(text, { path: this.path, line: sequence + 1 }, this.codec)\n      admitEntry(journal, entry, Buffer.from(`${text}\\n`, 'utf8'), this.codec)\n      entries.push(entry)\n      verified.text = `${verified.text}${text}\\n`\n      this.store.write(this.path, verified.text)\n      return { entry, appended: true, projection: journal.projector.snapshot() }\n    })\n  }\n\n  /** Verify the stored text again whenever it is not the text this instance wrote. */\n  private sync(): NonNullable<MemoryLedgerJournal<Header, Event, Projection>['verified']> {\n    const text = this.store.read(this.path) ?? ''\n    if (this.verified?.text === text) return this.verified\n    const journal = emptyJournal(this.codec)\n    const entries: LedgerEntryOf<Header, Event>[] = []\n    const bytes = Buffer.from(text, 'utf8')\n    for (const row of splitRows(bytes, this.path, this.codec)) {\n      const entry = parseRow(row.text, { path: this.path, line: entries.length + 1 }, this.codec)\n      admitEntry(journal, entry, Buffer.from(bytes.subarray(row.start, row.end)), this.codec)\n      entries.push(entry)\n    }\n    this.verified = { text, journal, entries }\n    return this.verified\n  }\n\n  /** A refused transition can leave the projector half applied; discard it. */\n  private async guarded<T>(run: () => T): Promise<T> {\n    try {\n      return run()\n    } catch (error) {\n      this.verified = null\n      throw error\n    }\n  }\n}\n\n/** Verify and replay resolved immutable journal bytes without filesystem I/O. */\nexport function replayLedgerText<Header extends object, Event extends LedgerEventBase, Projection>(\n  text: string,\n  path: string,\n  codec: LedgerJournalCodec<Header, Event, Projection>,\n): Projection {\n  const state = emptyJournal(codec)\n  extendJournal(state, Buffer.from(text, 'utf8'), path, codec)\n  return state.projector.snapshot()\n}\n\nfunction emptyJournal<Header extends object, Event extends LedgerEventBase, Projection>(\n  codec: LedgerJournalCodec<Header, Event, Projection>,\n): VerifiedJournal<LedgerEntryOf<Header, Event>, Projection> {\n  return {\n    identity: null,\n    size: 0,\n    offsets: [],\n    head: null,\n    sequenceByEventId: new Map(),\n    projector: codec.createProjector(),\n    pin: null,\n    snapshotSequence: null,\n  }\n}\n\n/** Verify and apply the rows in `bytes`, which start at the state's verified\n * length. */\nfunction extendJournal<Header extends object, Event extends LedgerEventBase, Projection>(\n  state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n  bytes: Buffer,\n  path: string,\n  codec: LedgerJournalCodec<Header, Event, Projection>,\n): void {\n  const rows = splitRows(bytes, path, codec)\n  for (const { text, start, end } of rows) {\n    const entry = parseRow(text, { path, line: state.offsets.length + 1 }, codec)\n    // Copy the row: a view would keep the whole read buffer alive.\n    admitEntry(state, entry, Buffer.from(bytes.subarray(start, end)), codec)\n  }\n}\n\n/** Check one parsed entry against the chain and apply it. Every row, read or\n * about to be written, enters the verified state here. */\nfunction admitEntry<Header extends object, Event extends LedgerEventBase, Projection>(\n  state: VerifiedJournal<LedgerEntryOf<Header, Event>, Projection>,\n  entry: LedgerEntryOf<Header, Event>,\n  row: Buffer,\n  codec: LedgerJournalCodec<Header, Event, Projection>,\n): void {\n  const index = state.offsets.length\n  codec.checkEntryHeader(entry, index)\n  if (entry.sequence !== index) {\n    throw codec.integrityError(\n      `entry ${entry.event.eventId} has sequence ${entry.sequence}, expected ${index}`,\n    )\n  }\n  if (entry.previousHash !== (state.head?.entry.entryHash ?? null)) {\n    throw codec.integrityError(`entry ${entry.event.eventId} does not extend the previous hash`)\n  }\n  const { entryHash: _entryHash, ...material } = entry\n  const expectedHash = hashCanonical(material)\n  if (entry.entryHash !== expectedHash) {\n    throw codec.integrityError(\n      `entry ${entry.event.eventId} hash mismatch: expected ${expectedHash}, got ${entry.entryHash}`,\n    )\n  }\n  if (state.sequenceByEventId.has(entry.event.eventId)) {\n    throw codec.integrityError(`duplicate eventId ${entry.event.eventId} in durable ledger`)\n  }\n  state.projector.apply(entry, index)\n  state.sequenceByEventId.set(entry.event.eventId, index)\n  state.offsets.push(state.size)\n  state.size += row.byteLength\n  state.head = { entry, row }\n}\n\n/** Parse one canonical row into a frozen entry. The projector and every caller\n * share entries, so none of them can change what the journal verified. */\nfunction parseRow<Header extends object, Event extends LedgerEventBase, Projection>(\n  text: string,\n  context: LedgerLineContext,\n  codec: LedgerJournalCodec<Header, Event, Projection>,\n): LedgerEntryOf<Header, Event> {\n  const { path, line } = context\n  let raw: unknown\n  try {\n    raw = JSON.parse(text)\n  } catch (error) {\n    throw codec.integrityError(`${codec.subject} ${path} has invalid JSON at line ${line}`, {\n      cause: error,\n    })\n  }\n  const entry = codec.parseEntry(raw, context)\n  let canonical: string\n  try {\n    canonical = canonicalString(entry)\n  } catch (error) {\n    throw codec.integrityError(\n      `${codec.subject} ${path} has a row with no canonical JSON form at line ${line}`,\n      { cause: error },\n    )\n  }\n  if (text !== canonical) {\n    throw codec.integrityError(`${codec.subject} ${path} has non-canonical bytes at line ${line}`)\n  }\n  return deepFreezeCanonicalJson(entry)\n}\n\ninterface JournalRow {\n  text: string\n  /** Byte range of the row in the buffer, newline included. */\n  start: number\n  end: number\n}\n\nfunction splitRows(bytes: Buffer, path: string, context: LedgerFileContext): JournalRow[] {\n  if (bytes.byteLength === 0) return []\n  if (bytes[bytes.byteLength - 1] !== 0x0a) {\n    throw context.integrityError(\n      `${context.subject} ${path} has a truncated final record (missing newline)`,\n    )\n  }\n  const rows: JournalRow[] = []\n  let start = 0\n  while (start < bytes.byteLength) {\n    const newline = bytes.indexOf(0x0a, start)\n    if (newline === start) {\n      throw context.integrityError(\n        `${context.subject} ${path} has a blank row at line ${rows.length + 1}`,\n      )\n    }\n    rows.push({ text: bytes.toString('utf8', start, newline), start, end: newline + 1 })\n    start = newline + 1\n  }\n  return rows\n}\n\n/** True when the verified head row still ends the verified length of the file. */\nfunction headInPlace(fd: number, size: number, row: Buffer | null): boolean {\n  return row === null || readRange(fd, size - row.byteLength, size).equals(row)\n}\n\n/** A read-only descriptor, or null when the file does not exist. */\nfunction openForReading(path: string, context: LedgerFileContext): number | null {\n  try {\n    return openSync(path, constants.O_RDONLY)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null\n    throw context.integrityError(`${context.subject} ${path} could not be opened for reading`, {\n      cause: error,\n    })\n  }\n}\n\nfunction readRange(fd: number, start: number, end: number): Buffer {\n  const bytes = Buffer.allocUnsafe(end - start)\n  let offset = 0\n  while (offset < bytes.byteLength) {\n    const read = readSync(fd, bytes, offset, bytes.byteLength - offset, start + offset)\n    if (read === 0) return bytes.subarray(0, offset)\n    offset += read\n  }\n  return bytes\n}\n"],"mappings":"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"}