dsh-experience 0.0.0-stage → 1.0.4

package/lib/decay.js

@@ -0,0 +1,253 @@
+/**
+ * dsh-experience / lib/decay.js — M3.1 decay ranking (pure, zero dependency).
+ *
+ * rank = score × freshness × utility × pin
+ *   freshness = 0.5 ^ (ageDays / halfLife)   halfLife: verified 180d / auto-verified 60d / candidate 30d
+ *   utility   = clamp(1 + log2(1 + uses) / 10, 1, 1.5)
+ *   pin       = Infinity for human-taught or explicitly pinned records
+ *
+ * Invariants:
+ *   - decay never rewrites the stored similarity score; it only ranks and selects.
+ *   - `verified` may become dormant, but is never proposed for eviction.
+ *   - `now` is always injected so tests can travel through time.
+ */
+
+export const DECAY_DEFAULTS = Object.freeze({
+  halfLife: Object.freeze({ verified: 180, 'auto-verified': 60, candidate: 30 }),
+  dormantFactor: 2,
+  utilityCap: 1.5,
+  utilityScale: 10,
+  capacityRatio: 0.8,
+  evictBatch: 5,
+  libraryLimit: 200,
+})
+
+const DAY_MS = 86400000
+
+function num(value, fallback) {
+  const parsed = Number(value)
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+export function halfLifeOf(status, config = {}) {
+  const table = { ...DECAY_DEFAULTS.halfLife, ...(config.halfLife || {}) }
+  const days = num(table[status], DECAY_DEFAULTS.halfLife.candidate)
+  return days > 0 ? days : DECAY_DEFAULTS.halfLife.candidate
+}
+
+function timeOf(value) {
+  if (!value) return null
+  const parsed = Date.parse(value)
+  return Number.isFinite(parsed) ? parsed : null
+}
+
+export function anchorMs(record) {
+  const proof = record && record.proof ? record.proof : {}
+  const candidates = [
+    timeOf(record && record.lastUsedAt),
+    timeOf(record && record.lastSuccessAt),
+    timeOf(proof.lastSuccessAt),
+    timeOf(record && record.createdAt),
+    timeOf(record && record.at),
+  ].filter((value) => value !== null)
+  return candidates.length ? Math.max(...candidates) : null
+}
+
+/** Age in days. Unknown or future timestamps count as fresh (age 0): never decay something we cannot date. */
+export function ageDays(record, now = Date.now()) {
+  const anchor = anchorMs(record)
+  const current = num(now, Date.now())
+  if (anchor === null) return 0
+  const days = (current - anchor) / DAY_MS
+  return days > 0 ? days : 0
+}
+
+export function freshnessOf(record, now = Date.now(), config = {}) {
+  const halfLife = halfLifeOf(record && record.status, config)
+  return 0.5 ** (ageDays(record, now) / halfLife)
+}
+
+export function utilityOf(uses, config = {}) {
+  const cap = num(config.utilityCap, DECAY_DEFAULTS.utilityCap)
+  const scale = num(config.utilityScale, DECAY_DEFAULTS.utilityScale)
+  const count = Math.max(0, num(uses, 0))
+  const value = 1 + Math.log2(1 + count) / scale
+  return Math.min(cap, Math.max(1, value))
+}
+
+export function isPinned(record) {
+  if (!record) return false
+  return record.pinned === true || record.teach === true || Boolean(record.source && record.source.teach)
+}
+
+export function rankOf(record, now = Date.now(), options = {}) {
+  if (isPinned(record)) return Infinity
+  const score = num(options.score, 1)
+  return score * freshnessOf(record, now, options) * utilityOf(record && record.uses, options)
+}
+
+/** Lifecycle for display only: archived is decided by selectEvictions, never here. */
+export function stateOf(record, now = Date.now(), config = {}) {
+  const halfLife = halfLifeOf(record && record.status, config)
+  const factor = num(config.dormantFactor, DECAY_DEFAULTS.dormantFactor)
+  const age = ageDays(record, now)
+  const dormantAt = halfLife * factor
+  const dormant = !isPinned(record) && age >= dormantAt
+  return {
+    state: dormant ? 'dormant' : 'active',
+    dormant,
+    ageDays: Math.round(age * 10) / 10,
+    halfLife,
+    dormantAt,
+    freshness: freshnessOf(record, now, config),
+    utility: utilityOf(record && record.uses, config),
+    rank: rankOf(record, now, config),
+    pinned: isPinned(record),
+  }
+}
+
+export function describeDecay(record, now = Date.now(), config = {}) {
+  const info = stateOf(record, now, config)
+  const rank = info.pinned ? 'pinned' : info.rank.toFixed(4)
+  return `rank=${rank} fresh=${info.freshness.toFixed(3)} uses=${num(record && record.uses, 0)} age=${info.ageDays}d state=${info.state}`
+}
+
+/**
+ * Capacity-driven eviction proposals. Never deletes anything, never touches verified/pinned.
+ * Returns proposals only once the library reaches capacityRatio × libraryLimit.
+ */
+export function selectEvictions(records, now = Date.now(), config = {}) {
+  const list = Array.isArray(records) ? records : []
+  const libraryLimit = num(config.libraryLimit, DECAY_DEFAULTS.libraryLimit)
+  const ratio = num(config.capacityRatio, DECAY_DEFAULTS.capacityRatio)
+  const batch = Math.max(1, num(config.evictBatch, DECAY_DEFAULTS.evictBatch))
+  const threshold = Math.ceil(libraryLimit * ratio)
+  const base = { count: list.length, threshold, libraryLimit }
+  if (list.length < threshold) {
+    return { ...base, triggered: false, evictions: [], reason: `未达容量阈值 ${threshold}（当前 ${list.length}）` }
+  }
+  const eligible = list
+    .filter((record) => record && record.status !== 'verified' && !isPinned(record))
+    .map((record) => ({ record, info: stateOf(record, now, config) }))
+    .filter((entry) => entry.info.dormant)
+    .sort((left, right) => left.info.rank - right.info.rank)
+  if (!eligible.length) {
+    return { ...base, triggered: true, evictions: [], reason: '已达容量阈值，但没有可淘汰的 dormant 候选' }
+  }
+  const evictions = eligible.slice(0, batch).map((entry) => ({
+    id: entry.record.id,
+    status: entry.record.status,
+    reason: `dormant ${entry.info.ageDays}d（半衰期 ${entry.info.halfLife}d），rank 最低`,
+    rank: entry.info.rank,
+    ageDays: entry.info.ageDays,
+  }))
+  return { ...base, triggered: true, evictions, reason: `已达容量阈值 ${threshold}，建议淘汰 ${evictions.length} 条` }
+}
+
+export function markDecay(records, now = Date.now(), config = {}) {
+  const list = Array.isArray(records) ? records : []
+  const stamp = new Date(num(now, Date.now())).toISOString()
+  let changed = 0
+  for (const record of list) {
+    if (!record) continue
+    const info = stateOf(record, now, config)
+    const next = {
+      state: info.state,
+      ageDays: info.ageDays,
+      halfLife: info.halfLife,
+      freshness: Math.round(info.freshness * 1000) / 1000,
+      utility: Math.round(info.utility * 1000) / 1000,
+      rank: info.pinned ? null : Math.round(info.rank * 10000) / 10000,
+      pinned: info.pinned,
+      at: stamp,
+    }
+    const prev = record.decay || {}
+    if (prev.state !== next.state || prev.ageDays !== next.ageDays || prev.rank !== next.rank || prev.pinned !== next.pinned) {
+      record.decay = next
+      changed++
+    }
+  }
+  return changed
+}
+
+export function decayLine(record, now = Date.now(), config = {}) {
+  const info = stateOf(record, now, config)
+  const rank = info.pinned ? 'pinned' : info.rank.toFixed(4)
+  return `${record.id} [${record.status}] rank=${rank} state=${info.state} age=${info.ageDays}d fresh=${info.freshness.toFixed(3)} uses=${num(record.uses, 0)}`
+}
+
+export function renderDecayReport(store, now = Date.now(), config = {}) {
+  const records = Array.isArray(store && store.experiences) ? store.experiences : []
+  const proposal = selectEvictions(records, now, config)
+  const counts = { active: 0, dormant: 0, pinned: 0 }
+  const sorted = records
+    .map((record) => ({ record, info: stateOf(record, now, config) }))
+    .sort((left, right) => {
+      if (left.info.pinned !== right.info.pinned) return left.info.pinned ? 1 : -1
+      return left.info.rank - right.info.rank
+    })
+  for (const entry of sorted) {
+    if (entry.info.pinned) counts.pinned++
+    else counts[entry.info.state]++
+  }
+  const eligible = new Set(proposal.evictions.map((item) => item.id))
+  const top = sorted.filter((entry) => !entry.info.pinned).slice(0, 5)
+  const lines = [
+    `[M3.3 衰减报告] 库 ${records.length} 条 · active ${counts.active} / dormant ${counts.dormant} / pinned ${counts.pinned}`,
+    `容量: ${proposal.count}/${proposal.libraryLimit}（阈值 ${proposal.threshold} · 比例 ${num(config.capacityRatio, DECAY_DEFAULTS.capacityRatio)}）· ${proposal.triggered ? '已达阈值' : '未达阈值'}`,
+    proposal.triggered
+      ? `建议归档 ${proposal.evictions.length} 条（最多 ${num(config.evictBatch, DECAY_DEFAULTS.evictBatch)} 条/次，按 rank 升序）:`
+      : '容量尚未告警: 以下为 rank 最低的 5 条观察项，无需处理。',
+    ...(top.length
+      ? top.map((entry, index) => `  ${index + 1}. ${decayLine(entry.record, now, config)}${eligible.has(entry.record.id) ? '  ← 可归档' : ''}`)
+      : ['  (库为空)']),
+    '只列出建议，不删除任何记录。确认后运行 /memory decay --apply（移入 archive，可用 /memory restore <id> 恢复）。',
+  ]
+  return lines.join('\n')
+}
+
+export function applyEvictions(store, now = Date.now(), config = {}, by = 'command') {
+  const records = Array.isArray(store && store.experiences) ? store.experiences : []
+  const proposal = selectEvictions(records, now, config)
+  if (!proposal.triggered) return { archived: [], triggered: false, reason: proposal.reason }
+  const ids = new Set(proposal.evictions.map((item) => item.id))
+  const keep = []
+  const archived = []
+  for (const record of records) {
+    const guard = record && ids.has(record.id) && record.status !== 'verified' && !isPinned(record)
+    if (guard) archived.push(record)
+    else keep.push(record)
+  }
+  if (!archived.length) return { archived: [], triggered: true, reason: '没有可归档的 dormant 候选' }
+  const at = new Date(num(now, Date.now())).toISOString()
+  store.experiences = keep
+  store.archive = Array.isArray(store.archive) ? store.archive : []
+  store.evictions = Array.isArray(store.evictions) ? store.evictions : []
+  for (const record of archived) {
+    store.archive.push({ ...record, archivedAt: at, archivedBy: by })
+    const proposalItem = proposal.evictions.find((item) => item.id === record.id)
+    store.evictions.push({
+      id: record.id,
+      at,
+      by,
+      reason: proposalItem ? proposalItem.reason : 'dormant',
+      rank: proposalItem ? proposalItem.rank : null,
+      ageDays: proposalItem ? proposalItem.ageDays : null,
+    })
+  }
+  return { archived: archived.map((record) => record.id), triggered: true, at, reason: `已归档 ${archived.length} 条（未物理删除，可用 /memory restore <id> 恢复）` }
+}
+
+export function restoreRecord(store, id) {
+  const archive = Array.isArray(store && store.archive) ? store.archive : []
+  const index = archive.findIndex((record) => record && record.id === id)
+  if (index < 0) return null
+  const [record] = archive.splice(index, 1)
+  delete record.archivedAt
+  delete record.archivedBy
+  delete record.decay
+  store.experiences.push(record)
+  store.evictions = Array.isArray(store.evictions) ? store.evictions : []
+  store.evictions.push({ id, at: new Date().toISOString(), by: 'restore', reason: '人工恢复' })
+  return record
+}

package/lib/evidence.js

@@ -0,0 +1,206 @@
+/**
+ * dsh-experience / lib/evidence.js — L2 evidence accumulation (M2).
+ *
+ * Pure functions: no ctx, no fs, no model calls. The only thing this module
+ * knows how to do is count *facts* (independent sessions, step stability,
+ * failures) and state, in plain words, why a candidate is not promoted yet.
+ *
+ * Trust boundary: nothing here can set `status: 'verified'`. The strongest
+ * outcome is `auto-verified`, which does not participate in recall unless the
+ * human turns `allowAutoVerified` on.
+ */
+import crypto from 'node:crypto'
+
+export const EVIDENCE_LIMIT = 20
+
+export const EVIDENCE_DEFAULTS = {
+  autoPromote: false,
+  minDistinctSessions: 2,
+  stepsJaccard: 0.7,
+  allowAutoVerified: false,
+}
+
+export function emptyProof() {
+  return { runs: [], distinctSessions: 0, minStability: 1, lastSuccessAt: null, lastFailureAt: null }
+}
+
+export function ensureProof(record) {
+  if (!record || typeof record !== 'object') return emptyProof()
+  if (!record.proof || typeof record.proof !== 'object') record.proof = emptyProof()
+  const proof = record.proof
+  if (!Array.isArray(proof.runs)) proof.runs = []
+  if (typeof proof.distinctSessions !== 'number') proof.distinctSessions = 0
+  if (typeof proof.minStability !== 'number') proof.minStability = 1
+  if (!('lastSuccessAt' in proof)) proof.lastSuccessAt = null
+  if (!('lastFailureAt' in proof)) proof.lastFailureAt = null
+  return proof
+}
+
+export function stepsHash(steps) {
+  const text = (steps || []).map(String).join('|')
+  return crypto.createHash('sha1').update(text).digest('hex').slice(0, 12)
+}
+
+/** Set Jaccard of two step lists; 1 when both are empty (nothing drifted). */
+export function jaccardSteps(a, b) {
+  const left = new Set((a || []).map(String))
+  const right = new Set((b || []).map(String))
+  if (!left.size && !right.size) return 1
+  let intersection = 0
+  for (const item of left) if (right.has(item)) intersection++
+  const union = left.size + right.size - intersection
+  return union ? Math.round((intersection / union) * 1000) / 1000 : 0
+}
+
+/**
+ * Append one run to the record's proof and refresh the derived counters.
+ * `steps` is the run's own step list; stability is measured against the
+ * record's canonical steps at write time so promotion stays a pure decision.
+ */
+export function recordEvidence(record, run) {
+  const proof = ensureProof(record)
+  const at = run.at || new Date().toISOString()
+  const outcome = run.outcome === 'failure' ? 'failure' : 'success'
+  // Stability is measured between consecutive successful runs: the record steps
+  // may predate structured evidence and would otherwise look like drift forever.
+  const previous = [...proof.runs]
+    .reverse()
+    .find((item) => item.outcome === 'success' && Array.isArray(item.steps) && item.steps.length)
+  const baseline = previous ? previous.steps : record.steps || []
+  const stability = run.byFingerprint || (run.verificationOnly && run.green) ? 1 : jaccardSteps(baseline, run.steps || [])
+  const entry = {
+    sessionId: String(run.sessionId || 'unknown'),
+    turn: run.turn ?? null,
+    at,
+    outcome,
+    stability,
+    byFingerprint: Boolean(run.byFingerprint),
+    verificationOnly: Boolean(run.verificationOnly),
+    green: Boolean(run.green),
+    errors: Number(run.errors || 0),
+    steps: (run.steps || []).slice(0, 8).map(String),
+    stepsHash: stepsHash(run.steps),
+  }
+  proof.runs = [...proof.runs, entry].slice(-EVIDENCE_LIMIT)
+
+  const sessions = new Set(proof.runs.filter((item) => item.outcome === 'success').map((item) => item.sessionId))
+  proof.distinctSessions = sessions.size
+  const successes = proof.runs.filter((item) => item.outcome === 'success')
+  // The first run with a step snapshot only establishes the baseline; comparing it
+  // against pre-snapshot record steps says nothing about reproducibility.
+  const comparable = successes.filter((item) => Array.isArray(item.steps) && item.steps.length).slice(1)
+  proof.minStability = comparable.length ? Math.min(...comparable.map((item) => item.stability)) : null
+  if (outcome === 'failure') proof.lastFailureAt = at
+  else proof.lastSuccessAt = at
+  return { entry, proof }
+}
+
+/**
+ * Why is this record (not) promotion-ready? Always returns a human sentence,
+ * which `/memory debug` prints verbatim under [2.5 证据].
+ */
+export function promotionState(record, config = {}, at = new Date().toISOString()) {
+  const cfg = { ...EVIDENCE_DEFAULTS, ...config }
+  const proof = ensureProof(record)
+  const status = record && record.status
+  if (status === 'verified') return { eligible: false, code: 'already-human', reason: '已人工确认（verified）' }
+  if (status === 'rejected') return { eligible: false, code: 'rejected', reason: '已被人工拒绝（rejected）' }
+
+  const successes = proof.runs.filter((item) => item.outcome === 'success')
+  const sessions = new Set(successes.map((item) => item.sessionId))
+  const withSteps = successes.filter((item) => Array.isArray(item.steps) && item.steps.length)
+  const comparable = withSteps.slice(1)
+  // The result fingerprint (same artifact, green tests) outranks step similarity:
+  // a run that re-proves the same terminal state is a 1.0 no matter how lean it was.
+  const fingerprintGreen = Boolean(record && record.fingerprint && record.fingerprint.green)
+  const effective = (item) =>
+    fingerprintGreen || (item && (item.byFingerprint || (item.verificationOnly && item.green))) ? 1 : item.stability
+  const stability = comparable.length ? Math.min(...comparable.map(effective)) : null
+  const fingerprinted = fingerprintGreen ? successes.length : successes.filter((item) => item && item.byFingerprint).length
+
+  const failedAfterSuccess =
+    Boolean(proof.lastFailureAt) &&
+    (!proof.lastSuccessAt || String(proof.lastFailureAt) >= String(proof.lastSuccessAt))
+
+  if (!proof.runs.length) {
+    return { eligible: false, code: 'no-runs', reason: '尚无结构化证据：迁移只补字段、不伪造历史运行，需要一次新的成功轨迹', sessions: 0, stability }
+  }
+  const stabilityText = stability === null ? "缺可比较快照" : String(stability)
+  const detail = `独立 session ${sessions.size}/${cfg.minDistinctSessions}，稳定性 ${stabilityText}（线 ${cfg.stepsJaccard}${fingerprinted ? `，指纹等效 ${fingerprinted}` : ''}）`
+  if (!cfg.autoPromote) {
+    return { eligible: false, code: 'policy-off', reason: `autoPromote=false：策略关闭，${detail}`, sessions: sessions.size, stability }
+  }
+  if (failedAfterSuccess) {
+    return { eligible: false, code: 'failure-after-success', reason: `最后一次成功之后出现失败，证据链作废；${detail}`, sessions: sessions.size, stability }
+  }
+  if (sessions.size < cfg.minDistinctSessions) {
+    return { eligible: false, code: 'sessions', reason: `未满 ${cfg.minDistinctSessions} 个独立 session；${detail}`, sessions: sessions.size, stability }
+  }
+  if (stability === null) {
+    const missing = 2 - withSteps.length
+    return {
+      eligible: false,
+      code: 'needs-baseline',
+      reason: `已有 ${successes.length} 次成功，但可比较的步骤快照不足（还需 ${missing} 次同类成功运行）；${detail}`,
+      sessions: sessions.size,
+      stability,
+    }
+  }
+  if (stability < cfg.stepsJaccard) {
+    return { eligible: false, code: 'drift', reason: `步骤稳定性 ${stability} < ${cfg.stepsJaccard}，视为不同变体；${detail}`, sessions: sessions.size, stability }
+  }
+  return { eligible: true, code: 'ready', reason: `满足升级条件：${detail}`, sessions: sessions.size, stability }
+}
+
+/**
+ * A fingerprint merge proves the terminal state: earlier step drift stops counting
+ * and every recorded success becomes a 1.0 equivalence. Exported so the caller that
+ * detected the match (runCapture) can stamp it before promotion is evaluated.
+ */
+export function markFingerprintEquivalent(record, at = new Date().toISOString()) {
+  const proof = ensureProof(record)
+  let changed = 0
+  for (const run of proof.runs) {
+    if (run.outcome !== 'success') continue
+    if (run.byFingerprint && run.stability === 1) continue
+    run.byFingerprint = true
+    run.stability = 1
+    changed++
+  }
+  proof.equivalentAt = at
+  return { changed, at }
+}
+
+/**
+ * Apply the strongest non-human promotion: candidate -> auto-verified.
+ * Never writes `verified`; that status only comes from `/memory`.
+ */
+export function promote(record, config = {}, at = new Date().toISOString()) {
+  const state = promotionState(record, config, at)
+  if (!state.eligible) return { promoted: false, ...state }
+  if (record.status !== 'candidate') return { promoted: false, code: 'not-candidate', reason: `当前状态 ${record.status} 不走证据升级` }
+  record.status = 'auto-verified'
+  record.verify = {
+    by: 'evidence',
+    at,
+    method: 'l2-evidence',
+    sessions: state.sessions,
+    stability: state.stability,
+  }
+  record.confidence = 0.55
+  return { promoted: true, ...state }
+}
+
+/** Idempotent schema migration; returns whether anything changed. */
+export function migrateStore(store) {
+  if (!store || typeof store !== 'object') return { migrated: false, count: 0, version: 1 }
+  let count = 0
+  for (const record of store.experiences || []) {
+    if (!record || typeof record !== 'object') continue
+    if (!record.proof) count++
+    ensureProof(record)
+  }
+  const previous = Number(store.version || 1)
+  store.version = Math.max(2, previous)
+  return { migrated: previous < 2 || count > 0, count, version: store.version }
+}

package/lib/lookup.js

@@ -0,0 +1,53 @@
+/**
+ * Lookup rendering for the `experience_lookup` tool.
+ *
+ * The tool accepts a list of ids. Some of them may not exist (typo, deleted
+ * candidate, or an id from another machine). Returning only the hits used to
+ * hide that fact, so the caller could not tell "exp-9 does not exist" from
+ * "exp-9 exists but was not requested". `renderLookup` keeps the historical
+ * output byte-for-byte in both the all-hit and no-hit cases, and only appends a
+ * `未找到：…` line when the request was *partially* satisfied.
+ */
+
+const JOINER = '\n\n'
+
+function idsOf(records) {
+  const ids = new Set()
+  for (const record of records || []) {
+    if (record && record.id != null) ids.add(String(record.id))
+  }
+  return ids
+}
+
+/**
+ * Split wanted ids into hits and unique missing ids.
+ * Hits keep *store* order (identical to the historical `records.filter(...)`),
+ * misses keep request order and are de-duplicated.
+ */
+export function splitLookup(wanted, records) {
+  const list = Array.isArray(wanted) ? wanted.map(String) : []
+  const wantedSet = new Set(list)
+  const found = (records || []).filter(
+    (record) => record && record.id != null && wantedSet.has(String(record.id)),
+  )
+  const known = idsOf(records)
+  const missing = []
+  for (const id of list) {
+    if (!known.has(id) && !missing.includes(id)) missing.push(id)
+  }
+  return { found, missing }
+}
+
+/**
+ * Render the tool reply.
+ * - all hits, no misses  -> body only (unchanged)
+ * - no hits              -> `未找到：<requested ids or (空)>` (unchanged)
+ * - partial              -> body, blank line, `未找到：<missing ids>`
+ */
+export function renderLookup(wanted, records, format = (record) => String(record)) {
+  const list = Array.isArray(wanted) ? wanted.map(String) : []
+  const { found, missing } = splitLookup(list, records)
+  if (!found.length) return `未找到：${list.join(', ') || '(空)'}`
+  const body = found.map((record) => format(record)).join(JOINER)
+  return missing.length ? `${body}${JOINER}未找到：${missing.join(', ')}` : body
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "dsh-experience",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.4",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Cross-session self-learning plugin for DeepSeek Harness: auto-capture, fingerprint-verified promotion, lifecycle decay.",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "agent-memory",
+    "self-learning",
+    "ai",
+    "agent",
+    "cordis",
+    "plugin"
+  ],
+  "license": "MIT",
+  "author": "Aatzer0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Aatzer0/dsh-experience.git"
+  },
+  "homepage": "https://github.com/Aatzer0/dsh-experience#readme",
+  "bugs": {
+    "url": "https://github.com/Aatzer0/dsh-experience/issues"
+  },
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "tools/selftest.mjs",
+    "tools/e2e.mjs",
+    "cordis.patch.yml",
+    "README.md",
+    "USER-GUIDE.md",
+    "CONTRIBUTING.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "store.example.json",
+    "config.example.json",
+    "package.json"
+  ],
+  "scripts": {
+    "test": "node tools/selftest.mjs",
+    "test:e2e": "node tools/e2e.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}

package/store.example.json

@@ -0,0 +1,10 @@
+{
+  "version": 2,
+  "nextId": 1,
+  "nextInjectionId": 1,
+  "experiences": [],
+  "injections": [],
+  "turns": [],
+  "archive": [],
+  "evictions": []
+}