dsh-harbor-evolution 0.7.3 → 0.8.0

package/lib/session-diagnostic.js

@@ -0,0 +1,320 @@
+import path from 'node:path'
+
+import { buildHistoricalGenerationBatch, writePrivateHistoricalBatch } from './session-materializer.js'
+import { buildSessionObservation } from './session-redaction.js'
+import {
+  canonicalDigest,
+  SessionSelectionTokenStore,
+  selectRecentSessions,
+  verifySessionSnapshot,
+} from './session-selection.js'
+
+function capability(ctx, name) {
+  try {
+    return typeof ctx?.get === 'function' ? ctx.get(name) ?? ctx[name] : ctx?.[name]
+  } catch {
+    return ctx?.[name]
+  }
+}
+
+function executionIdentity(exec) {
+  const header = exec?.agent?.session?.header
+  if (typeof header?.cwd !== 'string' || !path.isAbsolute(header.cwd)) {
+    throw new Error('Harbor Session tools require an Agent Session with an absolute working directory')
+  }
+  if (typeof header.id !== 'string' || !header.id) {
+    throw new Error('Harbor Session tools require the calling Agent Session identity')
+  }
+  return { projectRoot: path.resolve(header.cwd), ownerSessionId: header.id }
+}
+
+function feedbackItems(result) {
+  return result?.ok === true && Array.isArray(result.value?.items) ? result.value.items : []
+}
+
+async function readFeedback(service, sessionId) {
+  if (!service || typeof service.list !== 'function') return { items: [], available: false, failed: false }
+  try {
+    const result = await service.list({ sessionId })
+    return {
+      items: feedbackItems(result),
+      available: result?.ok === true,
+      failed: result?.ok === false,
+    }
+  } catch {
+    return { items: [], available: true, failed: true }
+  }
+}
+
+function withoutRawEvents(selection) {
+  const { events: _events, ...rest } = selection
+  return rest
+}
+
+function parseCreatedAfter(value) {
+  if (value === undefined || value === null || value === '') return undefined
+  if (typeof value !== 'string') {
+    throw new Error('SESSION_CREATED_AFTER_INVALID: createdAfter must be an ISO-8601 string')
+  }
+  const parsed = Date.parse(value)
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new Error('SESSION_CREATED_AFTER_INVALID: createdAfter must be a valid ISO-8601 timestamp')
+  }
+  return parsed
+}
+
+function feedbackDigest(observation) {
+  return canonicalDigest(
+    {
+      available: observation.available,
+      failed: observation.failed,
+      items: observation.items,
+    },
+    'harbor-dsh-session-feedback-snapshot-v1',
+  )
+}
+
+function requestedJudge(args) {
+  if (Boolean(args.evaluatorProvider) !== Boolean(args.evaluatorModel)) {
+    throw new Error('EVALUATOR_MODEL_INVALID: evaluatorProvider and evaluatorModel must be supplied together')
+  }
+  if (args.evaluatorReasoningEffort !== undefined && !args.evaluatorProvider) {
+    throw new Error('EVALUATOR_MODEL_INVALID: evaluatorReasoningEffort requires an explicit evaluatorProvider and evaluatorModel')
+  }
+  return {
+    candidateProvider: args.evaluatorProvider,
+    candidateModel: args.evaluatorModel,
+    candidateReasoningEffort: args.evaluatorReasoningEffort,
+  }
+}
+
+async function resolveJudge(modelRuntime, args) {
+  const requested = requestedJudge(args)
+  if (requested.candidateProvider) return modelRuntime.resolve(requested)
+  if (typeof modelRuntime.resolveCurrent === 'function') {
+    return modelRuntime.resolveCurrent()
+  }
+  const current = await modelRuntime.currentBinding()
+  return modelRuntime.resolve({
+    candidateProvider: current.provider,
+    candidateModel: current.model,
+    candidateReasoningEffort: current.reasoning_effort,
+  })
+}
+
+function judgeIdentity(binding, selections) {
+  if (!binding?.provider || !binding?.model) {
+    throw new Error('EVALUATOR_MODEL_INVALID: Judge resolution returned no provider/model identity')
+  }
+  const route = `${binding.provider}/${binding.model}`
+  const generatorRoutes = new Set(
+    selections.flatMap(item => item.index.modelRoutes.map(value => `${value.provider}/${value.model}`)),
+  )
+  return {
+    evaluator: { id: 'dsh-session-historical-evaluator', version: '1.0.0' },
+    judge: {
+      provider: binding.provider,
+      model: binding.model,
+      ...(binding.reasoning_effort === undefined
+        ? {}
+        : { reasoning_effort: binding.reasoning_effort }),
+      transport: 'dsh-host-broker',
+      protocol: 'dsh-host-model-gateway/v1',
+    },
+    coupling: generatorRoutes.size === 0
+      ? 'generator-model-unknown-diagnostic-only'
+      : generatorRoutes.has(route)
+        ? 'same-host-model-diagnostic-only'
+        : 'independent-historical-judge',
+  }
+}
+
+export class SessionDiagnosticService {
+  constructor({
+    ctx,
+    config,
+    modelRuntime,
+    runHistoricalEvaluation,
+    tokenStore,
+    now = () => new Date(),
+  }) {
+    this.ctx = ctx
+    this.config = config
+    this.modelRuntime = modelRuntime
+    this.runHistoricalEvaluation = runHistoricalEvaluation
+    this.tokens = tokenStore ?? new SessionSelectionTokenStore()
+    this.now = now
+  }
+
+  async preview(args = {}, exec) {
+    const identity = executionIdentity(exec)
+    const sessionQuery = capability(this.ctx, 'sessionQuery')
+    const limit = args.limit ?? 10
+    const createdAfter = parseCreatedAfter(args.createdAfter)
+    const result = await selectRecentSessions({
+      sessionQuery,
+      projectRoot: identity.projectRoot,
+      currentSessionId: identity.ownerSessionId,
+      limit,
+      maxSessionReads: this.config.sessionMaxReads ?? 100,
+      concurrency: this.config.sessionReadConcurrency ?? 4,
+      createdAfter,
+      signal: exec?.signal,
+    })
+    if (!result.selected.length) {
+      throw new Error('NO_ELIGIBLE_SESSIONS: no completed top-level DSH Sessions with direct human input and assistant output were found in this workspace')
+    }
+    const judgeBinding = await resolveJudge(this.modelRuntime, args)
+    const includeFeedback = args.includeFeedback !== false
+    const feedback = capability(this.ctx, 'messageFeedback')
+    const feedbackObservations = includeFeedback
+      ? await Promise.all(result.selected.map(item => readFeedback(feedback, item.rawSessionId)))
+      : result.selected.map(() => ({ items: [], available: false, failed: false }))
+    const feedbackSnapshots = feedbackObservations.map(observation => ({
+      available: observation.available,
+      failed: observation.failed,
+      digest: feedbackDigest(observation),
+    }))
+    const selected = result.publicSelected.map((item, index) => ({
+      ...item,
+      feedback: {
+        available: feedbackObservations[index].available,
+        positive: feedbackObservations[index].items.filter(value => value.rating === 'positive').length,
+        negative: feedbackObservations[index].items.filter(value => value.rating === 'negative').length,
+      },
+    }))
+    const evaluation = judgeIdentity(judgeBinding, result.selected)
+    const issued = this.tokens.issue({
+      ...identity,
+      selection: result.selected.map(withoutRawEvents),
+      feedbackSnapshots,
+      judgeBinding,
+      evaluation,
+      parameters: { limit, includeFeedback, createdAfter, scope: 'exact-cwd', order: 'last-activity-desc' },
+    })
+    const warnings = [...result.warnings]
+    if (feedbackObservations.some(item => item.failed)) {
+      warnings.push('Some Message Feedback could not be read; the Session sample remains usable without it.')
+    }
+    warnings.push('Frozen Session observations remain local under .harbor/private and the Harbor jobs directory; review repository ignore and retention policy before committing artifacts.')
+    return {
+      schema_version: 1,
+      capability: 'historical-generation-evaluation',
+      jobKind: 'historical-generation-evaluation',
+      projectRoot: identity.projectRoot,
+      scope: 'exact-cwd',
+      order: 'last-activity-desc',
+      ...(createdAfter === undefined ? {} : { createdAfter: new Date(createdAfter).toISOString() }),
+      executionMode: 'observe-existing',
+      promotionEligible: false,
+      evaluationLevel: 'trial',
+      selectionToken: issued.token,
+      expiresAt: new Date(issued.expiresAt).toISOString(),
+      selected,
+      excludedCounts: result.excludedCounts,
+      warnings,
+      estimatedJudgeRequests: selected.length,
+      estimatedMaxBytes: selected.length * 512 * 1024,
+      evaluation,
+      retention: {
+        privateEvidence: '.harbor/private/session-batches',
+        jobEvidence: this.config.jobsDir ?? 'jobs',
+        vcsPolicy: 'an ignore-all file is created only when .harbor/private/.gitignore is absent; existing private rules and jobs retention/VCS policy remain project-owned',
+      },
+      confirmation: `Run 1 historical-generation-evaluation Job with ${selected.length} immutable Trial(s) using ${evaluation.evaluator.id}@${evaluation.evaluator.version} and Judge ${evaluation.judge.provider}/${evaluation.judge.model} (${evaluation.coupling}); no Candidate will be executed or promoted.`,
+    }
+  }
+
+  async run(args = {}, exec) {
+    const identity = executionIdentity(exec)
+    if (args.stackPath !== undefined) {
+      throw new Error('HISTORICAL_CUSTOM_STACK_UNSUPPORTED: the first release binds the materialized Broker Evaluator and Stack as one immutable unit')
+    }
+    if (
+      args.evaluatorProvider !== undefined
+      || args.evaluatorModel !== undefined
+      || args.evaluatorReasoningEffort !== undefined
+    ) {
+      throw new Error('HISTORICAL_JUDGE_NOT_CONFIRMED: choose the Judge during Preview, then Run with only the confirmed selectionToken')
+    }
+    const token = String(args.selectionToken ?? '')
+    if (!token) throw new Error('selectionToken is required; call harbor_session_diagnostic_preview first')
+    const selectedState = this.tokens.consume(token, identity)
+    const sessionQuery = capability(this.ctx, 'sessionQuery')
+    if (!sessionQuery || typeof sessionQuery.readSession !== 'function') {
+      throw new Error('DSH_SESSION_QUERY_UNAVAILABLE: this DSH Profile does not expose the Session Query service')
+    }
+    const reads = await Promise.allSettled(
+      selectedState.selection.map(item => sessionQuery.readSession(item.rawSessionId)),
+    )
+    if (reads.some(item => item.status === 'rejected')) {
+      throw new Error('SESSION_SOURCE_READ_FAILED: at least one selected Session could not be re-read; no Batch was written')
+    }
+    const snapshots = reads.map(item => item.value)
+    if (snapshots.some((snapshot, index) => (
+      !verifySessionSnapshot(selectedState.selection[index], snapshot, identity.projectRoot)
+    ))) {
+      throw new Error('SESSION_SAMPLE_CHANGED: at least one selected Session changed after Preview; no Batch was written, preview again')
+    }
+    const feedback = capability(this.ctx, 'messageFeedback')
+    const feedbackObservations = selectedState.parameters.includeFeedback
+      ? await Promise.all(selectedState.selection.map(item => readFeedback(feedback, item.rawSessionId)))
+      : selectedState.selection.map(() => ({ items: [] }))
+    if (selectedState.parameters.includeFeedback) {
+      for (let index = 0; index < feedbackObservations.length; index += 1) {
+        const expected = selectedState.feedbackSnapshots[index]
+        const observed = feedbackObservations[index]
+        if (!expected || feedbackDigest(observed) !== expected.digest) {
+          throw new Error('SESSION_FEEDBACK_CHANGED: Message Feedback changed after Preview; no Batch was written, preview again')
+        }
+      }
+    }
+    const frozenSelections = selectedState.selection.map((item, index) => ({
+      ...item,
+      events: snapshots[index].events,
+    }))
+    const observations = frozenSelections.map((item, index) => (
+      buildSessionObservation(item, feedbackObservations[index].items)
+    ))
+    const judgeBinding = selectedState.judgeBinding
+    if (!judgeBinding?.provider || !judgeBinding?.model) {
+      throw new Error('HISTORICAL_JUDGE_NOT_CONFIRMED: preview again to freeze a valid Judge identity before writing the Batch')
+    }
+    const batch = buildHistoricalGenerationBatch({
+      projectRoot: identity.projectRoot,
+      selections: frozenSelections,
+      observations,
+      limit: selectedState.parameters.limit,
+      createdAfter: selectedState.parameters.createdAfter,
+      now: this.now(),
+    })
+    const written = await writePrivateHistoricalBatch({
+      projectRoot: identity.projectRoot,
+      batch,
+      observations,
+    })
+    const result = await this.runHistoricalEvaluation(
+      { ...this.config, projectRoot: identity.projectRoot },
+      {
+        batchPath: written.batchPath,
+        batchDir: written.batchDir,
+        jobName: args.jobName,
+        judgeBinding,
+      },
+      this.modelRuntime,
+    )
+    return {
+      schema_version: 1,
+      jobKind: 'historical-generation-evaluation',
+      executionMode: 'observe-existing',
+      promotionEligible: false,
+      batch: {
+        id: batch.batch_id,
+        digest: batch.digest,
+        recordCount: batch.records.length,
+        path: path.relative(identity.projectRoot, written.batchPath).split(path.sep).join('/'),
+      },
+      ...result,
+    }
+  }
+}

package/lib/session-materializer.js

@@ -0,0 +1,194 @@
+import { chmod, lstat, mkdir, mkdtemp, realpath, rename, rm, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { canonicalDigest } from './session-selection.js'
+import { DEFAULT_REDACTION_POLICY } from './session-redaction.js'
+
+function isoCompact(now) {
+  return now.toISOString().replace(/\.\d{3}Z$/, 'Z').replace(/[-:]/g, '')
+}
+
+function routeName(route) {
+  return `${route.provider}/${route.model}`
+}
+
+export function buildHistoricalGenerationBatch({ projectRoot, selections, observations, limit = 10, createdAfter, now = new Date() }) {
+  if (!Array.isArray(selections) || !selections.length || selections.length > 10) {
+    throw new Error('HISTORICAL_BATCH_SIZE_INVALID: a batch requires 1 to 10 Session observations')
+  }
+  if (!Array.isArray(observations) || observations.length !== selections.length) {
+    throw new Error('HISTORICAL_BATCH_OBSERVATION_MISMATCH')
+  }
+  const seed = canonicalDigest(
+    observations.map(observation => observation.digest),
+    'harbor-dsh-historical-batch-id-v1',
+  ).slice('sha256:'.length, 'sha256:'.length + 8)
+  const batchId = `recent-${isoCompact(now)}-${seed}`.toLowerCase()
+  const records = selections.map((selection, index) => {
+    const observation = observations[index]
+    if (observation.trial_id !== selection.trialId) {
+      throw new Error('HISTORICAL_BATCH_TRIAL_ID_MISMATCH')
+    }
+    return {
+      trial_id: selection.trialId,
+      record_kind: 'dsh-session',
+      source_ref: selection.sourceRef,
+      captured_through_seq: selection.capturedThroughSeq,
+      source_digest: selection.sourceDigest,
+      observation_digest: observation.digest,
+      last_activity_at: observation.source.last_activity_at,
+      generator: {
+        agent_preset: observation.generator.agent_preset,
+        model_routes: [...new Map(observation.generator.model_segments.map(segment => {
+          const route = {
+            provider: segment.provider,
+            model: segment.model,
+            ...(segment.reasoning_effort ? { reasoning_effort: segment.reasoning_effort } : {}),
+          }
+          return [routeName(route), route]
+        })).values()],
+        homogeneous: new Set(observation.generator.model_segments.map(routeName)).size <= 1,
+      },
+      observation_path: `sessions/${selection.trialId}.json`,
+    }
+  })
+  const presets = [...new Set(records.map(record => record.generator.agent_preset).filter(Boolean))].sort()
+  const routes = [...new Set(records.flatMap(record => record.generator.model_routes.map(routeName)))].sort()
+  const batch = {
+    schema_version: 1,
+    protocol: 'historical-generation-batch/v1',
+    batch_id: batchId,
+    created_at: now.toISOString(),
+    project: {
+      cwd_digest: canonicalDigest({ cwd: path.resolve(projectRoot) }, 'harbor-dsh-project-cwd-v1'),
+    },
+    selection: {
+      scope: 'exact-cwd',
+      order: 'last-activity-desc',
+      requested_limit: limit,
+      selected_count: records.length,
+      current_session_excluded: true,
+      ...(createdAfter === undefined ? {} : { created_after: new Date(createdAfter).toISOString() }),
+    },
+    source: {
+      kind: 'dsh-session',
+      adapter: 'dsh-session-query',
+      session_format_versions: [...new Set(selections.map(item => item.header.version))].sort(),
+    },
+    redaction_policy: DEFAULT_REDACTION_POLICY,
+    records,
+    generator_population: {
+      homogeneous: presets.length <= 1 && routes.length <= 1,
+      agent_presets: presets,
+      model_routes: routes,
+    },
+  }
+  const serialized = JSON.stringify(batch)
+  for (const selection of selections) {
+    const canary = String(selection.rawSessionId ?? '')
+    if (canary.length >= 8 && serialized.includes(canary)) {
+      throw new Error('SESSION_REDACTION_FAILED: a raw Session id survived Batch materialization')
+    }
+  }
+  batch.digest = canonicalDigest(batch, 'harbor-dsh-historical-generation-batch-v1')
+  return batch
+}
+
+async function writePrivateJson(pathname, value) {
+  await writeFile(pathname, `${JSON.stringify(value, null, 2)}\n`, {
+    encoding: 'utf8',
+    mode: 0o600,
+    flag: 'wx',
+  })
+  await chmod(pathname, 0o600)
+}
+
+function unsafePrivateEvidencePath(label) {
+  return new Error(
+    `PRIVATE_EVIDENCE_PATH_UNSAFE: ${label} must be a real directory inside projectRoot, not a symlink or non-directory`,
+  )
+}
+
+async function ensureSafeDirectory(directory, {
+  parentReal,
+  label,
+  mode = 0o700,
+  enforceMode = true,
+}) {
+  try {
+    await mkdir(directory, { mode })
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error
+  }
+  const details = await lstat(directory)
+  if (details.isSymbolicLink() || !details.isDirectory()) {
+    throw unsafePrivateEvidencePath(label)
+  }
+  const resolved = await realpath(directory)
+  if (path.dirname(resolved) !== parentReal) {
+    throw unsafePrivateEvidencePath(label)
+  }
+  if (enforceMode) await chmod(directory, mode)
+  return resolved
+}
+
+export async function writePrivateHistoricalBatch({ projectRoot, batch, observations }) {
+  const resolvedProjectRoot = path.resolve(projectRoot)
+  const projectReal = await realpath(resolvedProjectRoot)
+  const projectDetails = await lstat(projectReal)
+  if (!projectDetails.isDirectory()) {
+    throw unsafePrivateEvidencePath('projectRoot')
+  }
+  const harborRoot = path.join(resolvedProjectRoot, '.harbor')
+  const harborReal = await ensureSafeDirectory(harborRoot, {
+    parentReal: projectReal,
+    label: '.harbor',
+    enforceMode: false,
+  })
+  const privateRoot = path.join(harborRoot, 'private')
+  const privateReal = await ensureSafeDirectory(privateRoot, {
+    parentReal: harborReal,
+    label: '.harbor/private',
+  })
+  const batchesRoot = path.join(privateRoot, 'session-batches')
+  try {
+    await writeFile(path.join(privateRoot, '.gitignore'), '*\n!.gitignore\n', {
+      encoding: 'utf8', mode: 0o600, flag: 'wx',
+    })
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error
+  }
+  await ensureSafeDirectory(batchesRoot, {
+    parentReal: privateReal,
+    label: '.harbor/private/session-batches',
+  })
+  const staging = await mkdtemp(path.join(batchesRoot, '.staging-'))
+  const target = path.join(batchesRoot, batch.batch_id)
+  try {
+    await chmod(staging, 0o700)
+    const sessions = path.join(staging, 'sessions')
+    await mkdir(sessions, { mode: 0o700 })
+    for (const observation of observations) {
+      await writePrivateJson(path.join(sessions, `${observation.trial_id}.json`), observation)
+    }
+    const redactionReport = {
+      schema_version: 1,
+      policy: batch.redaction_policy,
+      sessions: observations.map(observation => ({
+        trial_id: observation.trial_id,
+        ...observation.redaction,
+      })),
+    }
+    await writePrivateJson(path.join(staging, 'session-redaction-report.json'), redactionReport)
+    await writePrivateJson(path.join(staging, 'historical-generation-batch.json'), batch)
+    await rename(staging, target)
+    return {
+      batchDir: target,
+      batchPath: path.join(target, 'historical-generation-batch.json'),
+      redactionReportPath: path.join(target, 'session-redaction-report.json'),
+    }
+  } catch (error) {
+    await rm(staging, { recursive: true, force: true })
+    throw error
+  }
+}

package/lib/session-projection.js

@@ -0,0 +1,161 @@
+function isAppendOrigin(event) {
+  return event?.surfaceOp === undefined || event.surfaceOp === 'append'
+}
+
+function finiteInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : undefined
+}
+
+function visibleTextBlocks(message) {
+  return Array.isArray(message?.content)
+    ? message.content.filter(block => block?.type === 'text' && typeof block.text === 'string' && block.text.trim())
+    : []
+}
+
+function routeKey(route) {
+  return `${route.provider}\u0000${route.model}\u0000${route.reasoning_effort ?? ''}`
+}
+
+/**
+ * Resolve the composition that actually produced the Session history.
+ *
+ * DSH freezes the creation-time preset in the Session header, but a blank
+ * Session may select another preset before its first turn. That selection is
+ * durable evidence and the newest `agent-preset/selected` event wins.
+ */
+export function resolveEffectiveAgentPreset(header, events) {
+  for (let index = Array.isArray(events) ? events.length - 1 : -1; index >= 0; index -= 1) {
+    const event = events[index]
+    if (event?.type === 'agent-preset/selected') {
+      return typeof event.data?.agentPreset === 'string'
+        ? event.data.agentPreset
+        : undefined
+    }
+  }
+  return typeof header?.agentPreset === 'string' ? header.agentPreset : undefined
+}
+
+/**
+ * Fold only non-content selection facts from a validated DSH Session log.
+ * Transcript text deliberately never enters this projection.
+ */
+export function foldSessionDiagnosticIndex(events, header) {
+  const openTurns = new Set()
+  const seenTurns = new Set()
+  const headerRouteEvents = []
+  const contextRouteEvents = []
+  const assistantRouteEvents = []
+  let lastActivityAt = 0
+  let lastSeq = null
+  let humanMessageCount = 0
+  let assistantMessageCount = 0
+  let lastTurnReason = null
+  let hasHarborToolCall = false
+  let toolCallCount = 0
+
+  for (const event of Array.isArray(events) ? events : []) {
+    const seq = finiteInteger(event?.seq)
+    const time = finiteInteger(event?.time)
+    if (seq !== undefined) lastSeq = lastSeq === null ? seq : Math.max(lastSeq, seq)
+    if (time !== undefined) lastActivityAt = Math.max(lastActivityAt, time)
+
+    if (event?.type === 'turn/start') {
+      const turn = finiteInteger(event.data?.turn)
+      if (turn !== undefined) {
+        openTurns.add(turn)
+        seenTurns.add(turn)
+      }
+    } else if (event?.type === 'turn/end') {
+      const turn = finiteInteger(event.data?.turn)
+      if (turn !== undefined) {
+        openTurns.delete(turn)
+        seenTurns.add(turn)
+      }
+      lastTurnReason = typeof event.data?.reason?.kind === 'string'
+        ? event.data.reason.kind
+        : null
+    } else if (event?.type === 'user/message' && isAppendOrigin(event)) {
+      if (event.data?.source?.kind === 'user' && visibleTextBlocks(event.data).length) {
+        humanMessageCount += 1
+      }
+    } else if (event?.type === 'assistant/message' && isAppendOrigin(event)) {
+      if (visibleTextBlocks(event.data?.message).length) assistantMessageCount += 1
+      const source = event.data?.message?.source
+      if (source?.kind === 'model' && typeof source.provider === 'string' && typeof source.model === 'string') {
+        const route = { provider: source.provider, model: source.model }
+        assistantRouteEvents.push({ seq: seq ?? 0, ...route })
+      }
+    } else if (event?.type === 'tool/call') {
+      toolCallCount += 1
+      const name = String(event.data?.name ?? '')
+      if (name.startsWith('harbor_')) hasHarborToolCall = true
+    } else if (event?.type === 'request/context') {
+      const { provider, model } = event.data ?? {}
+      if (typeof provider === 'string' && typeof model === 'string') {
+        const route = { provider, model }
+        contextRouteEvents.push({ seq: seq ?? 0, ...route })
+      }
+    } else if (event?.type === 'request/header') {
+      const config = event.data?.header?.config
+      if (typeof config?.provider === 'string' && typeof config?.model === 'string') {
+        const route = {
+          provider: config.provider,
+          model: config.model,
+          ...(typeof config.reasoningEffort === 'string'
+            ? { reasoning_effort: config.reasoningEffort }
+            : {}),
+        }
+        headerRouteEvents.push({ seq: seq ?? 0, ...route })
+      }
+    }
+  }
+
+  // request/header is the canonical full request identity. Fall back to
+  // request/context or assembled assistant provenance only for older logs.
+  const routeEvents = headerRouteEvents.length
+    ? headerRouteEvents
+    : contextRouteEvents.length ? contextRouteEvents : assistantRouteEvents
+  const modelSegments = []
+  for (const route of routeEvents) {
+    const previous = modelSegments.at(-1)
+    if (previous && routeKey(previous) === routeKey(route)) continue
+    modelSegments.push({
+      from_seq: route.seq,
+      through_seq: lastSeq ?? route.seq,
+      provider: route.provider,
+      model: route.model,
+      ...(route.reasoning_effort ? { reasoning_effort: route.reasoning_effort } : {}),
+    })
+  }
+  for (let index = 0; index < modelSegments.length - 1; index += 1) {
+    modelSegments[index].through_seq = Math.max(
+      modelSegments[index].from_seq,
+      modelSegments[index + 1].from_seq - 1,
+    )
+  }
+  const routes = new Map()
+  for (const segment of modelSegments) {
+    const route = {
+      provider: segment.provider,
+      model: segment.model,
+      ...(segment.reasoning_effort ? { reasoning_effort: segment.reasoning_effort } : {}),
+    }
+    routes.set(routeKey(route), route)
+  }
+
+  const effectiveAgentPreset = resolveEffectiveAgentPreset(header, events)
+  return {
+    lastActivityAt,
+    lastSeq,
+    openTurn: openTurns.size > 0,
+    turnCount: seenTurns.size,
+    humanMessageCount,
+    assistantMessageCount,
+    toolCallCount,
+    lastTurnReason,
+    hasHarborToolCall,
+    ...(effectiveAgentPreset === undefined ? {} : { effectiveAgentPreset }),
+    modelRoutes: [...routes.values()].sort((left, right) => routeKey(left).localeCompare(routeKey(right))),
+    modelSegments,
+  }
+}