@tangle-network/agent-knowledge 19.1.5 → 20.0.0

package/dist/source-record-CdWvzvO6.js

@@ -0,0 +1,39 @@
+import { r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
+//#region src/memory/source-record.ts
+function memoryHitToSourceRecord(hit, options = {}) {
+	const contentHash = sha256(`${hit.uri}\n${hit.text}`);
+	return {
+		id: stableId("src", `${hit.uri}:${contentHash}`),
+		uri: hit.uri,
+		title: hit.title ?? `${hit.kind}:${hit.id}`,
+		mediaType: "text/plain",
+		contentHash,
+		text: hit.text,
+		validUntil: hit.validUntil,
+		lastVerifiedAt: hit.lastVerifiedAt,
+		createdAt: (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
+		metadata: {
+			...hit.metadata ?? {},
+			source: "agent-memory",
+			memoryId: hit.id,
+			memoryKind: hit.kind,
+			score: hit.score,
+			normalizedScore: hit.normalizedScore,
+			confidence: hit.confidence,
+			scope: options.scope
+		}
+	};
+}
+function memoryWriteResultToSourceRecord(result, text, options = {}) {
+	return memoryHitToSourceRecord({
+		id: result.id,
+		uri: result.uri,
+		kind: result.kind,
+		text,
+		metadata: result.metadata
+	}, options);
+}
+//#endregion
+export { memoryWriteResultToSourceRecord as n, memoryHitToSourceRecord as t };
+
+//# sourceMappingURL=source-record-CdWvzvO6.js.map

package/dist/source-record-CdWvzvO6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-record-CdWvzvO6.js","names":[],"sources":["../src/memory/source-record.ts"],"sourcesContent":["import { sha256, stableId } from '../ids'\nimport type { SourceRecord } from '../types'\nimport type { AgentMemoryHit, AgentMemoryScope, AgentMemoryWriteResult } from './types'\n\nexport function memoryHitToSourceRecord(\n  hit: AgentMemoryHit,\n  options: { now?: () => Date; scope?: AgentMemoryScope } = {},\n): SourceRecord {\n  const contentHash = sha256(`${hit.uri}\\n${hit.text}`)\n  return {\n    id: stableId('src', `${hit.uri}:${contentHash}`),\n    uri: hit.uri,\n    title: hit.title ?? `${hit.kind}:${hit.id}`,\n    mediaType: 'text/plain',\n    contentHash,\n    text: hit.text,\n    validUntil: hit.validUntil,\n    lastVerifiedAt: hit.lastVerifiedAt,\n    createdAt: (options.now ?? (() => new Date()))().toISOString(),\n    metadata: {\n      ...(hit.metadata ?? {}),\n      source: 'agent-memory',\n      memoryId: hit.id,\n      memoryKind: hit.kind,\n      score: hit.score,\n      normalizedScore: hit.normalizedScore,\n      confidence: hit.confidence,\n      scope: options.scope,\n    },\n  }\n}\n\nexport function memoryWriteResultToSourceRecord(\n  result: AgentMemoryWriteResult,\n  text: string,\n  options: { now?: () => Date; scope?: AgentMemoryScope } = {},\n): SourceRecord {\n  return memoryHitToSourceRecord(\n    {\n      id: result.id,\n      uri: result.uri,\n      kind: result.kind,\n      text,\n      metadata: result.metadata,\n    },\n    options,\n  )\n}\n"],"mappings":";;AAIA,SAAgB,wBACd,KACA,UAA0D,CAAC,GAC7C;CACd,MAAM,cAAc,OAAO,GAAG,IAAI,IAAI,IAAI,IAAI,MAAM;CACpD,OAAO;EACL,IAAI,SAAS,OAAO,GAAG,IAAI,IAAI,GAAG,aAAa;EAC/C,KAAK,IAAI;EACT,OAAO,IAAI,SAAS,GAAG,IAAI,KAAK,GAAG,IAAI;EACvC,WAAW;EACX;EACA,MAAM,IAAI;EACV,YAAY,IAAI;EAChB,gBAAgB,IAAI;EACpB,YAAY,QAAQ,8BAAc,IAAI,KAAK,GAAA,CAAI,CAAC,CAAC,YAAY;EAC7D,UAAU;GACR,GAAI,IAAI,YAAY,CAAC;GACrB,QAAQ;GACR,UAAU,IAAI;GACd,YAAY,IAAI;GAChB,OAAO,IAAI;GACX,iBAAiB,IAAI;GACrB,YAAY,IAAI;GAChB,OAAO,QAAQ;EACjB;CACF;AACF;AAEA,SAAgB,gCACd,QACA,MACA,UAA0D,CAAC,GAC7C;CACd,OAAO,wBACL;EACE,IAAI,OAAO;EACX,KAAK,OAAO;EACZ,MAAM,OAAO;EACb;EACA,UAAU,OAAO;CACnB,GACA,OACF;AACF"}

package/dist/types-BWV_Fvp7.d.ts

@@ -0,0 +1,224 @@
+import { k as SourceRecord } from "./types-BekdNwGD.js";
+//#region src/memory/types.d.ts
+type AgentMemoryKind = 'message' | 'entity' | 'fact' | 'preference' | 'observation' | 'reasoning-trace';
+interface AgentMemoryScope {
+  tenantId?: string;
+  userId?: string;
+  agentId?: string;
+  teamId?: string;
+  runId?: string;
+  sessionId?: string;
+  namespace?: string;
+  tags?: Record<string, string>;
+}
+interface AgentMemoryHit {
+  id: string;
+  uri: string;
+  kind: AgentMemoryKind;
+  text: string;
+  title?: string;
+  score?: number;
+  normalizedScore?: number;
+  confidence?: number;
+  createdAt?: string;
+  validUntil?: string;
+  lastVerifiedAt?: string;
+  metadata?: Record<string, unknown>;
+}
+interface AgentMemoryContext {
+  query: string;
+  text: string;
+  hits: AgentMemoryHit[];
+  sourceRecords: SourceRecord[];
+  metadata?: Record<string, unknown>;
+}
+interface AgentMemorySearchOptions {
+  scope?: AgentMemoryScope;
+  limit?: number;
+  minScore?: number;
+  kinds?: AgentMemoryKind[];
+  metadata?: Record<string, unknown>;
+  /**
+   * Opt-in randomized retrieval holdout (epsilon-dropout) for treatment-effect logging.
+   * Absent by default; when absent, retrieval behavior is unchanged. See ./holdout.
+   */
+  holdout?: RetrievalHoldoutConfig;
+}
+interface AgentMemoryWriteInput {
+  kind: AgentMemoryKind;
+  text: string;
+  id?: string;
+  title?: string;
+  role?: 'system' | 'user' | 'assistant' | 'tool';
+  entityName?: string;
+  entityType?: string;
+  category?: string;
+  predicate?: string;
+  subject?: string;
+  object?: string;
+  confidence?: number;
+  scope?: AgentMemoryScope;
+  metadata?: Record<string, unknown>;
+}
+interface AgentMemoryWriteResult {
+  accepted: boolean;
+  id: string;
+  uri: string;
+  kind: AgentMemoryKind;
+  sourceRecord?: SourceRecord;
+  metadata?: Record<string, unknown>;
+}
+type AgentMemoryBranchIsolation = {
+  mode: 'scoped';
+  /** False when writes may outlive the worker process that issued them. */
+  processExitSafe?: boolean;
+  /** Wait before clearing an abandoned branch so accepted asynchronous writes become visible. */
+  recoveryDelayMs?: number;
+} | {
+  mode: 'instance';
+  branchId: string;
+  /** True only when the dedicated instance also enforces every logical scope. */
+  supportsLogicalScopes?: boolean;
+} | {
+  mode: 'unsupported';
+  reason: string;
+};
+interface AgentMemoryAdapter {
+  readonly id: string;
+  /** How this adapter prevents candidate branches from reading each other's state. */
+  readonly branchIsolation?: AgentMemoryBranchIsolation;
+  search(query: string, options?: AgentMemorySearchOptions): Promise<AgentMemoryHit[]>;
+  getContext(query: string, options?: AgentMemorySearchOptions): Promise<AgentMemoryContext>;
+  write(input: AgentMemoryWriteInput): Promise<AgentMemoryWriteResult>;
+  /** Delete exactly this scope. Repeated and concurrent calls for the same scope must be safe. */
+  clear?(scope?: AgentMemoryScope): Promise<void>;
+  flush?(): Promise<void>;
+  close?(): Promise<void>;
+}
+/**
+ * Optional session-level retrieval dropout for estimating whether delivered memories affect
+ * task outcomes. The feature is disabled unless configured, and consumers persist events
+ * through `onEvent`.
+ */
+interface RetrievalHoldoutConfig {
+  /** Per-session probability that one eligible watchlist item is suppressed. 0 logs the full schema without ever dropping. */
+  epsilon: number;
+  /** Item ids eligible for suppression. Empty or absent means no item can ever be dropped. */
+  watchlist?: string[];
+  /** Ties every event to the exact epsilon/watchlist in force, for audit and replay. */
+  configVersion?: string;
+  /** Copied onto every event so multi-adapter logs stay attributable. */
+  adapterId?: string;
+  /** Corpus/store version stamp; an edited item under the same id is a different treatment. */
+  corpusVersion?: string;
+  /**
+   * Emit plaintext sessionId and scope on events. Default false: events carry only
+   * sessionIdHash/scopeHash, so PII-bearing identifiers (tenantId/userId/tags) never reach a
+   * consumer-controlled sink unless the consumer explicitly owns that decision. Note that
+   * replaying assignment draws from logs alone needs the plaintext sessionId, so
+   * privacy-preserving logs require the consumer's own sessionId mapping for replay.
+   */
+  includePlaintextIdentifiers?: boolean;
+  /**
+   * Cap on tracked sessions per experiment config in the sticky wrapper's registry.
+   * The default is 10,000.
+   */
+  maxTrackedSessions?: number;
+  /**
+   * Uniform-[0,1) generator keyed by a string. Defaults to a sha256-derived deterministic
+   * generator so every assignment is replayable from the logged keys alone.
+   */
+  rng?: (key: string) => number;
+  /** Receives one event per retrieval call, including calls where nothing is dropped. */
+  onEvent: (event: RetrievalHoldoutEvent) => void;
+}
+interface RetrievalHoldoutEligibleItem {
+  id: string;
+  /** 1-based position in the post-filter hit list. */
+  rank: number;
+  score?: number;
+  kind: string;
+  /** sha256(hit.text) prefix; effects are estimated per (id, contentHash) pair. */
+  contentHash: string;
+}
+interface RetrievalHoldoutEvent {
+  v: 1;
+  eventId: string;
+  ts: string;
+  adapterId?: string;
+  /** Plaintext session id, emitted only when `includePlaintextIdentifiers` is true. */
+  sessionId?: string;
+  /** Consumer-supplied experiment/outcome join id (scope.tags.taskId); deliberately plaintext. */
+  taskId?: string;
+  /** 1-based call counter within the session; 0 when the call is outside session randomization. */
+  callIndex: number;
+  /**
+   * sha256(sessionId) prefix used as the privacy-preserving join key and assignment seed.
+   */
+  sessionIdHash?: string;
+  queryHash?: string;
+  /** Verbatim scope, emitted only when `includePlaintextIdentifiers` is true. */
+  scope?: AgentMemoryScope;
+  /** sha256 prefix of the canonical-JSON scope (keys sorted, undefined stripped). */
+  scopeHash?: string;
+  config: {
+    epsilon: number;
+    watchlist: string[];
+    configVersion?: string;
+  };
+  /**
+   * Value-hash of the experiment-defining knobs, sha256({epsilon, sorted watchlist}) prefix.
+   * The estimator groups events by it; the sticky-session registry is keyed by it.
+   */
+  configHash: string;
+  /**
+   * False when no sessionId is available or the adapter answered without retrieval
+   * (see bypassReason), so the fraction-under-experiment denominator stays honest.
+   */
+  holdoutEligible: boolean;
+  /** Present only on adapter paths that bypassed retrieval, where no suppression could apply. */
+  bypassReason?: RetrievalHoldoutBypassReason;
+  /** The full post-filter eligibility set E, logged on every call (control arm + interference probes). */
+  eligible: RetrievalHoldoutEligibleItem[];
+  /** Ids in watchlist ∩ E, in eligibility order. */
+  watchlistEligible: string[];
+  sessionHoldout: boolean;
+  /** The session's sticky drop target once drawn; distinguishes "target absent from E" from "not yet drawn". */
+  sessionTargetId: string | null;
+  /** The item suppressed in THIS call, or null. */
+  droppedId: string | null;
+  /** 1/|watchlist ∩ E| recorded at draw time; the exact inverse-propensity weight input. */
+  pickPropensity: number | null;
+  /** epsilon * pickPropensity, recorded at draw time so analysis never re-derives assignment probabilities. */
+  dropPropensity: number | null;
+  deliveredIds: string[];
+  corpusVersion?: string;
+}
+interface RetrievalHoldoutSessionState {
+  sessionId: string;
+  /** Calls observed so far in this session. */
+  callCount: number;
+  sessionHoldout: boolean;
+  /** Sticky drop target; drawn once at the first call whose eligibility set intersects the watchlist. */
+  targetId: string | null;
+  pickPropensity: number | null;
+}
+interface RetrievalHoldoutCallContext {
+  sessionId?: string;
+  taskId?: string;
+  /** Raw query; only its sha256 prefix is logged. */
+  query?: string;
+  scope?: AgentMemoryScope;
+  /** State returned by the previous call of this session; threading it is what makes suppression sticky. */
+  session?: RetrievalHoldoutSessionState;
+}
+interface RetrievalHoldoutResult {
+  delivered: AgentMemoryHit[];
+  event: RetrievalHoldoutEvent;
+  session?: RetrievalHoldoutSessionState;
+}
+/** Adapter context paths that answer without retrieval, so no holdout draw can happen. */
+type RetrievalHoldoutBypassReason = 'short-term-context' | 'raw-string-context';
+//#endregion
+export { AgentMemoryKind as a, AgentMemoryWriteInput as c, RetrievalHoldoutCallContext as d, RetrievalHoldoutConfig as f, RetrievalHoldoutSessionState as g, RetrievalHoldoutResult as h, AgentMemoryHit as i, AgentMemoryWriteResult as l, RetrievalHoldoutEvent as m, AgentMemoryBranchIsolation as n, AgentMemoryScope as o, RetrievalHoldoutEligibleItem as p, AgentMemoryContext as r, AgentMemorySearchOptions as s, AgentMemoryAdapter as t, RetrievalHoldoutBypassReason as u };
+//# sourceMappingURL=types-BWV_Fvp7.d.ts.map

package/dist/types-BWV_Fvp7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BWV_Fvp7.d.ts","names":[],"sources":["../src/memory/types.ts"],"mappings":";;KAEY;UAQK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA,OAAO;;UAGQ;EACf;EACA;EACA,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;;UAGI;EACf;EACA;EACA,MAAM;EACN,eAAe;EACf,WAAW;;UAGI;EACf,QAAQ;EACR;EACA;EACA,QAAQ;EACR,WAAW;;;;;EAKX,UAAU;;UAGK;EACf,MAAM;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;EACR,WAAW;;UAGI;EACf;EACA;EACA;EACA,MAAM;EACN,eAAe;EACf,WAAW;;KAGD;EAEN;;EAEA;;EAEA;;EAGA;EACA;;EAEA;;EAEA;EAAqB;;UAEV;WACN;;WAEA,kBAAkB;EAC3B,OAAO,eAAe,UAAU,2BAA2B,QAAQ;EACnE,WAAW,eAAe,UAAU,2BAA2B,QAAQ;EACvE,MAAM,OAAO,wBAAwB,QAAQ;;EAE7C,OAAO,QAAQ,mBAAmB;EAClC,UAAU;EACV,UAAU;;;;;;;UASK;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;;EAQA;;;;;EAKA;;;;;EAKA,OAAO;;EAEP,UAAU,OAAO;;UAGF;EACf;;EAEA;EACA;EACA;;EAEA;;UAGe;EACf;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;;;EAIA;EACA;;EAEA,QAAQ;;EAER;EACA;IAAU;IAAiB;IAAqB;;;;;;EAKhD;;;;;EAKA;;EAEA,eAAe;;EAEf,UAAU;;EAEV;EACA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;EACA;;UAGe;EACf;;EAEA;EACA;;EAEA;EACA;;UAGe;EACf;EACA;;EAEA;EACA,QAAQ;;EAER,UAAU;;UAGK;EACf,WAAW;EACX,OAAO;EACP,UAAU;;;KAIA"}

package/dist/{types-m2QB86fF.d.ts → types-BekdNwGD.d.ts}

@@ -51,20 +51,6 @@ interface KnowledgeRelation {
   weight?: number;
   metadata?: Record<string, unknown>;
 }
-/** A caller-declared vertex of a labeled relation graph. */
-interface KnowledgeRelationNode {
-  id: KnowledgeId;
-  /** Caller vocabulary, such as `run`, `claim`, `page`, or `model`. */
-  kind: string;
-  label?: string;
-  metadata?: Record<string, unknown>;
-}
-/** A labeled multi-edge graph with one edge per `(sourceId, targetId, predicate)`. */
-interface KnowledgeRelationGraph {
-  /** Declared nodes in declaration order; empty when the graph was built from relations alone. */
-  nodes: KnowledgeRelationNode[];
-  edges: KnowledgeRelation[];
-}
 interface KnowledgeUnit {
   id: KnowledgeId;
   title: string;
@@ -191,8 +177,7 @@ interface KnowledgeWriteParseResult {
 /**
  * The event vocabulary, as a value so the runtime schema is DERIVED from it
  * rather than restated. A restated copy in `schemas.ts` drifted: it omitted
- * `research.iteration`, which is the only event `runVerifiedResearchLoop`
- * produces, so every attempt to store one would have been rejected. Nothing
+ * `research.iteration`, which the research loop produces, so every attempt to store one would have been rejected. Nothing
  * caught it because nothing ever stored an event. Add a type here and the
  * schema accepts it in the same edit.
  */
@@ -228,7 +213,7 @@ interface DeepQuestion {
   /** The round this question was raised in. */
   raisedRound: number;
 }
-/** One live tracked claim exposed by the research-driving API. */
+/** One live tracked claim, with Set fields; `ResearchClaimRecord` is its durable form. */
 interface TrackedClaim {
   id: string;
   /** The claim text as first extracted (kept for prompts/audit). */
@@ -338,5 +323,5 @@ interface KnowledgeRelease {
   metadata?: Record<string, unknown>;
 }
 //#endregion
-export { SourceAnchor as A, KnowledgeUnit as C, ResearchClaimLedger as D, ResearchClaimEvidence as E, SourceRegistry as M, TrackedClaim as N, ResearchClaimRecord as O, KnowledgeSearchResult as S, KnowledgeWriteParseResult as T, KnowledgePolicy as _, KnowledgeBaseCandidate as a, KnowledgeRelationNode as b, KnowledgeEventType as c, KnowledgeGraphNode as d, KnowledgeId as f, KnowledgePageInvalidation as g, KnowledgePage as h, KNOWLEDGE_EVENT_TYPES as i, SourceRecord as j, ResearchSourceVersion as k, KnowledgeGraph as l, KnowledgeLintFinding as m, DeepQuestion as n, KnowledgeClaim as o, KnowledgeIndex as p, DeepQuestionKind as r, KnowledgeEvent as s, ClaimRef as t, KnowledgeGraphEdge as u, KnowledgeRelation as v, KnowledgeWriteBlock as w, KnowledgeRelease as x, KnowledgeRelationGraph as y };
-//# sourceMappingURL=types-m2QB86fF.d.ts.map
+export { SourceRegistry as A, KnowledgeWriteParseResult as C, ResearchSourceVersion as D, ResearchClaimRecord as E, SourceAnchor as O, KnowledgeWriteBlock as S, ResearchClaimLedger as T, KnowledgePolicy as _, KnowledgeBaseCandidate as a, KnowledgeSearchResult as b, KnowledgeEventType as c, KnowledgeGraphNode as d, KnowledgeId as f, KnowledgePageInvalidation as g, KnowledgePage as h, KNOWLEDGE_EVENT_TYPES as i, TrackedClaim as j, SourceRecord as k, KnowledgeGraph as l, KnowledgeLintFinding as m, DeepQuestion as n, KnowledgeClaim as o, KnowledgeIndex as p, DeepQuestionKind as r, KnowledgeEvent as s, ClaimRef as t, KnowledgeGraphEdge as u, KnowledgeRelation as v, ResearchClaimEvidence as w, KnowledgeUnit as x, KnowledgeRelease as y };
+//# sourceMappingURL=types-BekdNwGD.d.ts.map

package/dist/types-BekdNwGD.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-BekdNwGD.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY;UAEK;EACf;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,WAAW;;UAGI;EACf,IAAI;EACJ;EACA;EACA;EACA;EACA;EACA,UAAU;;EAEV;;EAEA;EACA,WAAW;EACX;;UAGe;EACf;EACA,SAAS;;UAGM;EACf;EACA;EACA;;UAGe;EACf,IAAI;EACJ;EACA,MAAM;EACN;EACA;EACA,WAAW;;UAGI;EACf,UAAU;EACV,UAAU;EACV;EACA;EACA,WAAW;;UAGI;EACf,IAAI;EACJ;EACA;EACA,SAAS;EACT,YAAY;EACZ;EACA;EACA,WAAW;EACX;;;;;;;;;;UAWe;EACf;EACA;EACA;EACA;EACA;EACA,WAAW;;UAGI;EACf,IAAI;EACJ;EACA;EACA;EACA,aAAa;EACb;EACA;EACA;;EAEA,QAAQ;;EAER,cAAc;;EAEd,eAAe;;UAGA;EACf,IAAI;EACJ;EACA;EACA;EACA;EACA;EACA;;UAGe;EACf,QAAQ;EACR,QAAQ;EACR;EACA;;UAGe;EACf,OAAO;EACP,OAAO;;UAGQ;EACf;EACA;EACA,SAAS;EACT,OAAO;EACP,OAAO;;UAGQ;EACf,MAAM;;;;;;;EAON;;EAEA;;;;;;;;EAQA;EACA;EACA;EACA;;UAGe;EACf;EAkBA;EACA;EACA;EACA,WAAW;;UAGI;EACf;EACA;EACA;EACA;EACA,WAAW;;UAGI;EACf,IAAI;EACJ,OAAO;EACP;EACA;EACA;EACA;EACA,WAAW;;UAGI;EACf;EACA;;UAGe;EACf,QAAQ;EACR;;;;;;;;;cAUW;KAWD,6BAA6B;UAExB;EACf;EACA,MAAM;EACN;EACA;EACA;EACA,WAAW;;;KAID;;;;;;;;;UAUK;EACf,MAAM;EACN;;EAEA;;EAEA;;EAEA;;EAEA;;;UAIe;EACf;;EAEA;;EAEA,iBAAiB;;EAEjB;;EAEA,aAAa;;;;;;EAMb;EACA;;;;;;;;;UAUe;EACf;EACA;EACA;EACA;EACA;EACA;EACA;;;UAIe;;EAEf,UAAU;;EAEV;;EAEA;;;;;;;;;;;UAYe;;EAEf;EACA;EACA;;EAEA,UAAU;EACV;;EAEA;;EAEA;EACA;;;;;;;;;;UAWe;;EAEf;EACA;;EAEA;;EAEA;;EAEA;;;;;EAKA;;;;;EAKA,eAAe;;EAEf,mBAAmB;EACnB,QAAQ;EACR,WAAW;;UAGI;EACf;EACA;EACA;EACA;EACA;EACA;EACA,WAAW"}

package/dist/viz/index.d.ts

@@ -1,4 +1,4 @@
-import { d as KnowledgeGraphNode, l as KnowledgeGraph, u as KnowledgeGraphEdge } from "../types-m2QB86fF.js";
+import { d as KnowledgeGraphNode, l as KnowledgeGraph, u as KnowledgeGraphEdge } from "../types-BekdNwGD.js";
 //#region src/viz/index.d.ts
 export interface KnowledgeVizNode extends KnowledgeGraphNode {
   degree: number;

package/docs/architecture.md

@@ -8,7 +8,6 @@ It owns the small set of primitives every serious agent knowledge system needs:
 - generated knowledge pages and units
 - claims with source references
 - deterministic indexing, graph construction, search, and lint
-- labeled relation graphs with one edge per `(source, target, predicate)` and neighbor, walk, and reachability queries
 - retrieval/RAG candidate surfaces, gold-target scoring, and eval-loop adapters
 - safe LLM write proposals
 - eval-gated release confidence through `@tangle-network/agent-eval`
@@ -57,15 +56,10 @@ They reach it through `mergeClaimLedger(id, merge)`, which holds the mutation lo
 The combining rule is `mergeClaimLedgers`: support and contradiction edges union, `contested` and `addressed` latch on, `firstSeenRound` moves earlier, and every collection is sorted.
 The merge is commutative, associative, and idempotent, so the bytes on disk depend on the evidence rather than on scheduling.
 Ledgers for two different goals refuse to merge (`ClaimLedgerGoalConflictError`) rather than pooling unrelated evidence into one corroboration count.
-The live driver exposes the published Set-based `TrackedClaim`; the ledger stores a separate `ResearchClaimRecord` with sorted arrays so JSON serialization cannot erase those sets.
-Source verification snapshots the proposal and persists a `ResearchClaimEvidence` observation containing the expected registry id, original URI, and full content hash; that observation cannot affect claim support or completion by itself.
-After the exact submitted bytes are durable, `runVerifiedResearchLoop` passes the resulting `SourceRecord` to `commitSources`.
+`TrackedClaim` keeps its published `Set` fields; the ledger stores a separate `ResearchClaimRecord` with sorted arrays so JSON serialization cannot erase those sets.
+A `ResearchClaimEvidence` observation records the expected registry id, original URI, and full content hash; it cannot affect claim support or completion by itself.
 The ledger materializes only observations whose complete source identity matches a confirmed record, so reusing one URI for different bytes cannot activate the wrong claims and a crash on either side resumes safely.
 Unversioned URI-only ledgers cannot prove which bytes produced their observations; reads and writes fail with `ClaimLedgerMigrationRequiredError` and preserve the original file for an explicit archive-and-reverify migration.
-Before synchronous question generation, the persistent driver records `preparedRounds`; a resume reconstructs and checkpoints any prepared round whose questions were interrupted, and the loop publishes its `research.iteration` event only after that checkpoint succeeds.
-The research loop requires storage readiness and the driver's optional `isComplete()` result before it reports completion.
-An unfinished driver can generate steering with no remaining storage gaps, so passing source requirements does not stop research prematurely.
-Drivers without `isComplete()` use storage readiness alone.
 Without readiness specifications, the loop runs to its round limit and never reports ready.
 
 Every write in this layer goes through `durable-fs` (`writeFileDurable`, `writeJsonDurableWithinRoot`): temp file, fsync, atomic rename, and parent fsync.
@@ -93,25 +87,3 @@ Applications must bind external state through their existing memory branch or ev
 6. Search and graph-lint the knowledge base.
 7. Evaluate candidate KB and retrieval variants with an `agent-eval` improvement loop, then fold the resulting run records into release confidence with `knowledgeReleaseReport`.
 8. Promote only variants that pass downstream gates.
-
-## CLI
-
-The CLI is intentionally fast and local:
-
-```bash
-agent-knowledge init
-agent-knowledge source-add ./source.md
-agent-knowledge sources
-agent-knowledge apply-write-blocks ./proposal.txt
-agent-knowledge index
-agent-knowledge search "query"
-agent-knowledge inspect
-agent-knowledge explain knowledge/concepts/example.md
-agent-knowledge graph
-agent-knowledge lint
-agent-knowledge validate --strict
-agent-knowledge export --format json
-agent-knowledge viz
-```
-
-It does not call an LLM. It operates over markdown and cached JSON indexes so fleet jobs and dev containers can use it cheaply.

package/docs/eval/investment-material-facts.md

@@ -1,5 +1,7 @@
 # Held-out investment-research eval set: material facts + provenance
 
+> Historical record. The investment-thesis set and task were removed in Knowledge 20.0.0; see commit bc2abe0cee1047350a27af37200b94b6801d1f6b for the code.
+
 This is the answer key and the provenance ledger for `tests/eval/investment-thesis-set.ts`.
 
 **What the set measures.** Give a research loop a company + ticker + an as-of

package/docs/results/research-driving.md

@@ -58,7 +58,7 @@ So we need a metric for research **quality**, not hygiene. We use:
 
 ## 2. The held-out exam (the firewall)
 
-[`tests/loops/held-out-exam.ts`](../../tests/loops/held-out-exam.ts). 5 ML topics,
+[`tests/loops/held-out-exam.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/held-out-exam.ts). 5 ML topics,
 4 questions each = **20 deep questions**. Each is a *depth* question by
 construction, comparative, mechanism-level, or contradiction-aware, chosen so a
 single web search for the topic name does **not** surface the answer:
@@ -100,16 +100,16 @@ between arms (if any) would be real depth, not grader slack.
 
 ## 3. The three arms, at equal compute
 
-[`tests/loops/research-driving-ab.test.ts`](../../tests/loops/research-driving-ab.test.ts).
+[`tests/loops/research-driving-ab.test.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/research-driving-ab.test.ts).
 All three arms run the **same** real web worker
-([`createWebResearchWorker`](../../src/web-research-worker.ts), glm-5.2 query-gen
+([`createWebResearchWorker`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/web-research-worker.ts), glm-5.2 query-gen
 → live `/v1/search` → `politeFetch` → `htmlToText`). They differ **only** in the
 driver:
 
 - **(A) single-agent collection**: the worker alone, no driver. It collects.
-- **(B) verify/dedup**: [`createVerifyingResearchDriver`](../../src/web-research-worker.ts):
+- **(B) verify/dedup**: [`createVerifyingResearchDriver`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/web-research-worker.ts):
   a second glm-5.2 pass filters each source for relevance / near-duplicates.
-- **(C) DRIVING**: [`createResearchDrivingDriver`](../../src/research-driving-driver.ts):
+- **(C) DRIVING**: [`createResearchDrivingDriver`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/research-driving-driver.ts):
   the driver extracts each source's claims (glm-5.2), tracks independent-source
   support + contradictions, and folds comparative / mechanism / gap /
   contradiction sub-questions into the worker's next prompt.
@@ -258,8 +258,8 @@ AGENT_KNOWLEDGE_LIVE=1 RQ_PROBE=1 RQ_PROBE_ROUNDS=3 TANGLE_API_KEY=<…> \
 cheaper slice. The exam is held out by construction, no flag shows it to a loop.
 
 **Source:** the exam and grader:
-[`tests/loops/held-out-exam.ts`](../../tests/loops/held-out-exam.ts);
+[`tests/loops/held-out-exam.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/held-out-exam.ts);
 the 3-arm A/B and multi-round probe:
-[`tests/loops/research-driving-ab.test.ts`](../../tests/loops/research-driving-ab.test.ts);
+[`tests/loops/research-driving-ab.test.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/research-driving-ab.test.ts);
 the driving driver under test:
-[`src/research-driving-driver.ts`](../../src/research-driving-driver.ts).
+[`src/research-driving-driver.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/research-driving-driver.ts).

package/docs/verified-research-ab.md

@@ -1,5 +1,7 @@
 # A verifier agent mostly deduplicates: a controlled A/B on two-agent web research, and what its cost buys
 
+> Historical record. The research loop, drivers, web worker, and investment-thesis task this paper measured were removed in Knowledge 20.0.0; code links point to the last commit that contained them.
+
 *Tangle Network · `agent-knowledge`*
 
 ## Abstract
@@ -476,13 +478,13 @@ per-company A/B: [`docs/results/investment-thesis.md`](results/investment-thesis
 ## 10. Reproduce
 
 The loop, the worker, the verifier, the claim-grounding mode, the adaptive driver, the
-driving driver, the held-out exam, the cost instrumentation, and every A/B are all in
-this repository. Each live test gates a cheap one-call glm-5.2 smoke before any
+driving driver, the held-out exam, the cost instrumentation, and every A/B are at commit
+`bc2abe0cee1047350a27af37200b94b6801d1f6b`. Each live test gates a cheap one-call glm-5.2 smoke before any
 multi-topic burn.
 
 ```bash
 git clone https://github.com/tangle-network/agent-knowledge
-cd agent-knowledge && pnpm install
+cd agent-knowledge && git checkout bc2abe0cee1047350a27af37200b94b6801d1f6b && pnpm install
 
 # offline A/B: deterministic, no credentials (a controlled lower bound that
 # exercises the same harness against a planted source pool)
@@ -523,13 +525,13 @@ AGENT_KNOWLEDGE_LIVE=1 RQ_PROBE=1 RQ_PROBE_ROUNDS=3 TANGLE_API_KEY=<…> \
 topic list; the live arms run the loops on each at equal compute and report the paired
 bootstrap and per-arm cost.
 
-**Source:** the loop, [`src/verified-research-loop.ts`](../src/verified-research-loop.ts);
-the live worker + verifier + cost instrumentation, [`src/web-research-worker.ts`](../src/web-research-worker.ts);
-the misattribution check, [`src/claim-grounding.ts`](../src/claim-grounding.ts);
-the adaptive driver, [`src/adaptive-driver.ts`](../src/adaptive-driver.ts);
-the driving driver, [`src/research-driving-driver.ts`](../src/research-driving-driver.ts);
-the held-out exam + $0 grader, [`tests/loops/held-out-exam.ts`](../tests/loops/held-out-exam.ts);
-the A/B harnesses, [`tests/loops/`](../tests/loops/).
+**Source:** the loop, [`src/verified-research-loop.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/verified-research-loop.ts);
+the live worker + verifier + cost instrumentation, [`src/web-research-worker.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/web-research-worker.ts);
+the misattribution check, [`src/claim-grounding.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/claim-grounding.ts);
+the adaptive driver, [`src/adaptive-driver.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/adaptive-driver.ts);
+the driving driver, [`src/research-driving-driver.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/src/research-driving-driver.ts);
+the held-out exam + $0 grader, [`tests/loops/held-out-exam.ts`](https://github.com/tangle-network/agent-knowledge/blob/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/held-out-exam.ts);
+the A/B harnesses, [`tests/loops/`](https://github.com/tangle-network/agent-knowledge/tree/bc2abe0cee1047350a27af37200b94b6801d1f6b/tests/loops/).
 Per-result detail: [`docs/results/cost-quality.md`](results/cost-quality.md),
 [`docs/results/claim-grounding.md`](results/claim-grounding.md),
 [`docs/results/adaptive.md`](results/adaptive.md),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-knowledge",
-  "version": "19.1.5",
+  "version": "20.0.0",
   "description": "Build, search, evaluate, and improve source-backed knowledge bases.",
   "homepage": "https://github.com/tangle-network/agent-knowledge#readme",
   "repository": {
@@ -34,11 +34,6 @@
       "import": "./dist/memory/index.js",
       "default": "./dist/memory/index.js"
     },
-    "./sources": {
-      "types": "./dist/sources/index.d.ts",
-      "import": "./dist/sources/index.js",
-      "default": "./dist/sources/index.js"
-    },
     "./benchmarks": {
       "types": "./dist/benchmarks/index.d.ts",
       "import": "./dist/benchmarks/index.js",
@@ -81,19 +76,18 @@
   "dependencies": {
     "@types/proper-lockfile": "4.1.4",
     "proper-lockfile": "4.1.2",
-    "zod": "4.6.5",
-    "@tangle-network/tcloud": ">=0.8.0 <0.9.0"
+    "zod": "4.6.5"
   },
   "peerDependencies": {
-    "@tangle-network/agent-eval": ">=0.201.0 <0.209.0",
-    "@tangle-network/agent-interface": "^2.16.0"
+    "@tangle-network/agent-eval": ">=0.209.1 <0.210.0",
+    "@tangle-network/agent-interface": "^3.0.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
     "@biomejs/biome": "^2.5.14",
     "@neo4j-labs/agent-memory": "0.5.0",
-    "@tangle-network/agent-eval": "0.208.2",
-    "@tangle-network/agent-interface": "2.16.0",
+    "@tangle-network/agent-eval": "0.209.1",
+    "@tangle-network/agent-interface": "3.0.0",
     "@types/node": "^26.6.2",
     "mem0ai": "3.3.0",
     "oxc-parser": "0.151.0",

package/skills/build-with-agent-knowledge/SKILL.md

@@ -11,17 +11,7 @@ Do not copy signatures from this skill.
 
 ## Choose The Job
 
-| Product need | Package capability |
-|---|---|
-| Start a source-backed Markdown knowledge base | File knowledge base and source registry |
-| Search an existing package knowledge base | File search provider or a product search adapter |
-| Improve knowledge without editing live files | Isolated knowledge candidates |
-| Tune retrieval on labeled questions | Retrieval improvement loop |
-| Diagnose and repair retrieval, sources, pages, and answers together | RAG knowledge improvement loop |
-| Compare memory systems | Memory adapter and experiment APIs |
-| Run retrieval, answer, knowledge, or memory cases | Knowledge benchmark APIs |
-| Let agents research or edit candidates | Runtime knowledge integration |
-
+Pick the API from the installed README's "Choose an API" table.
 Use the narrowest capability that solves the product problem.
 Do not add an agent loop when deterministic ingestion or indexing is enough.
 
@@ -42,9 +32,7 @@ The agent's current answer is not a gold answer.
 
 ## Keep The Boundary Clean
 
-`agent-knowledge` owns source records, indexes, retrieval tests, memory contracts, isolated candidates, and exact promotion.
-It does not own model choice, prompts, browsing, agent scheduling, product authorization, or product storage transactions.
-
+The README's "Package boundaries" section states what the package owns.
 Supply callbacks for research, retrieval, answer generation, and scoring.
 Use `@tangle-network/agent-runtime` when those callbacks should run agents.
 Use existing vector, graph, search, and memory systems through adapters instead of rebuilding their databases here.
@@ -79,7 +67,6 @@ Reject stale promotion rather than replacing newer knowledge.
 
 Report service and measurement failures separately from product failures.
 Keep candidate-generation cases separate from the final decision set.
-Bundled benchmark samples prove adapter wiring only; use complete external datasets for benchmark claims.
 
 ## Completion