solidity-argus 0.5.10 → 0.6.1

package/src/hooks/system-prompt-hook.ts

@@ -35,6 +35,73 @@ export function buildFallbackDirectives(unavailableTools: string[]): string[] {
   return directives
 }
 
+function formatDuration(startTime: number, endTime?: number): string {
+  if (typeof endTime !== "number" || endTime < startTime) return "pending"
+  return `${endTime - startTime}ms`
+}
+
+function buildToolLedgerLine(auditState: AuditState): string {
+  const taskTools = auditState.toolsExecuted.filter((tool) => tool.tool === "task")
+  const taskDispatches = taskTools.length
+  const argusTools = auditState.toolsExecuted.filter((tool) => tool.tool !== "task").slice(-5)
+  const entries = argusTools.map((tool) => {
+    const status = tool.success ? "ok" : "failed"
+    return `${tool.tool}=${status} findings=${tool.findingsCount} duration=${formatDuration(tool.startTime, tool.endTime)}`
+  })
+
+  if (taskDispatches > 0) {
+    const bySubagent = new Map<string, number>()
+    for (const tool of taskTools) {
+      const subagent = tool.subagent_type ?? "unknown"
+      bySubagent.set(subagent, (bySubagent.get(subagent) ?? 0) + 1)
+    }
+    const subagentSummary = [...bySubagent.entries()]
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([subagent, count]) => `${subagent}=${count}`)
+      .join(" ")
+    entries.push(
+      subagentSummary.length > 0
+        ? `task dispatches=${taskDispatches} (${subagentSummary})`
+        : `task dispatches=${taskDispatches}`,
+    )
+  }
+  return entries.length > 0 ? entries.join("; ") : "none"
+}
+
+function buildToolsLine(auditState: AuditState): string {
+  const tools = auditState.toolsExecuted
+    .filter((tool) => tool.tool !== "task")
+    .map((tool) => tool.tool)
+  return tools.length > 0 ? tools.join(", ") : "none"
+}
+
+function buildFindingCountsLine(auditState: AuditState): string | null {
+  const counts = auditState.findingCounts
+  if (!counts) return null
+
+  return [
+    "Finding Counts:",
+    `raw_observations=${counts.rawObservations ?? 0}`,
+    `recorded=${counts.recordedFindings ?? 0}`,
+    `deduped=${counts.dedupedFindings ?? 0}`,
+    `actionable=${counts.actionableFindings ?? 0}`,
+    `non_actionable=${counts.nonActionableFindings ?? 0}`,
+  ].join(" ")
+}
+
+function buildCoverageLine(auditState: AuditState): string {
+  const attempt = auditState.coverageAttempt
+  if (attempt) {
+    return attempt.reason
+      ? `Coverage: ${attempt.status} — ${attempt.reason}`
+      : `Coverage: ${attempt.status}`
+  }
+  const unavailable = auditState.unavailableTools ?? []
+  return unavailable.includes("forge")
+    ? "Coverage: skipped — forge unavailable"
+    : "Coverage: pending"
+}
+
 export function buildDynamicContext(
   auditState: AuditState,
   agent: string,
@@ -45,7 +112,7 @@ export function buildDynamicContext(
   const executedToolNames = new Set(
     auditState.toolsExecuted.map((t) => TOOL_SHORT_NAMES[t.tool] ?? t.tool),
   )
-  const tools = auditState.toolsExecuted.map((tool) => tool.tool).join(", ") || "none"
+  const findingCountsLine = buildFindingCountsLine(auditState)
   const taskStatus = KEY_TOOLS.map(
     (t) => `${t}=${executedToolNames.has(t) ? "done" : "pending"}`,
   ).join(" ")
@@ -62,7 +129,10 @@ export function buildDynamicContext(
     `Phase: ${auditState.currentPhase}`,
     `Contracts: ${auditState.contractsReviewed.length} reviewed`,
     `Findings: Critical=${severityCounts.Critical} High=${severityCounts.High} Medium=${severityCounts.Medium} Low=${severityCounts.Low} Info=${severityCounts.Informational}`,
-    `Tools: ${tools}`,
+    ...(findingCountsLine ? [findingCountsLine] : []),
+    `Tools: ${buildToolsLine(auditState)}`,
+    `Tool Ledger: ${buildToolLedgerLine(auditState)}`,
+    buildCoverageLine(auditState),
     `Tasks: ${taskStatus}`,
   ]
 

package/src/hooks/tool-tracking-hook.ts

@@ -20,6 +20,7 @@ import type {
   ArgusAgentName,
   AuditState,
   Finding,
+  FindingCounts,
   FindingSeverity,
   FuzzCounterexample,
   SoloditResult,
@@ -465,14 +466,38 @@ function processSoloditResult(parsed: Record<string, unknown>, state: AuditState
   })
 }
 
-function recordToolExecution(state: AuditState, toolName: string, findingsCount: number): void {
+function buildFindingCounts(state: AuditState, findingsCount: number): FindingCounts {
+  return {
+    rawObservations: Math.max(0, findingsCount),
+    recordedFindings: state.findings.length,
+  }
+}
+
+function readErrorReason(record: Record<string, unknown>): string | undefined {
+  if (typeof record.error === "string" && record.error.trim().length > 0) return record.error
+  const errorRecord = toRecord(record.error)
+  if (typeof errorRecord?.message === "string" && errorRecord.message.trim().length > 0) {
+    return errorRecord.message
+  }
+  if (typeof record.stderr === "string" && record.stderr.trim().length > 0) return record.stderr
+  return undefined
+}
+
+function recordToolExecution(
+  state: AuditState,
+  toolName: string,
+  findingsCount: number,
+  success: boolean,
+  findingCounts?: FindingCounts,
+): void {
   const now = Date.now()
   state.toolsExecuted.push({
     tool: toolName,
     startTime: now,
     endTime: now,
-    success: true,
+    success,
     findingsCount,
+    findingCounts,
   })
 }
 
@@ -616,7 +641,7 @@ export function createToolTrackingHook(
       }
 
       if (resolved) {
-        recordToolExecution(resolved.state, "task", 0)
+        recordToolExecution(resolved.state, "task", 0, true, buildFindingCounts(resolved.state, 0))
         onStateChanged?.({ tool: "task", findingsCount: 0, sessionId: input.sessionID })
       }
 
@@ -875,9 +900,16 @@ export function createToolTrackingHook(
             break
           }
           case "argus_forge_coverage": {
+            const now = Date.now()
             const reportObj = toRecord(record.report)
             const files = reportObj?.files
-            if (Array.isArray(files)) {
+            if (record.success === false) {
+              auditState.coverageAttempt = {
+                status: "failed",
+                attemptedAt: now,
+                reason: readErrorReason(record),
+              }
+            } else if (Array.isArray(files)) {
               auditState.coverageReport = {
                 files: files
                   .filter((f): f is Record<string, unknown> => !!f && typeof f === "object")
@@ -889,6 +921,13 @@ export function createToolTrackingHook(
                     functionsPct: typeof f.functionsPct === "number" ? f.functionsPct : 0,
                   })),
               }
+              auditState.coverageAttempt = { status: "run", attemptedAt: now }
+            } else {
+              auditState.coverageAttempt = {
+                status: "failed",
+                attemptedAt: now,
+                reason: "coverage report was missing or invalid",
+              }
             }
             break
           }
@@ -963,10 +1002,12 @@ export function createToolTrackingHook(
           }
         }
 
-        completedSuccess = true
+        completedSuccess = record.success !== false
       }
 
-      recordToolExecution(auditState, input.tool, findingsCount)
+      const findingCounts = buildFindingCounts(auditState, findingsCount)
+      auditState.findingCounts = findingCounts
+      recordToolExecution(auditState, input.tool, findingsCount, completedSuccess, findingCounts)
 
       const nextPhase = inferPhaseAdvancement(auditState, input.tool)
       if (nextPhase) {
@@ -1003,6 +1044,8 @@ export function createToolTrackingHook(
               break
             case "argus_forge_coverage":
               if (auditState.coverageReport) enrichment.coverageReport = auditState.coverageReport
+              if (auditState.coverageAttempt)
+                enrichment.coverageAttempt = auditState.coverageAttempt
               break
             case "argus_gas_analysis":
               if (auditState.gasHotspots) enrichment.gasHotspots = auditState.gasHotspots
@@ -1028,6 +1071,7 @@ export function createToolTrackingHook(
           buildEvent("tool.completed", runId, sessionId, toolCallId, {
             tool: input.tool,
             findingsCount,
+            findingCounts: completedSuccess ? auditState.findingCounts : undefined,
             success: completedSuccess,
             ...(completionError ? { error: completionError } : {}),
             ...enrichment,

package/src/managers/types.ts

@@ -1,5 +1,20 @@
 import type { AuditState } from "../state/types"
 
+export type BackgroundTaskStatus = "queued" | "running" | "completed" | "failed" | "cancelled"
+
+export type BackgroundFailureDiagnostic = {
+  category: "model_error" | "tool_error" | "timeout" | "cancelled" | "unknown"
+  retry_recommendation: "safe_to_retry" | "retry_with_changes" | "do_not_retry"
+  summary: string
+}
+
+export type BackgroundTaskDiagnostic = {
+  status: BackgroundTaskStatus
+  result?: unknown
+  error?: unknown
+  diagnostic?: BackgroundFailureDiagnostic
+}
+
 /**
  * BackgroundManager interface
  * Handles dispatching and managing background agent tasks
@@ -27,6 +42,12 @@ export interface BackgroundManager {
    */
   getResult(taskId: string): Promise<unknown>
 
+  /**
+   * Get task status and structured diagnostics for completed, failed, queued, and cancelled tasks.
+   * Unknown task IDs resolve to undefined.
+   */
+  getTaskStatus(taskId: string): Promise<BackgroundTaskDiagnostic | undefined>
+
   /**
    * Register a callback to be invoked when a task completes
    * @param callback - Function called with (taskId, result) when task finishes

package/src/shared/agent-names.ts

@@ -2,6 +2,7 @@ export const ARGUS_ORCHESTRATOR: ReadonlySet<string> = new Set(["argus"])
 export const ARGUS_SUBAGENTS: ReadonlySet<string> = new Set([
   "sentinel",
   "pythia",
+  "audit-specialist",
   "scribe",
   "themis",
 ])

package/src/shared/lineage-validator.ts

@@ -0,0 +1,96 @@
+import type { CanonicalFinding } from "../state/schemas"
+import type { Finding } from "../state/types"
+
+export type LineageCountMismatch = {
+  check: string
+  observation_count?: number
+  observation_ids_length: number
+}
+
+export type FindingLineageResult = {
+  valid: boolean
+  raw_count: number
+  mapped_count: number
+  duplicate_observation_ids: string[]
+  phantom_observation_ids: string[]
+  missing_observation_ids: string[]
+  count_mismatches: LineageCountMismatch[]
+}
+
+type FindingLike = Pick<Finding, "check"> & {
+  id?: string
+  observation_id?: string
+  observation_ids?: unknown
+  observation_count?: unknown
+}
+
+function sorted(values: Iterable<string>): string[] {
+  return Array.from(new Set(values)).sort((a, b) => a.localeCompare(b))
+}
+
+function observationIds(value: FindingLike): string[] {
+  if (!Array.isArray(value.observation_ids)) return []
+  return value.observation_ids.filter((id): id is string => typeof id === "string" && id.length > 0)
+}
+
+function rawObservationIds(rawFindings: CanonicalFinding[]): string[] {
+  return rawFindings
+    .map((finding) => finding.observation_id)
+    .filter((id): id is string => typeof id === "string" && id.length > 0)
+}
+
+export function validateFindingLineage(
+  rawFindings: CanonicalFinding[],
+  dedupedFindings: FindingLike[],
+): FindingLineageResult {
+  const rawIds = new Set(rawObservationIds(rawFindings))
+  const mappedIds: string[] = []
+  const seen = new Set<string>()
+  const duplicates = new Set<string>()
+  const countMismatches: LineageCountMismatch[] = []
+
+  for (const finding of dedupedFindings) {
+    const ids = observationIds(finding)
+    const suppliedCount = finding.observation_count
+
+    if (ids.length === 0 || (suppliedCount != null && suppliedCount !== ids.length)) {
+      countMismatches.push({
+        check: finding.check || finding.id || "(unknown finding)",
+        observation_count: typeof suppliedCount === "number" ? suppliedCount : undefined,
+        observation_ids_length: ids.length,
+      })
+    }
+
+    for (const id of ids) {
+      mappedIds.push(id)
+      if (seen.has(id)) {
+        duplicates.add(id)
+      }
+      seen.add(id)
+    }
+  }
+
+  const mappedSet = new Set(mappedIds)
+  const phantom = mappedIds.filter((id) => !rawIds.has(id))
+  const missing = Array.from(rawIds).filter((id) => !mappedSet.has(id))
+  const duplicateIds = sorted(duplicates)
+  const phantomIds = sorted(phantom)
+  const missingIds = sorted(missing)
+
+  countMismatches.sort((a, b) => a.check.localeCompare(b.check))
+
+  return {
+    valid:
+      duplicateIds.length === 0 &&
+      phantomIds.length === 0 &&
+      missingIds.length === 0 &&
+      countMismatches.length === 0 &&
+      mappedIds.length === rawIds.size,
+    raw_count: rawIds.size,
+    mapped_count: mappedIds.length,
+    duplicate_observation_ids: duplicateIds,
+    phantom_observation_ids: phantomIds,
+    missing_observation_ids: missingIds,
+    count_mismatches: countMismatches,
+  }
+}

package/src/shared/report-path-resolver.ts

@@ -16,6 +16,8 @@ export interface ReportPathOptions {
   outputDir: string
   /** Optional run_id for run-scoped naming */
   runId?: string
+  /** Optional caller-supplied report revision. Base report is revision 1. */
+  revision?: number
 }
 
 export interface ResolvedReportPath {
@@ -46,7 +48,7 @@ export function sanitizeContractName(name: string): string {
 }
 
 export function resolveReportPath(options: ReportPathOptions): ResolvedReportPath {
-  const { contractName, date, outputDir, runId } = options
+  const { contractName, date, outputDir, runId, revision } = options
 
   if (!contractName || contractName.trim() === "") {
     throw new ReportPathError("contractName must not be empty")
@@ -54,12 +56,16 @@ export function resolveReportPath(options: ReportPathOptions): ResolvedReportPat
   if (!outputDir || outputDir.trim() === "") {
     throw new ReportPathError("outputDir must not be empty")
   }
+  if (revision != null && (!Number.isInteger(revision) || revision < 2)) {
+    throw new ReportPathError("revision must be an integer greater than or equal to 2")
+  }
 
   const resolvedDate = date ?? new Date()
   const dateStr = formatReportDate(resolvedDate)
   const sanitizedName = sanitizeContractName(contractName)
   const runIdSuffix = runId ? `-${runId.substring(0, 8)}` : ""
-  const filename = `${sanitizedName}-security-audit-${dateStr}${runIdSuffix}.md`
+  const revisionSuffix = revision == null ? "" : `-r${revision}`
+  const filename = `${sanitizedName}-security-audit-${dateStr}${runIdSuffix}${revisionSuffix}.md`
   const filePath = join(outputDir, filename)
   const canonicalId = runId ?? filename
 

package/src/state/adapters.ts

@@ -246,9 +246,9 @@ export function normalizeToCanonicalFinding(
       : "manual"
 
   const reportedByAgentRaw =
+    options.reportedByAgent ??
     (typeof input.reported_by_agent === "string" ? input.reported_by_agent : undefined) ??
     (typeof input.reportedByAgent === "string" ? input.reportedByAgent : undefined) ??
-    options.reportedByAgent ??
     "unknown"
   const reportedByAgent: ArgusAgentName = VALID_AGENTS.has(reportedByAgentRaw as ArgusAgentName)
     ? (reportedByAgentRaw as ArgusAgentName)

package/src/state/projectors.ts

@@ -12,7 +12,9 @@ import {
 import type {
   AuditPhase,
   AuditState,
+  CoverageAttemptState,
   Finding,
+  FindingCounts,
   FuzzCounterexample,
   SoloditResult,
   ToolExecution,
@@ -99,6 +101,48 @@ function resolveToolSuccess(payload: Record<string, unknown>): boolean {
   return payload.success !== false
 }
 
+const FINDING_COUNT_FIELDS = [
+  "rawObservations",
+  "recordedFindings",
+  "dedupedFindings",
+  "actionableFindings",
+  "nonActionableFindings",
+] as const
+
+function asFindingCounts(value: unknown): FindingCounts | undefined {
+  if (!isRecord(value)) return undefined
+  const counts: FindingCounts = {}
+  for (const field of FINDING_COUNT_FIELDS) {
+    const count = value[field]
+    if (
+      typeof count === "number" &&
+      Number.isFinite(count) &&
+      Number.isInteger(count) &&
+      count >= 0
+    ) {
+      counts[field] = count
+    }
+  }
+  return Object.keys(counts).length > 0 ? counts : undefined
+}
+
+function asCoverageAttempt(value: unknown): CoverageAttemptState | undefined {
+  if (!isRecord(value)) return undefined
+  if (
+    value.status !== "pending" &&
+    value.status !== "run" &&
+    value.status !== "skipped" &&
+    value.status !== "failed"
+  ) {
+    return undefined
+  }
+  return {
+    status: value.status,
+    attemptedAt: typeof value.attemptedAt === "number" ? value.attemptedAt : undefined,
+    reason: typeof value.reason === "string" ? value.reason : undefined,
+  }
+}
+
 function asStringArray(value: unknown): string[] | undefined {
   if (!Array.isArray(value)) return undefined
   return value.filter((item): item is string => typeof item === "string")
@@ -321,6 +365,7 @@ export function projectToolExecutions(events: AuditEvent[]): CanonicalToolExecut
         endTime: existing?.endTime,
         success: existing?.success ?? false,
         findingsCount: existing?.findingsCount ?? 0,
+        findingCounts: existing?.findingCounts,
       })
       continue
     }
@@ -340,6 +385,7 @@ export function projectToolExecutions(events: AuditEvent[]): CanonicalToolExecut
       endTime: event.timestamp,
       success: resolveToolSuccess(payload),
       findingsCount: resolveFindingsCount(payload),
+      findingCounts: asFindingCounts(payload.findingCounts),
       run_id: event.run_id,
       schema_version: event.schema_version,
     })
@@ -408,6 +454,8 @@ export function projectReportInput(
     asFuzzCounterexamples,
   )
   const coverageReport = extractLatestFromPayload(events, "coverageReport", asCoverageReport)
+  const coverageAttempt = extractLatestFromPayload(events, "coverageAttempt", asCoverageAttempt)
+  const findingCounts = extractLatestFromPayload(events, "findingCounts", asFindingCounts)
   const gasHotspots = extractLatestFromPayload(events, "gasHotspots", asGasHotspots)
   const proxyContracts = extractLatestFromPayload(events, "proxyContracts", asProxyContracts)
   const patternVersion = extractLatestFromPayload(events, "patternVersion", asString)
@@ -424,10 +472,12 @@ export function projectReportInput(
     projectDir,
     findings,
     toolsExecuted,
+    findingCounts,
     scope,
     soloditResults,
     fuzzCounterexamples,
     coverageReport,
+    coverageAttempt,
     gasHotspots,
     proxyContracts,
     patternVersion,

package/src/state/schemas.ts

@@ -8,7 +8,9 @@ import {
 import type {
   ArgusAgentName,
   AuditPhase,
+  CoverageAttemptState,
   Finding,
+  FindingCounts,
   FindingSeverity,
   FuzzCounterexample,
   SoloditResult,
@@ -111,6 +113,7 @@ export interface ReportInput {
   projectDir: string
   findings: CanonicalFinding[]
   toolsExecuted: CanonicalToolExecution[]
+  findingCounts?: FindingCounts
   scope: string[]
   soloditResults?: SoloditResult[]
   fuzzCounterexamples?: FuzzCounterexample[]
@@ -120,6 +123,82 @@ export interface ReportInput {
   patternVersion?: string
   skillsLoaded?: string[]
   unavailableTools?: string[]
+  coverageAttempt?: CoverageAttemptState
+}
+
+const FINDING_COUNT_FIELDS = [
+  "rawObservations",
+  "recordedFindings",
+  "dedupedFindings",
+  "actionableFindings",
+  "nonActionableFindings",
+] as const
+
+const COVERAGE_ATTEMPT_STATUSES = new Set(["pending", "run", "skipped", "failed"])
+
+function pushFindingCountsErrors(errors: ValidationError[], raw: unknown, prefix: string): void {
+  if (raw == null) return
+  if (!isRecord(raw)) {
+    errors.push({
+      field: prefix,
+      code: "invalid",
+      message: `${prefix} must be an object when provided`,
+    })
+    return
+  }
+
+  for (const field of FINDING_COUNT_FIELDS) {
+    const value = raw[field]
+    if (value == null) continue
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+      errors.push({
+        field: `${prefix}.${field}`,
+        code: "invalid",
+        message: `${prefix}.${field} must be a non-negative integer when provided`,
+      })
+    }
+  }
+}
+
+function pushCoverageAttemptErrors(errors: ValidationError[], raw: unknown): void {
+  if (raw == null) return
+  if (!isRecord(raw)) {
+    errors.push({
+      field: "coverageAttempt",
+      code: "invalid",
+      message: "coverageAttempt must be an object when provided",
+    })
+    return
+  }
+
+  if (typeof raw.status !== "string" || !COVERAGE_ATTEMPT_STATUSES.has(raw.status)) {
+    errors.push({
+      field: "coverageAttempt.status",
+      code: "enum",
+      message: "coverageAttempt.status must be one of: pending, run, skipped, failed",
+    })
+  }
+
+  if (
+    raw.attemptedAt != null &&
+    (typeof raw.attemptedAt !== "number" ||
+      !Number.isInteger(raw.attemptedAt) ||
+      raw.attemptedAt <= 0)
+  ) {
+    errors.push({
+      field: "coverageAttempt.attemptedAt",
+      code: "invalid",
+      message: "coverageAttempt.attemptedAt must be a positive integer when provided",
+    })
+  }
+
+  if (raw.reason != null && (typeof raw.reason !== "string" || raw.reason.trim().length === 0)) {
+    errors.push({
+      field: "coverageAttempt.reason",
+      code: "invalid",
+      message: "coverageAttempt.reason must be a non-empty string when provided",
+    })
+  }
 }
 
 function pushRequiredRootStringError(
@@ -253,7 +332,8 @@ export function validateCanonicalFinding(raw: unknown): ValidationResult<Canonic
     errors.push({
       field: "reported_by_agent",
       code: "enum",
-      message: "reported_by_agent must be one of: argus, sentinel, pythia, scribe, unknown",
+      message:
+        "reported_by_agent must be one of: argus, sentinel, pythia, audit-specialist, scribe, unknown",
     })
   }
 
@@ -346,6 +426,8 @@ export function validateCanonicalToolExecution(
     })
   }
 
+  pushFindingCountsErrors(errors, raw.findingCounts, "findingCounts")
+
   if (typeof raw.run_id !== "string" || raw.run_id.trim().length === 0) {
     errors.push({
       field: "run_id",
@@ -400,6 +482,9 @@ export function validateReportInput(raw: unknown): ValidationResult<ReportInput>
     })
   }
 
+  pushFindingCountsErrors(errors, raw.findingCounts, "findingCounts")
+  pushCoverageAttemptErrors(errors, raw.coverageAttempt)
+
   if (!Array.isArray(raw.scope) || !raw.scope.every((item) => typeof item === "string")) {
     errors.push({
       field: "scope",

package/src/state/types.ts

@@ -1,5 +1,11 @@
 export type FindingSeverity = "Critical" | "High" | "Medium" | "Low" | "Informational"
-export type ArgusAgentName = "argus" | "sentinel" | "pythia" | "scribe" | "unknown"
+export type ArgusAgentName =
+  | "argus"
+  | "sentinel"
+  | "pythia"
+  | "audit-specialist"
+  | "scribe"
+  | "unknown"
 export type AuditPhase =
   | "reconnaissance"
   | "scanning"
@@ -88,6 +94,22 @@ export interface ToolExecution {
   endTime?: number
   success: boolean
   findingsCount: number
+  findingCounts?: FindingCounts
+  subagent_type?: string
+}
+
+export interface FindingCounts {
+  rawObservations?: number
+  recordedFindings?: number
+  dedupedFindings?: number
+  actionableFindings?: number
+  nonActionableFindings?: number
+}
+
+export interface CoverageAttemptState {
+  status: "pending" | "run" | "skipped" | "failed"
+  attemptedAt?: number
+  reason?: string
 }
 
 export interface AuditState {
@@ -105,7 +127,9 @@ export interface AuditState {
   skillsLoaded?: string[]
   unavailableTools?: string[]
   reportGenerated?: boolean
+  findingCounts?: FindingCounts
   knowledgeSynced?: { success: boolean; timestamp: number }
+  coverageAttempt?: CoverageAttemptState
   coverageReport?: {
     files: Array<{
       path: string