dsh-harbor-evolution 0.7.2 → 0.8.0

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

@@ -5,14 +5,14 @@ import process from 'node:process'
 import { fileURLToPath } from 'node:url'
 
 import { runProcess } from './process.js'
-
-export const DSH_VERSION = '0.1.0-rc.6'
+import { DSH_RUNTIME_VERSION } from './runtime-identity.js'
 
 const packageJson = JSON.parse(
   await readFile(new URL('../package.json', import.meta.url), 'utf8'),
 )
 
 export const INTEGRATION_VERSION = packageJson.version
+export const DSH_VERSION = DSH_RUNTIME_VERSION
 
 function requireValue(args, index, flag) {
   const value = args[index + 1]
@@ -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/lib/version.js

@@ -0,0 +1,128 @@
+export const NPM_PACKAGE_NAME = 'dsh-harbor-evolution'
+export const NPM_LATEST_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`
+export const RELEASES_URL = 'https://github.com/istarwyh/harbor-self-evolving/releases'
+
+const DEFAULT_CACHE_TTL_MS = 6 * 60 * 60 * 1_000
+const DEFAULT_FAILURE_TTL_MS = 5 * 60 * 1_000
+const DEFAULT_TIMEOUT_MS = 2_500
+
+export function parseSemver(value) {
+  const match = String(value ?? '').match(/^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/)
+  if (!match) return undefined
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+  }
+}
+
+function compareIdentifier(left, right) {
+  const leftNumber = /^\d+$/.test(left) ? Number(left) : undefined
+  const rightNumber = /^\d+$/.test(right) ? Number(right) : undefined
+  if (leftNumber !== undefined && rightNumber !== undefined) return Math.sign(leftNumber - rightNumber)
+  if (leftNumber !== undefined) return -1
+  if (rightNumber !== undefined) return 1
+  return left.localeCompare(right)
+}
+
+export function compareSemver(leftValue, rightValue) {
+  const left = parseSemver(leftValue)
+  const right = parseSemver(rightValue)
+  if (!left || !right) return undefined
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return Math.sign(left[key] - right[key])
+  }
+  if (!left.prerelease.length && !right.prerelease.length) return 0
+  if (!left.prerelease.length) return 1
+  if (!right.prerelease.length) return -1
+  const length = Math.max(left.prerelease.length, right.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    if (left.prerelease[index] === undefined) return -1
+    if (right.prerelease[index] === undefined) return 1
+    const comparison = compareIdentifier(left.prerelease[index], right.prerelease[index])
+    if (comparison) return Math.sign(comparison)
+  }
+  return 0
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", `'"'"'`)}'`
+}
+
+export function renderUpdateCommand(latestVersion, projectRoot) {
+  if (!parseSemver(latestVersion)) throw new Error('latestVersion must be a valid semantic version')
+  return `npx --yes ${NPM_PACKAGE_NAME}@${latestVersion} setup --project-root ${shellQuote(projectRoot)}`
+}
+
+function buildResult(currentVersion, latestVersion, projectRoot, checkedAt, options = {}) {
+  const comparison = compareSemver(currentVersion, latestVersion)
+  if (comparison === undefined) {
+    return { status: 'unavailable', currentVersion, checkedAt, source: options.source, stale: options.stale }
+  }
+  const updateAvailable = comparison < 0
+  return {
+    status: updateAvailable ? 'update-available' : 'up-to-date',
+    currentVersion,
+    latestVersion,
+    checkedAt,
+    source: options.source,
+    stale: options.stale,
+    releaseUrl: updateAvailable ? `${RELEASES_URL}/tag/v${latestVersion}` : RELEASES_URL,
+    command: updateAvailable ? renderUpdateCommand(latestVersion, projectRoot) : undefined,
+  }
+}
+
+export function createVersionChecker(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  const now = options.now ?? Date.now
+  const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS
+  const failureTtlMs = options.failureTtlMs ?? DEFAULT_FAILURE_TTL_MS
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  let successful
+  let failedAt = 0
+
+  return async function checkVersion({ currentVersion, projectRoot, refresh = false }) {
+    const checkedAt = new Date(now()).toISOString()
+    if (!refresh && successful && now() < successful.expiresAt) {
+      return buildResult(currentVersion, successful.latestVersion, projectRoot, successful.checkedAt, { source: 'cache' })
+    }
+    if (!refresh && !successful && failedAt && now() - failedAt < failureTtlMs) {
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'cache' }
+    }
+    if (typeof fetchImpl !== 'function') {
+      failedAt = now()
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'host' }
+    }
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), timeoutMs)
+    try {
+      const response = await fetchImpl(NPM_LATEST_URL, {
+        headers: { accept: 'application/json' },
+        redirect: 'error',
+        signal: controller.signal,
+      })
+      if (!response.ok) throw new Error('registry request failed')
+      const manifest = await response.json()
+      if (manifest?.name !== NPM_PACKAGE_NAME || !parseSemver(manifest.version)) {
+        throw new Error('registry response is invalid')
+      }
+      successful = {
+        latestVersion: manifest.version,
+        checkedAt,
+        expiresAt: now() + cacheTtlMs,
+      }
+      failedAt = 0
+      return buildResult(currentVersion, successful.latestVersion, projectRoot, checkedAt, { source: 'registry' })
+    } catch {
+      failedAt = now()
+      if (successful) {
+        return buildResult(currentVersion, successful.latestVersion, projectRoot, successful.checkedAt, { source: 'cache', stale: true })
+      }
+      return { status: 'unavailable', currentVersion, checkedAt, source: 'registry' }
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+}

package/lib/web.js

@@ -8,6 +8,8 @@ export const COMPARE_ROUTE = '/_dsh/harbor-evolution/compare'
 export const GOVERNANCE_ROUTE = '/_dsh/harbor-evolution/governance'
 export const EVALUATOR_ROUTE = '/_dsh/harbor-evolution/evaluator'
 export const META_ROUTE = '/_dsh/harbor-evolution/meta'
+export const PROJECT_ROOT_ROUTE = '/_dsh/harbor-evolution/project-root'
+export const VERSION_ROUTE = '/_dsh/harbor-evolution/version'
 const MAX_MUTATION_BYTES = 256 * 1024
 
 function sendJson(response, status, body) {
@@ -64,7 +66,7 @@ export function createApiHandler(load, code = 'request-failed') {
 }
 
 export function createDashboardHandler(service) {
-  return createApiHandler(() => service.dashboard(), 'dashboard-unavailable')
+  return createApiHandler(args => service.dashboard(args), 'dashboard-unavailable')
 }
 
 export function createMutationHandler(update, code = 'update-failed') {
@@ -116,6 +118,8 @@ export function installDashboardWeb(ctx, service) {
       [GOVERNANCE_ROUTE, createApiHandler(args => service.governance(args), 'governance-unavailable')],
       [EVALUATOR_ROUTE, createMutationHandler(args => service.evaluator(args), 'evaluator-update-failed')],
       [META_ROUTE, createApiHandler(args => service.meta(args), 'meta-evaluation-unavailable')],
+      [VERSION_ROUTE, createApiHandler(args => service.version(args), 'version-check-unavailable')],
+      [PROJECT_ROOT_ROUTE, createMutationHandler(args => service.setProjectRoot(args), 'project-root-update-failed')],
     ]
     for (const [route, handler] of routes) {
       webCtx.effect(() => webCtx.webServer.register({ kind: 'exact', path: route, handler }), `harbor-evolution: ${route}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-harbor-evolution",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "DeepSeek Harness plugin and bundled Skill for safely evolving Cordis Candidates with Harbor.",
   "type": "module",
   "main": "index.js",
@@ -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",
@@ -48,9 +53,14 @@
       "platform": "web"
     }
   },
+  "harborEvolution": {
+    "runtimePolicy": "follow-latest",
+    "dshRuntimeVersion": "latest",
+    "candidateAcpPackage": "@deepseek-ai/dsh-acp-demo@latest"
+  },
   "peerDependencies": {
-    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-skill": ">=0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.6"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "3.18.1"

package/schemas/dsh-session-observation.schema.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/istarwyh/harbor-self-evolving/schemas/dsh-session-observation.schema.json",
+  "title": "DSH Session Observation v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "protocol", "record_kind", "execution_mode", "trial_id", "source", "generator", "task", "visible_transcript", "execution", "feedback", "completeness", "redaction", "digest"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "protocol": { "const": "dsh-session-observation/v1" },
+    "record_kind": { "const": "dsh-session" },
+    "execution_mode": { "const": "observe-existing" },
+    "trial_id": { "type": "string", "minLength": 1 },
+    "source": {
+      "type": "object",
+      "required": ["ref", "captured_through_seq", "source_digest", "created_at", "last_activity_at", "last_turn_reason", "session_format_version"],
+      "properties": {
+        "ref": { "$ref": "#/$defs/digest" },
+        "captured_through_seq": { "type": "integer", "minimum": 0 },
+        "source_digest": { "$ref": "#/$defs/digest" },
+        "created_at": { "type": ["string", "null"], "format": "date-time" },
+        "last_activity_at": { "type": ["string", "null"], "format": "date-time" },
+        "last_turn_reason": { "type": ["string", "null"] },
+        "session_format_version": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "generator": { "type": "object", "required": ["agent_preset", "model_segments"] },
+    "task": {
+      "type": "object",
+      "required": ["title", "initial_user_goal", "turn_count"],
+      "properties": {
+        "title": { "type": "string", "minLength": 1 },
+        "initial_user_goal": { "type": "string", "minLength": 1 },
+        "turn_count": { "type": "integer", "minimum": 1 }
+      }
+    },
+    "visible_transcript": {
+      "type": "array",
+      "minItems": 2,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["event_seq", "message_ref", "role", "content", "time"],
+        "properties": {
+          "event_seq": { "type": "integer", "minimum": 0 },
+          "message_ref": { "$ref": "#/$defs/digest" },
+          "role": { "enum": ["user", "assistant"] },
+          "content": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["type", "text"],
+              "properties": { "type": { "const": "text" }, "text": { "type": "string", "minLength": 1 } }
+            }
+          },
+          "time": { "type": ["string", "null"], "format": "date-time" }
+        }
+      }
+    },
+    "execution": { "type": "object", "required": ["tools", "turns", "usage"] },
+    "feedback": { "type": "object", "required": ["items"] },
+    "completeness": { "type": "object", "required": ["transcript_complete", "tool_payloads_complete", "attachments_complete", "truncations"] },
+    "redaction": { "type": "object", "required": ["replacements", "truncations", "omitted_blocks"] },
+    "digest": { "$ref": "#/$defs/digest" }
+  },
+  "$defs": { "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" } }
+}

package/schemas/evaluation-result-v2.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/istarwyh/harbor-self-evolving/schemas/evaluation-result-v2.schema.json",
+  "title": "Harbor DSH Evaluation Result v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "protocol", "criteria", "aggregate"],
+  "properties": {
+    "schema_version": { "const": 2 },
+    "protocol": { "const": "evaluation-result/v2" },
+    "criteria": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "status", "score", "reason", "recommendation", "evidence_refs"],
+        "properties": {
+          "id": { "type": "string", "minLength": 1 },
+          "status": { "enum": ["scored", "not-applicable", "insufficient-evidence", "evaluation-error"] },
+          "score": { "type": ["number", "null"], "enum": [0, 0.5, 1, null] },
+          "reason": { "type": "string", "minLength": 1 },
+          "recommendation": { "type": "string", "minLength": 1 },
+          "evidence_refs": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+        },
+        "allOf": [
+          { "if": { "properties": { "status": { "const": "scored" } } }, "then": { "properties": { "score": { "enum": [0, 0.5, 1] } } } },
+          { "if": { "properties": { "status": { "enum": ["not-applicable", "insufficient-evidence", "evaluation-error"] } } }, "then": { "properties": { "score": { "type": "null" } } } }
+        ]
+      }
+    },
+    "aggregate": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["metric_id", "value", "scored_criteria", "total_criteria", "coverage"],
+      "properties": {
+        "metric_id": { "type": "string", "minLength": 1 },
+        "value": { "type": ["number", "null"], "minimum": 0, "maximum": 1 },
+        "scored_criteria": { "type": "integer", "minimum": 0 },
+        "total_criteria": { "type": "integer", "minimum": 1 },
+        "coverage": { "type": "number", "minimum": 0, "maximum": 1 }
+      }
+    }
+  }
+}