dsh-harbor-evolution 0.7.3 → 0.8.1

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

package/lib/session-selection.js

@@ -0,0 +1,294 @@
+import { createHash, randomBytes } from 'node:crypto'
+import path from 'node:path'
+
+import { foldSessionDiagnosticIndex } from './session-projection.js'
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize)
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.keys(value).sort().map(key => [key, canonicalize(value[key])]),
+    )
+  }
+  return value
+}
+
+export function canonicalDigest(value, namespace) {
+  const body = JSON.stringify(canonicalize(value))
+  return `sha256:${createHash('sha256').update(namespace).update('\0').update(body).digest('hex')}`
+}
+
+function sessionHeaderIdentity(header, effectiveAgentPreset) {
+  return {
+    version: header?.version,
+    id: header?.id,
+    createdAt: header?.createdAt,
+    cwd: header?.cwd,
+    parentSession: header?.parentSession,
+    seedLength: header?.seedLength,
+    origin: header?.origin,
+    delegationDepth: header?.delegationDepth,
+    ...(effectiveAgentPreset === undefined ? {} : { agentPreset: effectiveAgentPreset }),
+  }
+}
+
+function sameProjectRoot(value, projectRoot) {
+  if (typeof value !== 'string' || !path.isAbsolute(value)) return false
+  return path.resolve(value) === path.resolve(projectRoot)
+}
+
+function isoTime(value) {
+  return Number.isSafeInteger(value) && value > 0 ? new Date(value).toISOString() : null
+}
+
+function safeIdentity(value, rawSessionId) {
+  const text = typeof value === 'string' ? value : ''
+  if (rawSessionId && text.includes(rawSessionId)) return '[redacted-identity]'
+  if (
+    /(?:api[_-]?key|token|secret|password|authorization|bearer\s+)/i.test(text)
+    || /(?:^|[\\/])(?:Users|home|private|tmp|var|etc|opt|Volumes)(?:[\\/]|$)/.test(text)
+    || /\b(?:sk|rk|pk)-[A-Za-z0-9_-]{12,}\b/.test(text)
+  ) return '[redacted-identity]'
+  return text.slice(0, 160)
+}
+
+async function mapConcurrent(values, concurrency, mapper) {
+  const result = new Array(values.length)
+  let cursor = 0
+  const workers = Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+    while (cursor < values.length) {
+      const index = cursor
+      cursor += 1
+      try {
+        result[index] = { status: 'fulfilled', value: await mapper(values[index], index) }
+      } catch (reason) {
+        result[index] = { status: 'rejected', reason }
+      }
+    }
+  })
+  await Promise.all(workers)
+  return result
+}
+
+function publicSelection(item, index) {
+  const agentPreset = item.index.effectiveAgentPreset ?? item.header.agentPreset
+  return {
+    trialId: item.trialId,
+    title: `历史会话 ${index + 1}`,
+    createdAt: isoTime(item.header.createdAt),
+    lastActivityAt: isoTime(item.index.lastActivityAt),
+    turnCount: item.index.turnCount,
+    humanMessageCount: item.index.humanMessageCount,
+    assistantMessageCount: item.index.assistantMessageCount,
+    toolCallCount: item.index.toolCallCount,
+    lastTurnReason: item.index.lastTurnReason,
+    agentPreset: agentPreset ? safeIdentity(agentPreset, item.rawSessionId) : null,
+    modelRoutes: item.index.modelRoutes.map(route => ({
+      provider: safeIdentity(route.provider, item.rawSessionId),
+      model: safeIdentity(route.model, item.rawSessionId),
+      ...(route.reasoning_effort ? { reasoning_effort: safeIdentity(route.reasoning_effort, item.rawSessionId) } : {}),
+    })),
+  }
+}
+
+export async function selectRecentSessions({
+  sessionQuery,
+  projectRoot,
+  currentSessionId,
+  limit = 10,
+  maxSessionReads = 100,
+  concurrency = 4,
+  createdAfter,
+  signal,
+}) {
+  if (!sessionQuery || typeof sessionQuery.readSession !== 'function') {
+    throw new Error('DSH_SESSION_QUERY_UNAVAILABLE: this DSH Profile does not expose the Session Query service')
+  }
+  if (!Number.isInteger(limit) || limit < 1 || limit > 10) {
+    throw new Error('SESSION_LIMIT_INVALID: limit must be an integer from 1 to 10')
+  }
+  if (createdAfter !== undefined && (!Number.isSafeInteger(createdAfter) || createdAfter < 0)) {
+    throw new Error('SESSION_CREATED_AFTER_INVALID: createdAfter must be a valid timestamp')
+  }
+  const listed = typeof sessionQuery.filterSessions === 'function'
+    ? await sessionQuery.filterSessions([
+        { kind: 'cwd', values: [projectRoot] },
+        ...(createdAfter === undefined ? [] : [{ kind: 'created-at', from: createdAfter }]),
+      ], signal)
+    : await sessionQuery.listSessions(signal)
+  const excludedCounts = {
+    outsideWorkspace: 0,
+    beforeCreatedAfter: 0,
+    currentSession: 0,
+    subagent: 0,
+    forkOrChild: 0,
+    openTurn: 0,
+    noDirectHumanInput: 0,
+    noAssistantOutput: 0,
+    userAborted: 0,
+    harborInternal: 0,
+    empty: 0,
+    unreadable: 0,
+  }
+  const candidates = []
+  for (const record of Array.isArray(listed) ? listed : []) {
+    const header = record?.header ?? {}
+    if (!sameProjectRoot(header.cwd, projectRoot)) {
+      excludedCounts.outsideWorkspace += 1
+    } else if (header.id === currentSessionId) {
+      excludedCounts.currentSession += 1
+    } else if (createdAfter !== undefined && Number(header.createdAt) < createdAfter) {
+      excludedCounts.beforeCreatedAfter += 1
+    } else if (header.origin === 'subagent') {
+      excludedCounts.subagent += 1
+    } else if (
+      header.parentSession !== undefined
+      || Number(header.seedLength ?? 0) > 0
+      || Number(header.delegationDepth ?? 0) > 0
+    ) {
+      excludedCounts.forkOrChild += 1
+    } else {
+      candidates.push(record)
+    }
+  }
+  if (candidates.length > maxSessionReads) {
+    throw new Error(
+      `SESSION_SELECTION_TOO_EXPENSIVE: ${candidates.length} exact Session reads exceed maxSessionReads=${maxSessionReads}; preview again with createdAfter to narrow the scan`,
+    )
+  }
+
+  const snapshots = await mapConcurrent(candidates, concurrency, async record => {
+    const snapshot = await sessionQuery.readSession(record.header.id)
+    if (snapshot?.session?.id !== record.header.id) {
+      throw new Error('Session Query returned a mismatched Session header')
+    }
+    if (!sameProjectRoot(snapshot.session.cwd, projectRoot)) {
+      throw new Error('Session Query changed the Session workspace boundary')
+    }
+    return snapshot
+  })
+  const eligible = []
+  for (const outcome of snapshots) {
+    if (outcome.status === 'rejected') {
+      excludedCounts.unreadable += 1
+      continue
+    }
+    const snapshot = outcome.value
+    const index = foldSessionDiagnosticIndex(snapshot.events, snapshot.session)
+    if (index.lastSeq === null) {
+      excludedCounts.empty += 1
+      continue
+    }
+    if (index.openTurn) {
+      excludedCounts.openTurn += 1
+      continue
+    }
+    if (index.lastTurnReason === 'aborted') {
+      excludedCounts.userAborted += 1
+      continue
+    }
+    if (index.humanMessageCount < 1) {
+      excludedCounts.noDirectHumanInput += 1
+      continue
+    }
+    if (index.assistantMessageCount < 1) {
+      excludedCounts.noAssistantOutput += 1
+      continue
+    }
+    if (index.hasHarborToolCall) {
+      excludedCounts.harborInternal += 1
+      continue
+    }
+    if (/harbor/i.test(String(index.effectiveAgentPreset ?? ''))) {
+      excludedCounts.harborInternal += 1
+      continue
+    }
+    const header = sessionHeaderIdentity(snapshot.session, index.effectiveAgentPreset)
+    const sourceDigest = canonicalDigest(
+      { session: header, events: snapshot.events },
+      'harbor-dsh-session-source-v1',
+    )
+    const sourceRef = canonicalDigest(
+      { id: snapshot.session.id, header },
+      'harbor-dsh-session-source-ref-v1',
+    )
+    eligible.push({
+      rawSessionId: snapshot.session.id,
+      header,
+      events: snapshot.events,
+      index,
+      sourceDigest,
+      sourceRef,
+      capturedThroughSeq: index.lastSeq,
+      trialId: `session-${sourceRef.slice('sha256:'.length, 'sha256:'.length + 12)}`,
+    })
+  }
+  eligible.sort((left, right) => (
+    right.index.lastActivityAt - left.index.lastActivityAt
+    || left.sourceRef.localeCompare(right.sourceRef)
+  ))
+  const selected = eligible.slice(0, limit)
+  return {
+    selected,
+    publicSelected: selected.map(publicSelection),
+    excludedCounts,
+    warnings: excludedCounts.unreadable
+      ? [`${excludedCounts.unreadable} Session(s) could not be read and were excluded.`]
+      : [],
+  }
+}
+
+export function verifySessionSnapshot(expected, snapshot, projectRoot) {
+  if (snapshot?.session?.id !== expected.rawSessionId || !sameProjectRoot(snapshot?.session?.cwd, projectRoot)) {
+    return false
+  }
+  const index = foldSessionDiagnosticIndex(snapshot.events, snapshot.session)
+  if (index.lastSeq !== expected.capturedThroughSeq || index.openTurn) return false
+  const digest = canonicalDigest(
+    { session: sessionHeaderIdentity(snapshot.session, index.effectiveAgentPreset), events: snapshot.events },
+    'harbor-dsh-session-source-v1',
+  )
+  return digest === expected.sourceDigest
+}
+
+export class SessionSelectionTokenStore {
+  constructor({ ttlMs = 15 * 60 * 1000, now = () => Date.now(), randomToken } = {}) {
+    this.ttlMs = ttlMs
+    this.now = now
+    this.randomToken = randomToken ?? (() => randomBytes(32).toString('base64url'))
+    this.tokens = new Map()
+  }
+
+  issue(value) {
+    this.purge()
+    const token = this.randomToken()
+    const expiresAt = this.now() + this.ttlMs
+    this.tokens.set(token, { ...value, expiresAt })
+    return { token, expiresAt }
+  }
+
+  consume(token, { ownerSessionId, projectRoot }) {
+    const stored = this.tokens.get(token)
+    if (!stored) throw new Error('SESSION_SELECTION_TOKEN_INVALID: preview again before running the diagnostic')
+    // Consume before validation so a stolen or failed token cannot be replayed.
+    this.tokens.delete(token)
+    if (stored.ownerSessionId !== ownerSessionId) {
+      throw new Error('SESSION_SELECTION_TOKEN_OWNER_MISMATCH: the token belongs to another Agent Session')
+    }
+    if (path.resolve(stored.projectRoot) !== path.resolve(projectRoot)) {
+      throw new Error('SESSION_SELECTION_TOKEN_WORKSPACE_MISMATCH: the token belongs to another workspace')
+    }
+    if (stored.expiresAt <= this.now()) {
+      throw new Error('SESSION_SELECTION_TOKEN_EXPIRED: preview again before running the diagnostic')
+    }
+    this.purge()
+    return stored
+  }
+
+  purge() {
+    const now = this.now()
+    for (const [token, value] of this.tokens) {
+      if (value.expiresAt <= now) this.tokens.delete(token)
+    }
+  }
+}

package/lib/setup.js

@@ -281,9 +281,7 @@ export async function setupIntegration(raw = {}, dependencies = {}) {
   const patchChanged = await writeProfilePatch(config.patchFile, config)
   const harborVersion = await run(config.harborBin, ['--version'], { timeoutMs: 10_000 })
   const plugins = await run(config.harborBin, ['plugins', 'list'], { timeoutMs: 10_000 })
-  if (!plugins.stdout.includes('dsh-evolution')) {
-    throw new Error('Harbor installed, but its dsh-evolution plugin entry point was not discovered')
-  }
+  verifyHarborPlugins(plugins.stdout)
   await run(config.harborDshBin, ['--help'], { timeoutMs: 10_000 })
 
   return {
@@ -295,6 +293,14 @@ export async function setupIntegration(raw = {}, dependencies = {}) {
   }
 }
 
+export function verifyHarborPlugins(output) {
+  const missing = ['dsh-evolution', 'dsh-historical-evaluation']
+    .filter(name => !String(output).includes(name))
+  if (missing.length) {
+    throw new Error(`Harbor installed, but these plugin entry points were not discovered: ${missing.join(', ')}`)
+  }
+}
+
 function shellQuote(value) {
   return `'${String(value).replaceAll("'", `'"'"'`)}'`
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-harbor-evolution",
-  "version": "0.7.3",
-  "description": "DeepSeek Harness plugin and bundled Skill for safely evolving Cordis Candidates with Harbor.",
+  "version": "0.8.1",
+  "description": "DeepSeek Harness plugin and Skill for Harbor Candidate and Historical Session evaluation workflows.",
   "type": "module",
   "main": "index.js",
   "exports": {
@@ -9,6 +9,11 @@
     "./client": "./lib/client.js",
     "./cordis.patch.yml": "./cordis.patch.yml",
     "./schemas/evaluation-result.schema.json": "./schemas/evaluation-result.schema.json",
+    "./schemas/evaluation-result-v2.schema.json": "./schemas/evaluation-result-v2.schema.json",
+    "./schemas/historical-generation-batch.schema.json": "./schemas/historical-generation-batch.schema.json",
+    "./schemas/dsh-session-observation.schema.json": "./schemas/dsh-session-observation.schema.json",
+    "./schemas/historical-evaluation-context.schema.json": "./schemas/historical-evaluation-context.schema.json",
+    "./schemas/historical-evaluation-summary.schema.json": "./schemas/historical-evaluation-summary.schema.json",
     "./schemas/ground-truth.schema.json": "./schemas/ground-truth.schema.json",
     "./schemas/evaluator-observations.schema.json": "./schemas/evaluator-observations.schema.json",
     "./schemas/meta-evaluation-report.schema.json": "./schemas/meta-evaluation-report.schema.json",