@tangle-network/agent-knowledge 8.0.10 → 10.6.0

package/AGENTS.md

@@ -31,9 +31,13 @@ Otherwise, it stays in this package.
 ## Rules
 
 - Register sources before citing them: `agent-knowledge source-add <path>`.
-- Generated pages live under `knowledge/`.
+- Generated pages live under `knowledge/` unless the caller names another root-relative directory with `pagesDirectory` (CLI `--pages-dir`).
 - Raw evidence lives under `raw/sources/` and should not be edited.
+- Pass `intake` to `applyKnowledgeWriteBlocks` (CLI `--intake`) so a write that duplicates a visible page or cites a page id that exists nowhere is refused before any byte lands.
+- Build the retrieval brief with `buildKnowledgeBrief` before a run starts, and mint a receipt from `brief.results`, so retrieval is recorded rather than instructed.
 - Run `agent-knowledge index` after page changes.
+- Run `planInvalidationPropagation` + `formatKnowledgeInvalidationProposal` after grading, so every citer of a refuted page records `citesInvalidated`.
+- Move knowledge into shared scope only with `promoteRunScopedPages`. A run never writes the shared root itself.
 - Run `agent-knowledge lint` before trusting or promoting knowledge.
 - Treat `missing-source` lint findings as blocking.
 - Use `--json` for automation.
@@ -71,7 +75,15 @@ Sourced knowledge with links to [[Related Page]].
 ---END FILE---
 ```
 
-The parser rejects absolute paths, `..`, control characters, and writes outside `knowledge/`.
+The parser rejects absolute paths, `..`, control characters, and writes outside the pages directory (`knowledge/` by default).
+Pass the same `pagesDirectory` to `applyKnowledgeWriteBlocks` that the reader uses; the file transaction enforces the same bound.
+
+## Tool Boundary
+
+Expose knowledge to an agent with `createKnowledgeTools({ stores, runId, retrieverVersion })`.
+It returns `ToolDefinition[]` from `@tangle-network/agent-interface`.
+This package owns every handler; a runtime transports the definitions and the calls and runs no knowledge loop.
+The application supplies the roots, the lineage authority, and the effect authorization.
 
 ## Eval Boundary
 

package/CHANGELOG.md

@@ -1,5 +1,96 @@
 # Changelog
 
+## 10.6.0 — 2026-08-21
+
+### Added
+
+- Add `createKnowledgeTools({ stores, runId, retrieverVersion, ... })`, returning provider-neutral `ToolDefinition[]` for `knowledge_search`, `knowledge_read`, `knowledge_record`, and `knowledge_resolve`. This package owns every handler; a runtime transports the definitions and the calls and runs no knowledge loop. `knowledge_search` mints a retrieval receipt on every call and hands it to the optional `recordRetrieval` sink, so retrieval is recorded rather than claimed. `knowledge_record` applies the write intake gate. `knowledge_read` reports an id visible at two origins as `ambiguous` with both candidates and never chooses one.
+- Add `createKnowledgeRetrievalDisposition` and `verifyKnowledgeRetrievalDisposition`, the record for a retrieval that influenced nothing. A use receipt requires a selected rank, so a retrieval with no use previously left no record at all and "no evidence of use" was indistinguishable from "evidence of no use". The disposition binds to one `retrievalReceiptDigest`, carries `relation: 'irrelevant' | 'no-use'`, and has no rank.
+
+## 10.5.0 — 2026-08-21
+
+### Added
+
+- Add `promoteRunScopedPages(stores, runId, { pageIds, sharedRoot, actor, reason })`, the only path from run scope into the curated shared store. It carries the closure of the run-local pages a promoted page cites, each keeping its own evidence fields exactly as written, and refuses the promotion when any citation would not resolve in the target — including one qualified with `here::` or `inherited:`, whose scope does not exist in shared. Pages travel as the bytes their store holds, so a promoted page has one digest in both scopes.
+- Every promotion writes a record at `<shared>/.agent-knowledge/promotions/<digest>.json` naming the source run, each page digest, which pages were requested and which were carried support, the actor, the reason, and the time. The record is content-addressed, so re-running one promotion writes the same bytes at the same path. Read it back with `loadKnowledgePromotionRecord(sharedRoot, digest)`.
+- Add `RunScopedStores.storePath(runId)`. Promotion carries a page unchanged, which needs the store root a chain read hides.
+
+## 10.4.0 — 2026-08-21
+
+### Added
+
+- Add `buildKnowledgeBrief(visiblePages, question, options)`. It ranks the knowledge one question can see, renders a deterministic `- [id] title — snippet` line per page, and returns `results` in exactly the shape `createKnowledgeRetrievalReceipt` takes, so a retrieval is recorded rather than claimed. It is pure: no clock, no filesystem, no network. `excludeInvalidated` defaults to `true`, the opposite of `searchKnowledge`, because a brief offers every page it names with an id ready to cite.
+- The brief also returns `retrieverId` and `retrieverConfigDigest`, the retriever identity a receipt needs, so a caller declares only the running package version.
+- Add `searchKnowledgePages(pages, query, options)`, the ranking over a page set that is not a built index, such as the chain a run can see. `searchKnowledge(index, ...)` is now this function over `index.pages`, so the two entry points cannot drift.
+
+## 10.3.0 — 2026-08-21
+
+### Added
+
+- Add `planInvalidationPropagation(visiblePages)` and `formatKnowledgeInvalidationProposal(plan)`. Every page authored in the target store that cites a page carrying an `invalidation` is stamped with `citesInvalidated: [ids]`; a citation whose target was revalidated has the stamp removed. The plan is a diff, so a second pass over an already stamped store produces no mutation. Only `here` pages are stamped, because a run does not write the stores it inherits or shares.
+- Add the `cites-invalidated` lint finding, a warning naming every live citation from a page into a page its own evidence refuted.
+- Add `SearchKnowledgeOptions.excludeInvalidated`, which drops refuted pages from a result set. It defaults to `false`, so what search returns does not change for an existing caller.
+- Add `originatedPages(pages, origin?)`, which presents plain pages as a visibility chain of one origin, so citation resolution, the write intake gate, and invalidation propagation take one page shape whether or not the caller runs run-scoped stores.
+
+## 10.2.0 — 2026-08-21
+
+### Added
+
+- Add `assertKnowledgeWriteIntake(candidates, { visiblePages, nearDuplicates?, citations? })`, a write-time gate that refuses a page which restates visible knowledge without relating itself to it, and a page whose citation resolves to no visible page. A duplicate is cleared by citing the matched page, naming it in `contradicts`, or reusing its id so the write updates it. The candidates are part of the corpus both checks see, so a batch may cite a page it writes in the same call.
+- Add the `intake` option to `applyKnowledgeWriteBlocks` and `applyKnowledgeWriteBlocksFile`, and `--intake` / `--intake-threshold` to `agent-knowledge apply-write-blocks`. The gate runs inside the write lock and refuses the whole proposal, so a refused write leaves nothing on disk.
+- Add `knowledgePageFromMarkdown(path, content, pagesDirectory?)` and `isKnowledgePagePath(path)`. The reader and the intake gate build pages through this one constructor, so a gate judges exactly what the store loads back.
+
+## 10.1.0 — 2026-08-21
+
+### Changed
+
+- `searchKnowledge` ranks its lexical list with Okapi BM25 instead of the hand-weighted substring scorer. A term that occurs in most pages is discounted by inverse document frequency, term frequency saturates, and a long page no longer outranks a short one by repetition. An exact title or path match, a title that contains the query, and a body that contains the query stay ahead of a bag-of-words match, so exact lookups keep their order. The hit shape, `normalizedScore`, `snippet`, `reasons`, the reciprocal-rank fusion with the link graph, and the path tie-break are unchanged. There is no option to select the previous scorer.
+- The retrieval-eval retriever, the CLI `search` command, and `FileSystemSearchProvider` inherit the new ranking. The provider builds one lexical index per page index and drops both together on `refresh` or `invalidate()`.
+
+### Added
+
+- Add `buildKnowledgeLexicalIndex(pages, { tokenize, fieldBoosts })` and `scoreBm25(index, tokens, { k1, b })` in `src/lexical-index.ts`: a pure inverted index with field-boosted term frequencies, document lengths, average document length, and document count. No dependency and no native module, so the package stays importable at the edge.
+- Add `tokenizeText`, the token stream that indexing and querying share; `tokenizeQuery` is its distinct-token form and moves to the same module, so one tokenizer serves both sides and the vocabularies cannot drift.
+- Add `KNOWLEDGE_SEARCH_RETRIEVER_ID` (`bm25-rrf-v1`), the retriever identity to declare in a retrieval receipt minted from `searchKnowledge` results.
+- `SearchKnowledgeOptions.lexicalIndex` accepts an index built from exactly the searched pages, for a caller that queries one page index repeatedly. A mismatched index is refused.
+
+## 10.0.0 — 2026-08-20
+
+### Breaking Changes
+
+- **A retrieval receipt now references the visibility snapshot instead of embedding it.** `KnowledgeRetrievalReceipt.visibility` becomes `KnowledgeVisibilityRef { snapshotDigest, pageCount, artifact?: { uri, digest, byteLength } }`, and `KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION` becomes `2.0.0`. Every verifier refuses a `1.0.0` record, which has no reader. A receipt is now bounded by its results rather than by the visible page count.
+- **`createKnowledgeRetrievalReceipt` takes `visibility: KnowledgeVisibilitySnapshot` instead of `visiblePages`.** Create the snapshot once with `createKnowledgeVisibilitySnapshot` and reuse it for every retrieval over that view. Results still join against the snapshot entries, so a result absent from the view is refused as before. Repeated retrievals over one snapshot no longer re-serialize or re-hash the page inventory.
+- **The verification claim is split, so a check cannot overstate what it proved.** `verifyKnowledgeRetrievalReceipt(receipt)` proves receipt shape, canonical digest, rank continuity, finite scores, and a well-formed reference, and makes no result-to-snapshot claim. `assertKnowledgeRetrievalMatchesVisibility(receipt, snapshot | visiblePages)` recomputes the snapshot digest and page count and joins every returned result.
+
+### Added
+
+- Add `assertKnowledgeRetrievalMatchesVisibilityArtifact(receipt, loadArtifact)`, which loads the referenced snapshot artifact, checks its stored-byte digest and byte length, decodes and verifies the snapshot, and then proves the same join. A snapshot that cannot be obtained raises `KnowledgeVisibilityUnavailableError` with an explicit reason; it is never treated as an empty snapshot.
+- Add `verifyKnowledgeVisibilitySnapshot`, `encodeKnowledgeVisibilitySnapshot`, `decodeKnowledgeVisibilitySnapshot`, and `knowledgeVisibilityArtifactRef({ uri, bytes })` so an adapter persists and reloads a snapshot without inventing its serialization.
+
+## 9.0.0 — 2026-08-20
+
+### Breaking Changes
+
+- Rename `LoadKnowledgePagesOptions` to `KnowledgePagesOptions`. The same `{ pagesDirectory }` option now drives the write path as well as the reader, so the `Load` name no longer described it. Replace the type name; the option field is unchanged.
+
+**What to do:** import `KnowledgePagesOptions` where `LoadKnowledgePagesOptions` was imported. No runtime behavior changes for a caller that names no directory.
+
+### Added
+
+- `applyKnowledgeWriteBlocks(root, text, { pagesDirectory })` and `applyKnowledgeWriteBlocksFile` accept the pages directory the reader accepts. The parser allows only `FILE` blocks under `<pagesDirectory>/`, and the file transaction enforces the same bound, so a store laid out as `kb/pages/<line>/` can use the safe-write protocol.
+- `buildKnowledgeIndex`, `writeKnowledgeIndex`, `FileSystemSearchProviderOptions`, and `RunScopedStoresOptions` take `pagesDirectory`, so the custom directory is indexed, searched, and read through the lineage chain. The CLI takes `--pages-dir <dir>` on `apply-write-blocks`, `index`, `search`, and every other index-reading command.
+- `normalizePagesDirectory` and `DEFAULT_PAGES_DIRECTORY` are exported. The normalizer refuses `..`, `.` and empty segments, absolute paths, drive letters, control characters, and the package-owned `.agent-knowledge` and `raw` trees, because the value is a write allowlist prefix as well as a read location.
+- A knowledge file transaction journals the pages directory it was prepared under (`pagesDirectory`, absent for the default), so recovery and replay enforce the same allowlist as the prepare step. The default journal is byte-identical to before.
+
+## 8.1.0 — 2026-08-20
+
+### Added
+
+- Add `buildKnowledgeRelationGraph({ nodes, relations })`, which builds a labeled multi-edge graph from `KnowledgeRelation[]` and caller-declared nodes with a `kind`, `label`, and `metadata`. The graph keeps one edge per `(sourceId, targetId, predicate)`; a repeated triple is accepted only when it is byte-identical, and an endpoint outside the declared nodes is refused.
+- Add `neighbors`, `walk`, and `isReachable` over that graph, filtered by predicate and direction (`out`, `in`, `both`), with a cycle-safe breadth-first walk.
+- Add `KnowledgeRelationSchema`, `KnowledgeRelationNodeSchema`, and `KnowledgeRelationGraphSchema`, with an explicit `metadata` field so a persisted graph round-trips. `KnowledgeBaseCandidateSchema` uses the same relation schema.
+- Add `knowledgePageRelations(pages)`, the labeled page relations (`wikilink`, `citation`, `shared-source`, `contradicts`) that `buildKnowledgeGraph` now collapses into its weighted edges; the collapsed graph bytes are unchanged.
+
 ## 8.0.10 — 2026-08-19
 
 ### Changed

package/README.md

@@ -78,10 +78,19 @@ const search = createFileSystemSearchProvider({ root, index })
 console.log(await search.search('How long is the refund window?', { limit: 3 }))
 ```
 
-The provider uses the package's local text search.
+The provider ranks with BM25 over title, path, and body, keeps exact-title and phrase matches ahead of bag-of-words matches, and fuses that list with link and shared-source structure by reciprocal rank fusion.
+It builds the lexical index once per page index and drops both together on `refresh` or `invalidate()`.
+Declare `KNOWLEDGE_SEARCH_RETRIEVER_ID` (`bm25-rrf-v1`) as the retriever id when minting a retrieval receipt from these results.
 Pass `refresh: 'always'` to rebuild its index before every query, or call `invalidate()` after changing files.
 Use `asRetrievalEvalRetriever()` to send the same search path into retrieval tests.
 
+`knowledgePageRelations(pages)` lists the labeled relations between pages (`wikilink`, `citation`, `shared-source`, `contradicts`), and `buildKnowledgeGraph` collapses them into the weighted page graph stored in the index.
+For caller-defined provenance (runs, claims, models, any predicate), `buildKnowledgeRelationGraph({ nodes, relations })` keeps one edge per `(sourceId, targetId, predicate)`, refuses a conflicting repeat or an undeclared endpoint, and `neighbors`, `walk`, and `isReachable` query it by predicate and direction; `KnowledgeRelationGraphSchema` round-trips a persisted graph with its metadata.
+
+Pages live under `knowledge/` unless you name another root-relative directory.
+`loadKnowledgePages`, `buildKnowledgeIndex`, `writeKnowledgeIndex`, `applyKnowledgeWriteBlocks`, `createFileSystemSearchProvider`, and `createRunScopedStores` all take one `pagesDirectory` option (`KnowledgePagesOptions`), so a store laid out as `kb/pages/<line>/` is read, indexed, searched, chained, and written through the same value.
+The write protocol and the file transaction refuse a `FILE` block outside `<pagesDirectory>/`, and `normalizePagesDirectory` refuses `..`, absolute paths, drive letters, and the package-owned `.agent-knowledge` and `raw` trees.
+
 ## Prove what the agent saw and used
 
 A page existing in a knowledge base, a page appearing in retrieval results, and a page influencing a decision are three different facts. The receipt APIs preserve those joins without pretending they prove the page is true or that it improved the outcome.
@@ -91,16 +100,24 @@ import {
   createKnowledgeRetrievalReceipt,
   createKnowledgeUseReceipt,
   createKnowledgeVisibilitySnapshot,
+  encodeKnowledgeVisibilitySnapshot,
+  KNOWLEDGE_SEARCH_RETRIEVER_ID,
+  knowledgeVisibilityArtifactRef,
 } from '@tangle-network/agent-knowledge'
 
-const visiblePages = await runStores.loadChain(runId)
-const visibility = createKnowledgeVisibilitySnapshot(visiblePages)
+const visibility = createKnowledgeVisibilitySnapshot(await runStores.loadChain(runId))
+const bytes = encodeKnowledgeVisibilitySnapshot(visibility)
+await artifacts.put('artifact://run/visibility.json', bytes)
 
 const retrieval = createKnowledgeRetrievalReceipt({
   runId,
   query: 'prior verifier obstruction',
-  retriever: { id: 'hybrid-search', version: '1.0.0', configDigest },
-  visiblePages,
+  retriever: { id: KNOWLEDGE_SEARCH_RETRIEVER_ID, version: '1.0.0', configDigest },
+  visibility,
+  visibilityArtifact: knowledgeVisibilityArtifactRef({
+    uri: 'artifact://run/visibility.json',
+    bytes,
+  }),
   results,
 })
 
@@ -116,6 +133,9 @@ console.log(visibility.snapshotDigest, retrieval.receiptDigest, use.receiptDiges
 
 ELI5: the visibility snapshot is the bookshelf the agent was allowed to see, the retrieval receipt is the exact books search handed back, and the use receipt records which returned book the agent attached to a downstream decision or artifact.
 
+Create the snapshot once per knowledge view and reuse it: the retrieval receipt stores the snapshot's digest, page count, and storage locator, not its pages, so repeated queries over one view do not re-serialize the inventory.
+`verifyKnowledgeRetrievalReceipt` proves the receipt itself; `assertKnowledgeRetrievalMatchesVisibility` and `assertKnowledgeRetrievalMatchesVisibilityArtifact` prove that every returned result occurs in that exact snapshot.
+
 The receipts are content-addressed and mutation-sensitive. They do **not** establish correctness, novelty, compliance, or causal lift; Eval owns those later judgments. Read [knowledge retrieval and use receipts](docs/knowledge-use-receipts.md) for the complete proof boundary, trace attributes, and experiment design.
 
 ## Use the CLI
@@ -132,6 +152,20 @@ pnpm exec agent-knowledge validate --strict --root ./support-kb
 ```
 
 Run `pnpm exec agent-knowledge help` for every command.
+Pass `--pages-dir <dir>` to `apply-write-blocks`, `index`, `search`, and the other index-reading commands when the pages live outside `knowledge/`.
+
+## Gate a write before it lands
+
+A store degrades in two ways no later report reverses: a page restates knowledge already in the store without relating itself to it, and a page cites an id that exists nowhere.
+`assertKnowledgeWriteIntake(candidates, { visiblePages })` refuses both, and `applyKnowledgeWriteBlocks(root, text, { intake })` runs it inside the write lock, so a refused proposal writes nothing.
+
+```bash
+pnpm exec agent-knowledge apply-write-blocks ./proposal.txt --root ./support-kb --intake
+```
+
+A duplicate is cleared by one authoring action, each of which turns the duplication into structure: cite the matched page, name it in `contradicts`, or give the candidate that page's id so the write updates it.
+The candidates are part of the corpus both checks see, so a proposal may cite a page it writes in the same call.
+`--intake-threshold` sets the duplicate similarity; the near-duplicate detector's own default applies when it is absent.
 
 The default layout is:
 
@@ -144,6 +178,94 @@ support-kb/
     index.json                 # generated search index
 ```
 
+## Give an agent the tools
+
+`createKnowledgeTools` returns provider-neutral `ToolDefinition[]` for search, read, record, and resolve. Knowledge owns what each tool does; a runtime only transports the definitions and the calls.
+
+```ts
+const tools = createKnowledgeTools({
+  stores,
+  runId,
+  retrieverVersion,
+  actorId,
+  intake: {},
+  recordRetrieval: (receipt) => ledger.append(receipt),
+})
+```
+
+`knowledge_search` builds a brief and mints a retrieval receipt on every call, so retrieval is recorded by the infrastructure rather than claimed by the run.
+`knowledge_read` reports an id visible at two origins as `ambiguous` with both candidates, and never chooses one.
+`knowledge_record` writes into this run's store through the intake gate.
+`knowledge_resolve` returns the resolution status of each reference.
+
+Supply `retrieverVersion` yourself: a bundled build cannot read its own manifest, and a receipt that guessed the version would be a receipt that lies about what ranked the results.
+
+When a retrieval influences nothing, record that too:
+
+```ts
+createKnowledgeRetrievalDisposition({
+  retrieval: receipt,
+  relation: 'no-use',
+  consumer: { kind: 'decision', uri },
+})
+```
+
+A use receipt requires a selected rank, so without this record a retrieval that influenced nothing is indistinguishable from a retrieval nobody bothered to record. `irrelevant` means the results did not bear on the question; `no-use` means they did and the consumer still used none of them.
+
+## Promote a run's knowledge into the shared store
+
+A run writes only its own store. Knowledge reaches the curated shared store through one call, and every promotion leaves a record:
+
+```ts
+const record = await promoteRunScopedPages(stores, runId, {
+  pageIds: ['latency-budget'],
+  sharedRoot,
+  actor: 'drew',
+  reason: 'The measurement replicated twice.',
+})
+```
+
+A claim's cited support travels with it. Promoting a claim and leaving the run-local pages it cites behind is what turns a resolved citation into a dangling one, so the closure of cited pages is carried, each keeping its own evidence fields exactly as written — a promoted claim cannot inherit a confidence its support does not carry.
+The promotion is refused when any citation would not resolve in the shared store, including a citation qualified with `here::` or `inherited:`, whose scope does not exist there.
+Pages travel as the bytes their store holds, so a promoted page has one digest in both scopes.
+The record lands at `<shared>/.agent-knowledge/promotions/<digest>.json` with the source run, every page digest, which pages were requested and which were carried support, the actor, the reason, and the time. Re-running the same promotion writes the same record at the same path.
+
+## Brief a run before its first token
+
+"Search the store first" is an instruction an agent may or may not follow. A brief is infrastructure: it retrieves the settled knowledge a question can reach and hands it over with the ids a later write must cite.
+
+```ts
+const brief = buildKnowledgeBrief(originatedPages(await loadKnowledgePages(root)), question)
+const receipt = createKnowledgeRetrievalReceipt({
+  runId,
+  query: brief.question,
+  retriever: { id: brief.retrieverId, version, configDigest: brief.retrieverConfigDigest },
+  visibility: createKnowledgeVisibilitySnapshot(visiblePages),
+  results: brief.results,
+})
+```
+
+`brief.text` is deterministic Markdown, one `- [id] title — snippet` line per page in rank order.
+`brief.results` is the exact shape `createKnowledgeRetrievalReceipt` takes, so what an actor was given is recorded rather than asserted.
+`excludeInvalidated` defaults to **true** here, the opposite of `searchKnowledge`: a brief offers every page it names with an id ready to cite, so a refuted page in it invites a run to build on a dead claim.
+`maxChars` bounds the brief, and a page whose line does not fit is left out of `text`, `hits`, `citationIds`, and `results` alike, so all four always describe one identical set.
+
+## Propagate an invalidation
+
+A page whose own evidence refuted it carries an `invalidation`. A reader who arrives through a citation never meets that verdict, so run the propagation pass after grading:
+
+```ts
+const plan = planInvalidationPropagation(originatedPages(await loadKnowledgePages(root)))
+if (plan.stamps.length > 0) {
+  await applyKnowledgeWriteBlocks(root, formatKnowledgeInvalidationProposal(plan))
+}
+```
+
+Each stamped page records `citesInvalidated: [ids]` in its frontmatter, and nothing else changes.
+The plan is a diff, so a second pass over an already stamped store produces no mutation, and a citation whose target was revalidated has its stamp removed.
+`agent-knowledge lint` reports a `cites-invalidated` warning for every live citation into a refuted page, and `searchKnowledge(index, query, { excludeInvalidated: true })` drops the refuted pages from a result set.
+The default stays `false`: a caller reading history needs them.
+
 ## Improve a live knowledge base
 
 `improveKnowledgeBase` creates an isolated candidate, runs your update callback, measures the candidate, and returns an exact candidate reference.

package/dist/benchmarks/index.d.ts

@@ -1,2 +1,2 @@
-import { A as KnowledgeBenchmarkResponder, B as KnowledgeMemoryEvent, C as KnowledgeBenchmarkArtifact, Ct as createInMemoryBenchmarkAdapter, D as KnowledgeBenchmarkEvaluation, E as KnowledgeBenchmarkDistribution, F as KnowledgeBenchmarkSplit, G as MemoryAdapterBenchmarkCandidate, H as KnowledgeRetrievalBenchmarkCase, I as KnowledgeBenchmarkTaskKind, J as RunKnowledgeBenchmarkSuiteResult, K as MemoryAdapterBenchmarkRankingRow, L as KnowledgeClaimMatcher, M as KnowledgeBenchmarkSliceSummary, N as KnowledgeBenchmarkSource, O as KnowledgeBenchmarkFamily, P as KnowledgeBenchmarkSpec, R as KnowledgeMemoryBenchmarkCase, S as KnowledgeAnswerBenchmarkTaskKind, T as KnowledgeBenchmarkCaseBase, U as KnowledgeRetrievalBenchmarkQrel, V as KnowledgeMemoryFactMatcher, W as KnowledgeRetrievalBenchmarkQuery, X as RunMemoryAdapterBenchmarkResult, Y as RunMemoryAdapterBenchmarkOptions, _ as buildIndustryRagBenchmarkSmokeCases, a as runKnowledgeBenchmarkSuite, b as BuildRetrievalBenchmarkCasesFromQrelsOptions, c as buildRetrievalBenchmarkCasesFromQrels, d as summarizeKnowledgeBenchmarkCampaign, f as runMemoryAdapterBenchmark, g as buildIndustryMemoryBenchmarkSmokeCases, h as buildFirstPartyMemoryLifecycleBenchmarkCases, i as renderKnowledgeBenchmarkReportMarkdown, j as KnowledgeBenchmarkScenario, k as KnowledgeBenchmarkReport, l as parseKnowledgeBenchmarkJsonl, m as INDUSTRY_RAG_BENCHMARKS, n as buildKnowledgeBenchmarkScenarios, o as scoreKnowledgeBenchmarkArtifact, p as INDUSTRY_MEMORY_BENCHMARKS, q as RunKnowledgeBenchmarkSuiteOptions, r as knowledgeBenchmarkJudge, s as scoreMemoryBenchmarkArtifact, t as isKnowledgeMemoryBenchmarkCase, u as parseKnowledgeBenchmarkQrels, v as respondToIndustryMemoryBenchmarkSmokeCase, w as KnowledgeBenchmarkCase, wt as createNoopMemoryBenchmarkAdapter, x as KnowledgeAnswerBenchmarkCase, y as respondToIndustryRagBenchmarkSmokeCase, z as KnowledgeMemoryBenchmarkTaskKind } from "../index-DypNCZtP.js";
+import { A as KnowledgeBenchmarkResponder, B as KnowledgeMemoryEvent, C as KnowledgeBenchmarkArtifact, Ct as createInMemoryBenchmarkAdapter, D as KnowledgeBenchmarkEvaluation, E as KnowledgeBenchmarkDistribution, F as KnowledgeBenchmarkSplit, G as MemoryAdapterBenchmarkCandidate, H as KnowledgeRetrievalBenchmarkCase, I as KnowledgeBenchmarkTaskKind, J as RunKnowledgeBenchmarkSuiteResult, K as MemoryAdapterBenchmarkRankingRow, L as KnowledgeClaimMatcher, M as KnowledgeBenchmarkSliceSummary, N as KnowledgeBenchmarkSource, O as KnowledgeBenchmarkFamily, P as KnowledgeBenchmarkSpec, R as KnowledgeMemoryBenchmarkCase, S as KnowledgeAnswerBenchmarkTaskKind, T as KnowledgeBenchmarkCaseBase, U as KnowledgeRetrievalBenchmarkQrel, V as KnowledgeMemoryFactMatcher, W as KnowledgeRetrievalBenchmarkQuery, X as RunMemoryAdapterBenchmarkResult, Y as RunMemoryAdapterBenchmarkOptions, _ as buildIndustryRagBenchmarkSmokeCases, a as runKnowledgeBenchmarkSuite, b as BuildRetrievalBenchmarkCasesFromQrelsOptions, c as buildRetrievalBenchmarkCasesFromQrels, d as summarizeKnowledgeBenchmarkCampaign, f as runMemoryAdapterBenchmark, g as buildIndustryMemoryBenchmarkSmokeCases, h as buildFirstPartyMemoryLifecycleBenchmarkCases, i as renderKnowledgeBenchmarkReportMarkdown, j as KnowledgeBenchmarkScenario, k as KnowledgeBenchmarkReport, l as parseKnowledgeBenchmarkJsonl, m as INDUSTRY_RAG_BENCHMARKS, n as buildKnowledgeBenchmarkScenarios, o as scoreKnowledgeBenchmarkArtifact, p as INDUSTRY_MEMORY_BENCHMARKS, q as RunKnowledgeBenchmarkSuiteOptions, r as knowledgeBenchmarkJudge, s as scoreMemoryBenchmarkArtifact, t as isKnowledgeMemoryBenchmarkCase, u as parseKnowledgeBenchmarkQrels, v as respondToIndustryMemoryBenchmarkSmokeCase, w as KnowledgeBenchmarkCase, wt as createNoopMemoryBenchmarkAdapter, x as KnowledgeAnswerBenchmarkCase, y as respondToIndustryRagBenchmarkSmokeCase, z as KnowledgeMemoryBenchmarkTaskKind } from "../index-DZeFm-BP.js";
 export { type BuildRetrievalBenchmarkCasesFromQrelsOptions, INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, type KnowledgeAnswerBenchmarkCase, type KnowledgeAnswerBenchmarkTaskKind, type KnowledgeBenchmarkArtifact, type KnowledgeBenchmarkCase, type KnowledgeBenchmarkCaseBase, type KnowledgeBenchmarkDistribution, type KnowledgeBenchmarkEvaluation, type KnowledgeBenchmarkFamily, type KnowledgeBenchmarkReport, type KnowledgeBenchmarkResponder, type KnowledgeBenchmarkScenario, type KnowledgeBenchmarkSliceSummary, type KnowledgeBenchmarkSource, type KnowledgeBenchmarkSpec, type KnowledgeBenchmarkSplit, type KnowledgeBenchmarkTaskKind, type KnowledgeClaimMatcher, type KnowledgeMemoryBenchmarkCase, type KnowledgeMemoryBenchmarkTaskKind, type KnowledgeMemoryEvent, type KnowledgeMemoryFactMatcher, type KnowledgeRetrievalBenchmarkCase, type KnowledgeRetrievalBenchmarkQrel, type KnowledgeRetrievalBenchmarkQuery, type MemoryAdapterBenchmarkCandidate, type MemoryAdapterBenchmarkRankingRow, type RunKnowledgeBenchmarkSuiteOptions, type RunKnowledgeBenchmarkSuiteResult, type RunMemoryAdapterBenchmarkOptions, type RunMemoryAdapterBenchmarkResult, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildRetrievalBenchmarkCasesFromQrels, createInMemoryBenchmarkAdapter, createNoopMemoryBenchmarkAdapter, isKnowledgeMemoryBenchmarkCase, knowledgeBenchmarkJudge, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, renderKnowledgeBenchmarkReportMarkdown, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, runKnowledgeBenchmarkSuite, runMemoryAdapterBenchmark, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, summarizeKnowledgeBenchmarkCampaign };

package/dist/benchmarks/index.js

@@ -1,2 +1,2 @@
-import { B as createNoopMemoryBenchmarkAdapter, F as buildIndustryRagBenchmarkSmokeCases, I as respondToIndustryMemoryBenchmarkSmokeCase, L as respondToIndustryRagBenchmarkSmokeCase, M as INDUSTRY_RAG_BENCHMARKS, N as buildFirstPartyMemoryLifecycleBenchmarkCases, P as buildIndustryMemoryBenchmarkSmokeCases, R as isKnowledgeMemoryBenchmarkCase, a as buildKnowledgeBenchmarkScenarios, c as runKnowledgeBenchmarkSuite, d as summarizeKnowledgeBenchmarkCampaign, i as runMemoryAdapterBenchmark, j as INDUSTRY_MEMORY_BENCHMARKS, l as scoreKnowledgeBenchmarkArtifact, n as parseKnowledgeBenchmarkJsonl, o as knowledgeBenchmarkJudge, r as parseKnowledgeBenchmarkQrels, s as renderKnowledgeBenchmarkReportMarkdown, t as buildRetrievalBenchmarkCasesFromQrels, u as scoreMemoryBenchmarkArtifact, z as createInMemoryBenchmarkAdapter } from "../benchmarks-B_07vX0Q.js";
+import { B as createNoopMemoryBenchmarkAdapter, F as buildIndustryRagBenchmarkSmokeCases, I as respondToIndustryMemoryBenchmarkSmokeCase, L as respondToIndustryRagBenchmarkSmokeCase, M as INDUSTRY_RAG_BENCHMARKS, N as buildFirstPartyMemoryLifecycleBenchmarkCases, P as buildIndustryMemoryBenchmarkSmokeCases, R as isKnowledgeMemoryBenchmarkCase, a as buildKnowledgeBenchmarkScenarios, c as runKnowledgeBenchmarkSuite, d as summarizeKnowledgeBenchmarkCampaign, i as runMemoryAdapterBenchmark, j as INDUSTRY_MEMORY_BENCHMARKS, l as scoreKnowledgeBenchmarkArtifact, n as parseKnowledgeBenchmarkJsonl, o as knowledgeBenchmarkJudge, r as parseKnowledgeBenchmarkQrels, s as renderKnowledgeBenchmarkReportMarkdown, t as buildRetrievalBenchmarkCasesFromQrels, u as scoreMemoryBenchmarkArtifact, z as createInMemoryBenchmarkAdapter } from "../benchmarks-B6fCb6AD.js";
 export { INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildRetrievalBenchmarkCasesFromQrels, createInMemoryBenchmarkAdapter, createNoopMemoryBenchmarkAdapter, isKnowledgeMemoryBenchmarkCase, knowledgeBenchmarkJudge, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, renderKnowledgeBenchmarkReportMarkdown, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, runKnowledgeBenchmarkSuite, runMemoryAdapterBenchmark, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, summarizeKnowledgeBenchmarkCampaign };

package/dist/{benchmarks-B_07vX0Q.js → benchmarks-B6fCb6AD.js}

@@ -1,5 +1,5 @@
 import { r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { n as searchKnowledge } from "./search-CtVJ0PKX.js";
+import { r as searchKnowledge } from "./search-Cw6eYfSd.js";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { canonicalJson } from "@tangle-network/agent-eval";
@@ -2783,4 +2783,4 @@ function defaultDocumentTarget(documentId, targetKind) {
 //#endregion
 export { reserveRecoveryAttempts as A, createNoopMemoryBenchmarkAdapter as B, sleepForMemoryRecovery as C, hasSettledPaidCall as D, assertNoInterruptedPaidCalls as E, buildIndustryRagBenchmarkSmokeCases as F, retrievalConfigFromSurface as G, memoryWriteResultToSourceRecord as H, respondToIndustryMemoryBenchmarkSmokeCase as I, scoreRetrievalArtifact as J, retrievalConfigSurface as K, respondToIndustryRagBenchmarkSmokeCase as L, INDUSTRY_RAG_BENCHMARKS as M, buildFirstPartyMemoryLifecycleBenchmarkCases as N, readActiveAttemptJournal as O, buildIndustryMemoryBenchmarkSmokeCases as P, isKnowledgeMemoryBenchmarkCase as R, runBoundedMemoryLifecycle as S, appendDurableJournalEvent as T, buildRetrievalEvalDispatch as U, memoryHitToSourceRecord as V, partitionRetrievalScenarios as W, MEMORY_OPERATION_CANCELLATION_TIMEOUT_MS as _, buildKnowledgeBenchmarkScenarios as a, memoryRecoveryDelayMs as b, runKnowledgeBenchmarkSuite as c, summarizeKnowledgeBenchmarkCampaign as d, acquireAgentMemoryRunLease as f, MEMORY_CAMPAIGN_DISPATCH_SHUTDOWN_TIMEOUT_MS as g, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS as h, runMemoryAdapterBenchmark as i, INDUSTRY_MEMORY_BENCHMARKS as j, reconcileInterruptedMemoryPaidCalls as k, scoreKnowledgeBenchmarkArtifact as l, AgentMemoryLifecycleUnsafeError as m, parseKnowledgeBenchmarkJsonl as n, knowledgeBenchmarkJudge as o, AgentMemoryLifecycleTimeoutError as p, retrievalRecallJudge as q, parseKnowledgeBenchmarkQrels as r, renderKnowledgeBenchmarkReportMarkdown as s, buildRetrievalBenchmarkCasesFromQrels as t, scoreMemoryBenchmarkArtifact as u, createBoundedMemoryAdapter as v, appendAttemptJournalEvent as w, resolveMemoryCleanupTimeoutMs as x, createMemoryExecutionPool as y, createInMemoryBenchmarkAdapter as z };
 
-//# sourceMappingURL=benchmarks-B_07vX0Q.js.map
+//# sourceMappingURL=benchmarks-B6fCb6AD.js.map