@pikku/inspector 0.12.56 → 0.12.58

package/dist/utils/workflow/dsl/patterns.js

@@ -57,19 +57,22 @@ export function getScenarioStepPhase(node) {
 /**
  * The expectation helpers that assert without being a `then`.
  *
- * `expectService` and `expectError` are inline steps rather than scenario
- * steps, so they carry no phase and never reach the step meta — but each one is
- * a witness: a recorded service call, or a refusal. PKU680 has to see them, or
- * a scenario whose only assertion is one of these reads as asserting nothing.
+ * `expectService`, `expectError` and `expectScore` are inline steps rather than
+ * scenario steps, so they carry no phase and never reach the step meta — but
+ * each one is a witness: a recorded service call, a refusal, or a graded run.
+ * PKU680 has to see them, or a scenario whose only assertion is one of these
+ * reads as asserting nothing.
  */
 const SCENARIO_EXPECTATION_CALLS = [
     'expectService',
     'expectError',
     'expectEventually',
+    'expectScore',
 ];
 /**
  * Check if a call expression is one of the scenario expectation helpers —
- * `scenario.expectService()`, `.expectError()` or `.expectEventually()`.
+ * `scenario.expectService()`, `.expectError()`, `.expectEventually()` or
+ * `.expectScore()`.
  */
 export function isScenarioExpectationCall(node) {
     return (ts.isPropertyAccessExpression(node.expression) &&

package/dist/visit.js

@@ -29,6 +29,7 @@ import { addVariable } from './add/add-variable.js';
 import { addWorkflowGraph } from './add/add-workflow-graph.js';
 import { addFeature } from './add/add-feature.js';
 import { addAIAgent } from './add/add-ai-agent.js';
+import { addAIScorer } from './add/add-ai-scorer.js';
 import { addApprovalDescription } from './add/add-approval-description.js';
 export const visitSetup = (logger, checker, node, state, options) => {
     addFileExtendsCoreType(node, checker, state.singletonServicesTypeImportMap, 'CoreSingletonServices', state);
@@ -88,5 +89,6 @@ export const visitRoutes = (logger, checker, node, state, options) => {
     addWorkflowGraph(logger, node, checker, state, nextOptions);
     addFeature(logger, node, checker, state, nextOptions);
     addAIAgent(logger, node, checker, state, nextOptions);
+    addAIScorer(logger, node, checker, state, nextOptions);
     ts.forEachChild(node, (child) => visitRoutes(logger, checker, child, state, nextOptions));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.56",
+  "version": "0.12.58",
   "description": "TypeScript inspector for Pikku — discovers functions and wirings to drive code generation",
   "author": "yasser.fadl@gmail.com",
   "license": "BUSL-1.1",
@@ -45,10 +45,10 @@
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.80"
+    "@pikku/core": "^0.12.82"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.80",
+    "@pikku/core": "^0.12.82",
     "@types/node": "^24.11.0"
   },
   "engines": {

package/src/add/add-ai-agent.ts

@@ -330,6 +330,39 @@ function resolveIdentifierToAgentName(
   return null
 }
 
+/**
+ * The scorers an agent asks to be graded by, which are plain names rather than
+ * references: a scorer is resolved out of the registry at grading time, not
+ * imported by the agent, so nothing here has a declaration to chase.
+ */
+function resolveScorerNames(
+  obj: ts.ObjectLiteralExpression,
+  agentName: string,
+  logger: InspectorLogger
+): string[] | null {
+  const property = obj.properties.find(
+    (p) =>
+      ts.isPropertyAssignment(p) &&
+      ts.isIdentifier(p.name) &&
+      p.name.text === 'scorers'
+  )
+  if (!property || !ts.isPropertyAssignment(property)) return null
+  if (!ts.isArrayLiteralExpression(property.initializer)) return null
+
+  const names: string[] = []
+  for (const element of property.initializer.elements) {
+    if (!ts.isStringLiteral(element)) {
+      logger.critical(
+        ErrorCode.INVALID_VALUE,
+        `AI agent '${agentName}' lists a scorer that is not an inline string: \`${element.getText()}\`. A scorer is named, not imported, so the name has to be readable from source.`
+      )
+      continue
+    }
+    names.push(element.text)
+  }
+  return names.length > 0 ? names : null
+}
+
 export const addAIAgent: AddWiring = (
   logger,
   node,
@@ -377,6 +410,7 @@ export const addAIAgent: AddWiring = (
       | number
       | null
     const toolChoiceValue = getPropertyValue(obj, 'toolChoice') as string | null
+    const scorersValue = resolveScorerNames(obj, nameValue || '', logger)
     const toolsValue = resolveToolReferences(
       obj,
       checker,
@@ -582,6 +616,7 @@ export const addAIAgent: AddWiring = (
       ...(toolsValue !== null && { tools: toolsValue }),
       ...(agentsValue !== null && { agents: agentsValue }),
       ...(workflowsValue !== null && { workflows: workflowsValue }),
+      ...(scorersValue !== null && { scorers: scorersValue }),
       tags,
       inputSchema,
       outputSchema,

package/src/add/add-ai-scorer.test.ts

@@ -0,0 +1,197 @@
+import { strict as assert } from 'assert'
+import { describe, test } from 'node:test'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { inspect } from '../inspector.js'
+import { ErrorCode } from '../error-codes.js'
+import type { InspectorLogger } from '../types.js'
+
+const makeLogger = (criticals: Array<{ code: ErrorCode; message: string }>) =>
+  ({
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    diagnostic: ({ code, message }) => {
+      criticals.push({ code, message })
+    },
+    critical: (code: ErrorCode, message: string) => {
+      criticals.push({ code, message })
+    },
+    hasCriticalErrors: () => criticals.length > 0,
+  }) satisfies InspectorLogger
+
+const inspectSources = async (sources: Record<string, string>) => {
+  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-add-ai-scorer-'))
+  const files: Record<string, string> = {}
+  for (const [name, source] of Object.entries(sources)) {
+    files[name] = join(rootDir, name)
+    await writeFile(files[name]!, source)
+  }
+  const criticals: Array<{ code: ErrorCode; message: string }> = []
+  try {
+    const state = await inspect(makeLogger(criticals), Object.values(files), {
+      rootDir,
+    })
+    return { state, criticals }
+  } finally {
+    await rm(rootDir, { recursive: true, force: true })
+  }
+}
+
+const inspectSource = (source: string) =>
+  inspectSources({ 'grading.scorer.ts': source })
+
+describe('addAIScorer', () => {
+  test('reads the lane off which constructor was called, not off a field', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        `export const brevity = pikkuAIScorer({`,
+        `  name: 'brevity',`,
+        `  description: 'Shorter answers score higher',`,
+        `  score: () => ({ score: 1 }),`,
+        `})`,
+        `export const helpfulness = pikkuAIJudge({`,
+        `  name: 'helpfulness',`,
+        `  description: 'Does the answer help',`,
+        `  model: 'claude-opus-5',`,
+        `  goal: 'Grade helpfulness.',`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.deepEqual(criticals, [])
+    assert.equal(state.scorers.scorersMeta['brevity']?.lane, 'fast')
+    assert.equal(state.scorers.scorersMeta['helpfulness']?.lane, 'slow')
+  })
+
+  test('defaults an unstated sample rate to grading every run', async () => {
+    const { state } = await inspectSource(
+      [
+        `export const brevity = pikkuAIScorer({`,
+        `  name: 'brevity',`,
+        `  description: 'Shorter answers score higher',`,
+        `  score: () => ({ score: 1 }),`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.equal(state.scorers.scorersMeta['brevity']?.sampleRate, 1)
+    assert.equal(state.scorers.scorersMeta['brevity']?.requiresReference, false)
+  })
+
+  test('carries the sample rate and the reference requirement into the meta', async () => {
+    const { state } = await inspectSource(
+      [
+        `export const correctness = pikkuAIJudge({`,
+        `  name: 'correctness',`,
+        `  description: 'Is the answer right',`,
+        `  model: 'claude-opus-5',`,
+        `  goal: 'Grade correctness.',`,
+        `  sampleRate: 0.1,`,
+        `  requiresReference: true,`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.equal(state.scorers.scorersMeta['correctness']?.sampleRate, 0.1)
+    assert.equal(
+      state.scorers.scorersMeta['correctness']?.requiresReference,
+      true
+    )
+  })
+
+  test('rejects a sample rate that is not a fraction', async () => {
+    const { state, criticals } = await inspectSource(
+      [
+        `export const brevity = pikkuAIScorer({`,
+        `  name: 'brevity',`,
+        `  description: 'Shorter answers score higher',`,
+        `  sampleRate: 50,`,
+        `  score: () => ({ score: 1 }),`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.equal(criticals[0]?.code, ErrorCode.INVALID_VALUE)
+    assert.match(criticals[0]!.message, /between 0 and 1/)
+    assert.deepEqual(state.scorers.scorersMeta, {})
+  })
+
+  test('a scorer with no description is refused, since the meta is what names it', async () => {
+    const { criticals } = await inspectSource(
+      [
+        `export const brevity = pikkuAIScorer({`,
+        `  name: 'brevity',`,
+        `  score: () => ({ score: 1 }),`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.equal(criticals[0]?.code, ErrorCode.MISSING_DESCRIPTION)
+  })
+
+  test('records where a scorer was declared, so codegen can import it back', async () => {
+    const { state } = await inspectSource(
+      [
+        `export const brevity = pikkuAIScorer({`,
+        `  name: 'brevity',`,
+        `  description: 'Shorter answers score higher',`,
+        `  score: () => ({ score: 1 }),`,
+        `})`,
+      ].join('\n')
+    )
+
+    assert.equal(state.scorers.files.get('brevity')?.exportedName, 'brevity')
+    assert.match(
+      state.scorers.files.get('brevity')?.path ?? '',
+      /grading\.scorer\.ts$/
+    )
+  })
+})
+
+describe('an agent asking to be graded', () => {
+  const scorerFile = [
+    `export const brevity = pikkuAIScorer({`,
+    `  name: 'brevity',`,
+    `  description: 'Shorter answers score higher',`,
+    `  score: () => ({ score: 1 }),`,
+    `})`,
+  ].join('\n')
+
+  const agent = (scorers: string) =>
+    [
+      `export const assistant = pikkuAIAgent({`,
+      `  name: 'assistant',`,
+      `  description: 'Answers questions',`,
+      `  goal: 'Answer the question.',`,
+      `  model: 'anthropic/claude-opus-5',`,
+      `  scorers: [${scorers}],`,
+      `})`,
+    ].join('\n')
+
+  test('carries the named scorers onto the agent meta', async () => {
+    const { state, criticals } = await inspectSources({
+      'grading.scorer.ts': scorerFile,
+      'assistant.agent.ts': agent(`'brevity'`),
+    })
+
+    assert.deepEqual(criticals, [])
+    assert.deepEqual(state.agents.agentsMeta['assistant']?.scorers, ['brevity'])
+  })
+
+  test('naming a scorer that does not exist fails the build rather than grading nothing', async () => {
+    const { criticals } = await inspectSources({
+      'grading.scorer.ts': scorerFile,
+      'assistant.agent.ts': agent(`'brevty'`),
+    })
+
+    const finding = criticals.find(
+      (critical) => critical.code === ErrorCode.AGENT_SCORER_NOT_FOUND
+    )
+    assert.ok(finding, `expected a scorer-not-found critical`)
+    assert.match(finding!.message, /brevty/)
+    assert.match(finding!.message, /Declared scorers: brevity/)
+  })
+})

package/src/add/add-ai-scorer.ts

@@ -0,0 +1,83 @@
+import * as ts from 'typescript'
+import { getPropertyValue } from '../utils/get-property-value.js'
+import type { AddWiring } from '../types.js'
+import { extractFunctionName } from '../utils/extract-function-name.js'
+import { ErrorCode } from '../error-codes.js'
+
+/**
+ * `pikkuAIScorer` grades in code and `pikkuAIJudge` grades with a model, which
+ * is the whole difference between the two lanes — so the lane is read off which
+ * constructor was called rather than from a field an author could contradict.
+ */
+const LANES: Record<string, 'fast' | 'slow'> = {
+  pikkuAIScorer: 'fast',
+  pikkuAIJudge: 'slow',
+}
+
+export const addAIScorer: AddWiring = (logger, node, checker, state) => {
+  if (!ts.isCallExpression(node)) return
+
+  const expression = node.expression
+  if (!ts.isIdentifier(expression)) return
+
+  const lane = LANES[expression.text]
+  if (!lane) return
+
+  const firstArg = node.arguments[0]
+  if (!firstArg || !ts.isObjectLiteralExpression(firstArg)) return
+
+  const obj = firstArg
+  const { exportedName } = extractFunctionName(node, checker, state.rootDir)
+
+  const nameValue = getPropertyValue(obj, 'name') as string | null
+  if (!nameValue) {
+    logger.critical(
+      ErrorCode.MISSING_NAME,
+      "AI scorer is missing the required 'name' property."
+    )
+    return
+  }
+
+  const description = getPropertyValue(obj, 'description') as string | null
+  if (!description) {
+    logger.critical(
+      ErrorCode.MISSING_DESCRIPTION,
+      `AI scorer '${nameValue}' is missing the required 'description' property.`
+    )
+    return
+  }
+
+  const sampleRateValue = getPropertyValue(obj, 'sampleRate') as number | null
+  if (
+    sampleRateValue !== null &&
+    (sampleRateValue < 0 || sampleRateValue > 1)
+  ) {
+    logger.critical(
+      ErrorCode.INVALID_VALUE,
+      `AI scorer '${nameValue}' has a sampleRate of ${sampleRateValue} — it is the fraction of live runs to grade, so it must be between 0 and 1.`
+    )
+    return
+  }
+
+  const requiresReference =
+    (getPropertyValue(obj, 'requiresReference') as boolean | null) ?? false
+
+  const scorerKey = exportedName || nameValue
+
+  if (exportedName) {
+    state.scorers.files.set(scorerKey, {
+      path: node.getSourceFile().fileName,
+      exportedName,
+    })
+  }
+
+  state.scorers.scorersMeta[scorerKey] = {
+    name: nameValue,
+    description,
+    lane,
+    sampleRate: sampleRateValue ?? 1,
+    requiresReference,
+    sourceFile: node.getSourceFile().fileName,
+    exportedName: exportedName || undefined,
+  }
+}

package/src/add/add-scenario-step.test.ts

@@ -243,6 +243,25 @@ describe('pikkuScenarioStep', () => {
     }
   })
 
+  test('a graded agent run is a witness too', async () => {
+    // An agent's answer cannot be matched against a fixed string, so a scenario
+    // that grades one is asserting — even though `expectScore`, like the other
+    // helpers, is an inline step that reaches PKU680 as nothing at all.
+    const { criticals, cleanup } = await run([
+      "const answer = await scenario.when('asks for a summary', 'runAssistant', { prompt: 'hi' }, { actor: actors.shopper })",
+      "await scenario.expectScore('answered briefly', answer.runId, 'brevity', { atLeast: 0.8 })",
+    ])
+    try {
+      assert.equal(
+        criticals.filter((c) => c.code === 'PKU680').length,
+        0,
+        `got: ${JSON.stringify(criticals)}`
+      )
+    } finally {
+      await cleanup()
+    }
+  })
+
   test('an expectation parked in an uncalled helper is still no assertion', async () => {
     const { criticals, cleanup } = await run([
       'const neverCalled = async () => {',

package/src/add/add-wire-addon.test.ts

@@ -61,9 +61,52 @@ describe('addWireAddon', () => {
       secretOverrides: undefined,
       variableOverrides: undefined,
       credentialOverrides: undefined,
+      globalSecrets: undefined,
+      globalCredentials: undefined,
     })
   })
 
+  test('captures the reason an addon was exempted from credential scoping', () => {
+    const declarations = inspect(`
+      wireAddon({
+        name: 'console',
+        package: '@pikku/addon-console',
+        globalCredentials: 'links credentials an operator names at runtime',
+      })
+    `)
+
+    assert.equal(
+      declarations.get('console').globalCredentials,
+      'links credentials an operator names at runtime'
+    )
+  })
+
+  test('captures the reason an addon was exempted from secret scoping', () => {
+    const declarations = inspect(`
+      wireAddon({
+        name: 'console',
+        package: '@pikku/addon-console',
+        globalSecrets: 'administers secrets an operator names at runtime',
+      })
+    `)
+
+    assert.equal(
+      declarations.get('console').globalSecrets,
+      'administers secrets an operator names at runtime'
+    )
+  })
+
+  test('a globalSecrets reason that is not a literal still reports the grant', () => {
+    // Unlike `scopes`, dropping this would under-report: the grant is real at
+    // runtime whatever the reason evaluates to. The source text is recorded so
+    // the manifest names the addon and points at where the reason comes from.
+    const declarations = inspect(`
+      wireAddon({ name: 'console', package: '@x/y', globalSecrets: REASON })
+    `)
+
+    assert.equal(declarations.get('console').globalSecrets, 'REASON')
+  })
+
   test('leaves the gates undefined when none are declared', () => {
     const declarations = inspect(`
       wireAddon({ name: 'console', package: '@pikku/addon-console' })

package/src/add/add-wire-addon.ts

@@ -60,6 +60,8 @@ export function addWireAddon(
   let secretOverrides: Record<string, string> | undefined
   let variableOverrides: Record<string, string> | undefined
   let credentialOverrides: Record<string, string> | undefined
+  let globalSecrets: string | undefined
+  let globalCredentials: string | undefined
 
   for (const prop of firstArg.properties) {
     if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
@@ -102,6 +104,16 @@ export function addWireAddon(
       ts.isObjectLiteralExpression(prop.initializer)
     ) {
       credentialOverrides = parseStringRecord(prop.initializer)
+    } else if (key === 'globalSecrets') {
+      // The grant is real at runtime whatever the reason evaluates to, so a
+      // non-literal is recorded as its source text rather than dropped.
+      globalSecrets = ts.isStringLiteral(prop.initializer)
+        ? prop.initializer.text
+        : prop.initializer.getText()
+    } else if (key === 'globalCredentials') {
+      globalCredentials = ts.isStringLiteral(prop.initializer)
+        ? prop.initializer.text
+        : prop.initializer.getText()
     }
   }
 
@@ -118,6 +130,8 @@ export function addWireAddon(
     secretOverrides,
     variableOverrides,
     credentialOverrides,
+    globalSecrets,
+    globalCredentials,
   })
   state.rpc.usedAddons.add(name)
   state.rpc.wireAddonFiles.add(node.getSourceFile().fileName)

package/src/add/scenario-instrumentation.ts

@@ -13,12 +13,18 @@
  * `pikku dev` registers the implementations itself. Ignoring by name (rather
  * than deleting the scaffold and requiring every project to regenerate) is what
  * keeps an existing project's checked-in `scenarios.gen.ts` from deploying.
+ *
+ * `pikkuScenarioGradeRun` was never scaffolded — it arrived after the split —
+ * but it belongs here for the same reason: grading a run on demand, ignoring the
+ * sample rate that governs live traffic, is a thing you do to a development
+ * server, and the name is reserved so an application cannot claim it.
  */
 export const SCENARIO_INSTRUMENTATION_FUNCTIONS = [
   'pikkuScenarioTakeLiveCoverage',
   'pikkuScenarioResetLiveCoverage',
   'pikkuScenarioResetStubs',
   'pikkuScenarioGetStubCalls',
+  'pikkuScenarioGradeRun',
 ] as const
 
 export type ScenarioInstrumentationFunction =

package/src/error-codes.ts

@@ -91,6 +91,9 @@ export enum ErrorCode {
   AGENT_TOOL_NOT_FOUND = 'PKU153',
   AGENT_TOOL_MISSING_DESCRIPTION = 'PKU154',
 
+  // Agent scorer reference errors
+  AGENT_SCORER_NOT_FOUND = 'PKU155',
+
   // File structure errors
   SCHEMA_AND_WIRING_COLOCATED = 'PKU490',
 

package/src/inspector.ts

@@ -16,6 +16,7 @@ import {
   stampAuthHandlerServices,
   validateAgentModels,
   validateAgentToolReferences,
+  validateAgentScorerReferences,
   validateSecretOverrides,
   validateVariableOverrides,
   validateCredentialOverrides,
@@ -28,7 +29,6 @@ import {
   computeMiddlewareGroupsMeta,
   computePermissionsGroupsMeta,
   computeRequiredSchemas,
-  computeSecretBrokers,
   validateNoSecretAliasServices,
   validateSecretUsage,
   computeDiagnostics,
@@ -160,6 +160,10 @@ export function getInitialInspectorState(rootDir: string): InspectorState {
       agentsMeta: {},
       files: new Map(),
     },
+    scorers: {
+      scorersMeta: {},
+      files: new Map(),
+    },
     cli: {
       meta: {
         programs: {},
@@ -484,7 +488,6 @@ export const inspect = async (
     computeResolvedIOTypes(state)
     computeMiddlewareGroupsMeta(state)
     computePermissionsGroupsMeta(state)
-    computeSecretBrokers(state)
     validateNoSecretAliasServices(logger, checker, state)
     validateSecretUsage(logger, state)
     computeDiagnostics(state)
@@ -511,8 +514,9 @@ export const inspect = async (
       )
     }
 
-    validateAgentModels(logger, state)
+    validateAgentModels(logger, state, options.modelAliases)
     validateAgentToolReferences(logger, state, options)
+    validateAgentScorerReferences(logger, state)
     validateSecretOverrides(logger, state)
     validateVariableOverrides(logger, state)
     validateCredentialOverrides(logger, state)

package/src/types.ts

@@ -13,6 +13,7 @@ import type {
   MCPPromptMeta,
 } from '@pikku/core/mcp'
 import type { AIAgentMeta } from '@pikku/core/ai-agent'
+import type { ScorerMeta } from '@pikku/core/ai-scorer'
 import type { CLIMeta } from '@pikku/core/cli'
 import type { CLICommandMeta } from '@pikku/core/cli'
 import type { NodesMeta } from '@pikku/core/node'
@@ -298,6 +299,8 @@ export type InspectorOptions = Partial<{
    * tool's own name, so this is a quality gate rather than a correctness one.
    */
   strictMeta: boolean
+  /** The `models` table from pikku.config.json, alias -> `provider/model`. */
+  modelAliases: Record<string, string>
   sourceFile: ts.SourceFile
   /**
    * The project's tsconfig, read for its path mappings only. The inspector's
@@ -585,6 +588,16 @@ export interface InspectorState {
         secretOverrides?: Record<string, string>
         variableOverrides?: Record<string, string>
         credentialOverrides?: Record<string, string>
+        /**
+         * The app's stated reason for handing this instance the whole
+         * `SecretService` instead of one scoped to its declared secrets.
+         */
+        globalSecrets?: string
+        /**
+         * The app's stated reason for handing this instance the whole
+         * `CredentialService` instead of one scoped to its declared credentials.
+         */
+        globalCredentials?: string
       }
     >
     wireAddonFiles: Set<string>
@@ -599,6 +612,10 @@ export interface InspectorState {
     agentsMeta: AIAgentMeta
     files: Map<string, { path: string; exportedName: string }>
   }
+  scorers: {
+    scorersMeta: ScorerMeta
+    files: Map<string, { path: string; exportedName: string }>
+  }
   cli: {
     meta: CLIMeta
     files: Set<string>

package/src/utils/filter-inspector-state.ts

@@ -419,6 +419,14 @@ export function filterInspectorState(
       agentsMeta: JSON.parse(JSON.stringify(state.agents?.agentsMeta ?? {})),
       files: new Map(),
     },
+    // Scorers carry through every filter. They are named by the agents that
+    // survive it, and a deployment that quietly stopped grading would look
+    // exactly like one whose scorers all returned nothing.
+    scorers: {
+      ...state.scorers,
+      scorersMeta: JSON.parse(JSON.stringify(state.scorers?.scorersMeta ?? {})),
+      files: new Map(state.scorers?.files ?? []),
+    },
     rpc: {
       ...state.rpc,
       internalMeta: { ...state.rpc.internalMeta }, // Clone to avoid mutating original