dsh-harbor-evolution 0.7.2 → 0.8.0

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,
+  }
+}

package/lib/session-redaction.js

@@ -0,0 +1,311 @@
+import { canonicalDigest } from './session-selection.js'
+
+const MAX_MESSAGE_CHARS = 4_000
+const MAX_TRANSCRIPT_MESSAGES = 80
+const MAX_OBSERVATION_BYTES = 512 * 1024
+
+const SECRET_PATTERNS = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/gi,
+  /\b(?:authorization\s*[:=]\s*(?:bearer\s+)?|bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi,
+  /\b(?:api[_-]?key|access[_-]?token|refresh[_-]?token|secret|password|passwd)\s*[:=]\s*["']?[^\s,"'}\]]{4,}/gi,
+  /\b(?:sk|rk|pk)-[A-Za-z0-9_-]{12,}\b/g,
+  /\bgh[opusr]_[A-Za-z0-9]{20,}\b/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+]
+
+const ABSOLUTE_PATH = /(?:[A-Za-z]:\\(?:[^\s<>:"|?*]+\\)+[^\s<>:"|?*]*|\/(?:Users|home|private|tmp|var|etc|opt|Volumes|workspace)(?:\/[A-Za-z0-9._ @+-]+)+)/g
+
+function replaceCanaries(value, canaries) {
+  let text = value
+  let replacements = 0
+  for (const canary of canaries) {
+    if (!canary || !text.includes(canary)) continue
+    const pieces = text.split(canary)
+    replacements += pieces.length - 1
+    text = pieces.join('[REDACTED_SESSION_ID]')
+  }
+  return { text, replacements }
+}
+
+function replaceSecrets(value, canaries = []) {
+  const canaryResult = replaceCanaries(value, canaries)
+  value = canaryResult.text
+  let text = value
+  let replacements = canaryResult.replacements
+  for (const pattern of SECRET_PATTERNS) {
+    text = text.replace(pattern, () => {
+      replacements += 1
+      return '[REDACTED_SECRET]'
+    })
+  }
+  text = text.replace(ABSOLUTE_PATH, () => {
+    replacements += 1
+    return '[REDACTED_PATH]'
+  })
+  return { text, replacements }
+}
+
+function sanitizeText(value, maxChars = MAX_MESSAGE_CHARS, canaries = []) {
+  const input = String(value ?? '')
+  const redacted = replaceSecrets(input, canaries)
+  const truncated = redacted.text.length > maxChars
+  return {
+    text: truncated ? `${redacted.text.slice(0, maxChars)}\n[TRUNCATED]` : redacted.text,
+    replacements: redacted.replacements,
+    truncated,
+  }
+}
+
+function isoTime(value) {
+  return Number.isSafeInteger(value) && value > 0 ? new Date(value).toISOString() : null
+}
+
+function appendOrigin(event) {
+  return event?.surfaceOp === undefined || event.surfaceOp === 'append'
+}
+
+function visibleContent(message, report, canaries) {
+  const content = []
+  for (const block of Array.isArray(message?.content) ? message.content : []) {
+    if (block?.type !== 'text' || typeof block.text !== 'string') continue
+    const sanitized = sanitizeText(block.text, MAX_MESSAGE_CHARS, canaries)
+    report.replacements += sanitized.replacements
+    if (sanitized.truncated) report.truncations += 1
+    if (sanitized.text.trim()) content.push({ type: 'text', text: sanitized.text })
+  }
+  return content
+}
+
+function messageRef(message) {
+  return canonicalDigest(
+    { id: typeof message?.id === 'string' ? message.id : null },
+    'harbor-dsh-session-message-ref-v1',
+  )
+}
+
+function sanitizeIdentity(value, report, canaries) {
+  const sanitized = sanitizeText(value, 160, canaries)
+  report.replacements += sanitized.replacements
+  if (sanitized.truncated) report.truncations += 1
+  return sanitized.text
+}
+
+function modelSegments(selected, report, canaries) {
+  return selected.index.modelSegments.map(segment => ({
+    from_seq: segment.from_seq,
+    through_seq: segment.through_seq,
+    provider: sanitizeIdentity(segment.provider, report, canaries),
+    model: sanitizeIdentity(segment.model, report, canaries),
+    ...(segment.reasoning_effort
+      ? { reasoning_effort: sanitizeIdentity(segment.reasoning_effort, report, canaries) }
+      : {}),
+  }))
+}
+
+function toolEvidence(events) {
+  const results = new Map()
+  for (const event of events) {
+    if (event?.type !== 'tool/result') continue
+    results.set(event.data?.message?.source?.callId, event)
+  }
+  const tools = []
+  for (const event of events) {
+    if (event?.type !== 'tool/call') continue
+    const result = results.get(event.data?.callId)
+    tools.push({
+      event_seq: event.seq,
+      name: String(event.data?.name ?? 'unknown').slice(0, 160),
+      outcome: result?.data?.error || result?.data?.message?.content?.[0]?.isError ? 'error' : result ? 'success' : 'unknown',
+      error_code: typeof result?.data?.error?.code === 'string'
+        ? result.data.error.code.slice(0, 160)
+        : null,
+      result_summary: result ? 'Tool completed; payload intentionally omitted.' : 'No matching tool result observed.',
+      truncated: true,
+    })
+  }
+  return tools.slice(0, 200)
+}
+
+function turnEvidence(events) {
+  const starts = new Map()
+  const turns = []
+  for (const event of events) {
+    if (event?.type === 'turn/start') starts.set(event.data?.turn, event.time)
+    if (event?.type === 'turn/end') {
+      turns.push({
+        turn: event.data?.turn,
+        reason: event.data?.reason?.kind ?? 'unknown',
+        started_at: isoTime(starts.get(event.data?.turn)),
+        ended_at: isoTime(event.time),
+      })
+    }
+  }
+  return turns
+}
+
+function usageEvidence(events) {
+  let inputTokens = 0
+  let outputTokens = 0
+  let reported = false
+  for (const event of events) {
+    if (event?.type !== 'assistant/message' || !event.data?.usage) continue
+    const usage = event.data.usage
+    if (Number.isFinite(usage.inputTokens)) inputTokens += usage.inputTokens
+    if (Number.isFinite(usage.outputTokens)) outputTokens += usage.outputTokens
+    reported = true
+  }
+  return { input_tokens: inputTokens, output_tokens: outputTokens, reported }
+}
+
+function sanitizeFeedback(items, report, canaries) {
+  const output = []
+  for (const item of Array.isArray(items) ? items : []) {
+    if (!['positive', 'negative'].includes(item?.rating)) continue
+    const note = sanitizeText(item.note ?? '', 1_000, canaries)
+    report.replacements += note.replacements
+    if (note.truncated) report.truncations += 1
+    output.push({
+      message_ref: canonicalDigest({ id: item.messageId ?? null }, 'harbor-dsh-feedback-message-ref-v1'),
+      rating: item.rating,
+      ...(note.text.trim() ? { note: note.text } : {}),
+      updated_at: isoTime(item.updatedAt),
+    })
+  }
+  return output.slice(0, 100)
+}
+
+function assertNoSecret(value, canaries = []) {
+  const serialized = JSON.stringify(value)
+  for (const canary of canaries) {
+    if (canary.length >= 8 && serialized.includes(canary)) {
+      throw new Error('SESSION_REDACTION_FAILED: a raw Session id survived the redaction pipeline')
+    }
+  }
+  for (const pattern of SECRET_PATTERNS) {
+    pattern.lastIndex = 0
+    if (pattern.test(serialized)) {
+      throw new Error('SESSION_REDACTION_FAILED: a credential-shaped value survived the redaction pipeline')
+    }
+  }
+  ABSOLUTE_PATH.lastIndex = 0
+  if (ABSOLUTE_PATH.test(serialized)) {
+    throw new Error('SESSION_REDACTION_FAILED: an absolute local path survived the redaction pipeline')
+  }
+  if (Buffer.byteLength(serialized) > MAX_OBSERVATION_BYTES) {
+    throw new Error(`SESSION_OBSERVATION_TOO_LARGE: redacted observation exceeds ${MAX_OBSERVATION_BYTES} bytes`)
+  }
+}
+
+const policyWithoutDigest = {
+  id: 'dsh-session-default-redaction',
+  version: '1.0.0',
+  projection: 'direct-human-and-assembled-assistant-text',
+  tool_payloads: 'omit',
+  reasoning: 'omit',
+  attachments: 'omit',
+  credentials: 'redact-and-fail-closed',
+}
+
+export const DEFAULT_REDACTION_POLICY = Object.freeze({
+  ...policyWithoutDigest,
+  digest: canonicalDigest(policyWithoutDigest, 'harbor-dsh-session-redaction-policy-v1'),
+})
+
+export function buildSessionObservation(selected, feedbackItems = []) {
+  const report = { replacements: 0, truncations: 0, omitted_blocks: 0 }
+  const canaries = [String(selected.rawSessionId ?? '')].filter(Boolean)
+  const visibleTranscript = []
+  for (const event of selected.events) {
+    if (!appendOrigin(event)) continue
+    let role
+    let message
+    if (event?.type === 'user/message' && event.data?.source?.kind === 'user') {
+      role = 'user'
+      message = event.data
+    } else if (event?.type === 'assistant/message') {
+      role = 'assistant'
+      message = event.data?.message
+    } else {
+      continue
+    }
+    const content = visibleContent(message, report, canaries)
+    const originalBlocks = Array.isArray(message?.content) ? message.content.length : 0
+    report.omitted_blocks += Math.max(0, originalBlocks - content.length)
+    if (!content.length) continue
+    if (visibleTranscript.length >= MAX_TRANSCRIPT_MESSAGES) {
+      report.truncations += 1
+      break
+    }
+    visibleTranscript.push({
+      event_seq: event.seq,
+      message_ref: messageRef(message),
+      role,
+      content,
+      time: isoTime(event.time),
+    })
+  }
+  const initialGoal = visibleTranscript.find(message => message.role === 'user')?.content
+    ?.map(block => block.text).join('\n') ?? ''
+  const sanitizedTitle = sanitizeText(
+    initialGoal.split('\n').find(Boolean) ?? 'Historical DSH Session',
+    120,
+    canaries,
+  )
+  report.replacements += sanitizedTitle.replacements
+  if (sanitizedTitle.truncated) report.truncations += 1
+
+  const agentPreset = selected.index.effectiveAgentPreset ?? selected.header.agentPreset
+  const observation = {
+    schema_version: 1,
+    protocol: 'dsh-session-observation/v1',
+    record_kind: 'dsh-session',
+    execution_mode: 'observe-existing',
+    trial_id: selected.trialId,
+    source: {
+      ref: selected.sourceRef,
+      captured_through_seq: selected.capturedThroughSeq,
+      source_digest: selected.sourceDigest,
+      created_at: isoTime(selected.header.createdAt),
+      last_activity_at: isoTime(selected.index.lastActivityAt),
+      last_turn_reason: selected.index.lastTurnReason,
+      session_format_version: selected.header.version,
+    },
+    generator: {
+      agent_preset: agentPreset
+        ? sanitizeIdentity(agentPreset, report, canaries)
+        : null,
+      model_segments: modelSegments(selected, report, canaries),
+    },
+    task: {
+      title: sanitizedTitle.text || 'Historical DSH Session',
+      initial_user_goal: initialGoal,
+      turn_count: selected.index.turnCount,
+    },
+    visible_transcript: visibleTranscript,
+    execution: {
+      tools: toolEvidence(selected.events),
+      turns: turnEvidence(selected.events),
+      usage: usageEvidence(selected.events),
+    },
+    feedback: { items: sanitizeFeedback(feedbackItems, report, canaries) },
+    completeness: {
+      transcript_complete: visibleTranscript.length < MAX_TRANSCRIPT_MESSAGES,
+      tool_payloads_complete: false,
+      attachments_complete: false,
+      truncations: report.truncations ? [`${report.truncations} bounded text projection(s)`] : [],
+    },
+    redaction: report,
+  }
+  observation.digest = canonicalDigest(observation, 'harbor-dsh-session-observation-v1')
+  assertNoSecret(observation, canaries)
+  return observation
+}
+
+export function scanForCredentialCanaries(value) {
+  try {
+    assertNoSecret(value)
+    return []
+  } catch (error) {
+    return [error.message]
+  }
+}