@vortex-os/ontos 0.1.0 → 0.2.0

package/README.md

@@ -9,34 +9,49 @@ connects, and acts on recurring situations.
 > Sibling add-ons, one line: **remember** (`memory-extended`) · **perceive**
 > (`computer-use`) · **model** (`ontos`).
 
-## Status — Phase 1 (0.1.0)
+## Status — Phase 1 (0.2.0)
 
 Phase 1 is **text-first**: the ontology is built only from existing markdown
-records (the failure ledger, decision-log, memories, `[[wikilinks]]`), with **no
-screen perception and no background daemon** (those are Phase 2, only if Phase 1
-proves its value). Storage is **sqlite** (better-sqlite3) with recursive-CTE
+records (the failure ledger, decision-log, memories, runbooks, `[[wikilinks]]`),
+with **no screen perception and no background daemon** (those are Phase 2, only if
+Phase 1 proves its value). Storage is **sqlite** (better-sqlite3) with recursive-CTE
 traversal — no graph DB (TypeDB/Neo4j) and no formal OWL/RDF reasoner.
 
-Implemented and verified (typecheck/build/verify 15/15; confirmed on a real
+Implemented and verified (typecheck/build/verify 47/47; confirmed on a real
 instance — e.g. `literal-control-bytes` → 6 occurrences, guard fires):
 
 - **`sqlite/OntosStore`** — schema; idempotent object/relation upsert
   (relId = `sha256(source⏎relation⏎target)`); alias-based identity resolution;
   hop-capped (≤ 3) cycle-guarded recursive-CTE traversal; recurrence count;
-  `clear()` + a transaction wrapper for a true rebuild.
-- **`extract/`** — the deterministic extractor (Phase 1 §4): failure ledger →
+  `clear()` + a transaction wrapper for a true rebuild. Plus the 0.2.0
+  `relation_proposals` table (kept SEPARATE from the trusted graph), additive
+  migration, and `confirmProposal` / `rejectProposal` / `proposalsFor`.
+- **`extract/`** — the deterministic extractor (§4): failure ledger →
   recurring-failure subgraph (`recurs-as` occurrence→class, `covered-by` →rule);
   decision-log → `decision:` objects (+ wikilink candidates); memory → `rule:`
-  objects. LLM enrichment is a documented `TODO`.
-- **`actions/`** — `recurringFailureGuard` (the §5A fast-proof) and `why`
-  (§5B decision archaeology, evidence-first ≤ 3 hops).
-- **`scripts/rebuild-ontos.mjs`** — read-only walk of `data/_failures`,
-  `data/decision-log`, `data/_memory` → extract → true-rebuild the index.
-
-**Deferred** (Phase 1 follow-ups): frontmatter `ontos:` writeback, LLM
-enrichment, confirmation UX, identity embedding-candidates (optional reuse of
-`@vortex-os/memory-extended`'s embedder when present), and the `vortex ontos`
-CLI / session-start trigger wiring.
+  objects; runbooks → `action:` objects (`resolved-by` targets).
+- **`enrich/`** (0.2.0) — agent-mediated LLM enrichment: build an extraction
+  request, validate the agent's proposals (vocab + domain/range), tier them
+  (deterministic HIGH / cross-model MEDIUM / self LOW / disagreed rejected), and
+  store them as PROPOSALS only. A proposal never reaches the trusted graph until
+  human-confirmed.
+- **`writeback`** (0.2.0, §5-bis) — on confirm, persist the relation to the source
+  record's `ontos:` frontmatter block via a format-preserving `parseDocument`
+  round-trip (idempotent; malformed/colliding/ambiguous frontmatter untouched), so
+  confirmed knowledge syncs across machines via git.
+- **`actions/`** — `recurringFailureGuard` (the §5A fast-proof), `why` (§5B
+  decision archaeology, evidence-first ≤ 3 hops), and `proposalHints` (surface
+  unconfirmed links, hedged — actions read the trusted graph only).
+- **`scripts/`** — `rebuild-ontos` (read-only deterministic rebuild from
+  `_failures`/`decision-log`/`_memory`/`runbooks`); `enrich-ontos --emit|--ingest`
+  (the agent I/O wrapper) and `--gc` (reconcile orphans after rename/delete).
+- **CLI** — `vortex ontos check | why <target>` via `@vortex-os/base` (optional;
+  base works without ontos installed).
+
+**Deferred** (later): identity embedding-candidates (optional reuse of
+`@vortex-os/memory-extended`'s embedder when present), broader object coverage
+(Component extraction beyond runbooks), session-start ambient surfacing, and
+Phase 2 (vision / daemon).
 
 Design: the concept and Phase 1 build spec live in the maintainer's VortEX
 instance (Codex-reviewed, 2 rounds).

package/dist/actions/index.d.ts

@@ -1,5 +1,6 @@
 import type { OntosStore } from "../sqlite/index.js";
-import type { WalkStep } from "../types.js";
+import type { RelationType, WalkStep } from "../types.js";
+import type { Trust } from "../enrich/types.js";
 /**
  * §5B — decision archaeology. Walks the reasoning relations (supersedes /
  * contradicts / causes) from an object, returning short, evidence-first chains
@@ -9,6 +10,32 @@ import type { WalkStep } from "../types.js";
  * snippets (the store already carries `evidence` on each relation).
  */
 export declare function why(store: OntosStore, objectId: string, maxHops?: number): WalkStep[];
+/**
+ * A "possible (unverified)" connection touching an object — an LLM proposal that
+ * is NOT in the trusted graph. SEPARATE from `why()`/the guard on purpose: those
+ * read only confirmed relations, so this never silently colours an action. The
+ * agent fetches hints alongside a firm answer and may weave the strongest in,
+ * hedged ("a possible link, not confirmed — treat it as real?").
+ *
+ * Demand-driven usage (the asking heuristic lives in the agent, not here): only
+ * surface a hint when it would change the answer the user is already getting;
+ * skip HIGH/already-corroborated noise; respect a re-ask cooldown via `askedAt`
+ * (and stamp `store.markAsked` when you do ask); on "yes" call
+ * `store.confirmProposal`, on "no" `store.rejectProposal`; a non-answer leaves it
+ * as a hint (safe default). Highest trust first.
+ */
+export interface ProposalHint {
+    readonly relId: string;
+    readonly rel: RelationType;
+    readonly sourceId: string;
+    readonly targetId: string;
+    readonly trust: Trust;
+    readonly confidence: number;
+    readonly evidencePath: string;
+    /** ISO date last surfaced as a question (null = never) — for the agent's cooldown. */
+    readonly askedAt: string | null;
+}
+export declare function proposalHints(store: OntosStore, objectId: string): ProposalHint[];
 export interface GuardHit {
     readonly failureId: string;
     readonly recurrence: number;

package/dist/actions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,QAAQ,EAAE,CAKhF;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,SAAI,GACZ,QAAQ,GAAG,IAAI,CASjB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,QAAQ,EAAE,CAKhF;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,YAAY,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,sFAAsF;IACtF,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,EAAE,CAWjF;AAED,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,UAAU,EACjB,SAAS,EAAE,MAAM,EACjB,SAAS,SAAI,GACZ,QAAQ,GAAG,IAAI,CASjB"}

package/dist/actions/index.js

@@ -12,6 +12,18 @@ export function why(store, objectId, maxHops = 3) {
         rels: ["supersedes", "contradicts", "causes"],
     });
 }
+export function proposalHints(store, objectId) {
+    return store.proposalsFor(objectId).map((p) => ({
+        relId: p.relId,
+        rel: p.rel,
+        sourceId: p.sourceId,
+        targetId: p.targetId,
+        trust: p.trust,
+        confidence: p.confidence,
+        evidencePath: p.evidencePath,
+        askedAt: p.askedAt ?? null,
+    }));
+}
 /**
  * §5A — recurring-failure guard. Given a situation already resolved to a failure
  * object id (the §6 trigger surface does that resolution), report whether it

package/dist/actions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CAAC,KAAiB,EAAE,QAAgB,EAAE,OAAO,GAAG,CAAC;IAClE,OAAO,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE;QAC9B,OAAO;QACP,IAAI,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,CAAC;KAC9C,CAAC,CAAC;AACL,CAAC;AAOD;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAiB,EACjB,SAAiB,EACjB,SAAS,GAAG,CAAC;IAEb,4EAA4E;IAC5E,6EAA6E;IAC7E,6EAA6E;IAC7E,wDAAwD;IACxD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC;IAChG,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACvD,MAAM,UAAU,GAAG,KAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAClD,OAAO,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7E,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CAAC,KAAiB,EAAE,QAAgB,EAAE,OAAO,GAAG,CAAC;IAClE,OAAO,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE;QAC9B,OAAO;QACP,IAAI,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,QAAQ,CAAC;KAC9C,CAAC,CAAC;AACL,CAAC;AA4BD,MAAM,UAAU,aAAa,CAAC,KAAiB,EAAE,QAAgB;IAC/D,OAAO,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC9C,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,GAAG,EAAE,CAAC,CAAC,GAAG;QACV,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,QAAQ,EAAE,CAAC,CAAC,QAAQ;QACpB,KAAK,EAAE,CAAC,CAAC,KAAK;QACd,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,YAAY,EAAE,CAAC,CAAC,YAAY;QAC5B,OAAO,EAAE,CAAC,CAAC,OAAO,IAAI,IAAI;KAC3B,CAAC,CAAC,CAAC;AACN,CAAC;AAOD;;;;;;;;GAQG;AACH,MAAM,UAAU,qBAAqB,CACnC,KAAiB,EACjB,SAAiB,EACjB,SAAS,GAAG,CAAC;IAEb,4EAA4E;IAC5E,6EAA6E;IAC7E,6EAA6E;IAC7E,wDAAwD;IACxD,MAAM,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC;IAChG,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC;IACvD,MAAM,UAAU,GAAG,KAAK,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAClD,OAAO,UAAU,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7E,CAAC"}

package/dist/enrich/domain-range.d.ts

@@ -0,0 +1,25 @@
+/**
+ * §1/§2 controlled vocabulary + domain/range, factored out so BOTH the proposal
+ * validator (id-prefix typing, at propose time) and the store's confirm path
+ * (the objects' STORED types, at promote time) can share one rule set with no
+ * import cycle. Pure; imports only types.
+ */
+import type { ObjectType, RelationType } from "../types.js";
+import type { DomainRange } from "./types.js";
+export declare const OBJECT_TYPES: readonly ObjectType[];
+export declare const RELATION_TYPES: readonly RelationType[];
+/**
+ * §2 domain/range. Empty domain/range = "any type". `Guard` is a subtype of
+ * `action`, so `resolved-by` ranges over `action`.
+ */
+export declare const DOMAIN_RANGE: Readonly<Record<RelationType, DomainRange>>;
+/** Read an object type from a canonical id prefix (`type:rest`). null = untyped/unresolved. */
+export declare function typeFromId(id: string): ObjectType | null;
+/**
+ * True when (srcType, tgtType) violates `rel`'s domain/range. A null type skips
+ * the side it can't determine (propose-time, unresolved ends); the confirm path
+ * passes the objects' STORED types (both non-null) so a wrong-type object cannot
+ * be promoted even though the id prefix conventionally matched.
+ */
+export declare function domainRangeViolated(rel: RelationType, srcType: ObjectType | null, tgtType: ObjectType | null): boolean;
+//# sourceMappingURL=domain-range.d.ts.map

package/dist/enrich/domain-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-range.d.ts","sourceRoot":"","sources":["../../src/enrich/domain-range.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAO7C,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EASjD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,WAAW,CAAC,CASpE,CAAC;AAEF,+FAA+F;AAC/F,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAGxD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,YAAY,EACjB,OAAO,EAAE,UAAU,GAAG,IAAI,EAC1B,OAAO,EAAE,UAAU,GAAG,IAAI,GACzB,OAAO,CAMT"}

package/dist/enrich/domain-range.js

@@ -0,0 +1,60 @@
+/**
+ * §1/§2 controlled vocabulary + domain/range, factored out so BOTH the proposal
+ * validator (id-prefix typing, at propose time) and the store's confirm path
+ * (the objects' STORED types, at promote time) can share one rule set with no
+ * import cycle. Pure; imports only types.
+ */
+export const OBJECT_TYPES = [
+    "component",
+    "problem",
+    "decision",
+    "rule",
+    "action",
+    "person",
+];
+export const RELATION_TYPES = [
+    "causes",
+    "affects",
+    "depends-on",
+    "supersedes",
+    "contradicts",
+    "resolved-by",
+    "covered-by",
+    "recurs-as",
+];
+/**
+ * §2 domain/range. Empty domain/range = "any type". `Guard` is a subtype of
+ * `action`, so `resolved-by` ranges over `action`.
+ */
+export const DOMAIN_RANGE = {
+    "covered-by": { domain: ["problem"], range: ["rule"] },
+    "resolved-by": { domain: ["problem"], range: ["action"] },
+    "recurs-as": { domain: ["problem"], range: ["problem"] },
+    causes: { domain: ["component", "problem", "decision"], range: [] },
+    affects: { domain: [], range: ["component"] },
+    "depends-on": { domain: ["component"], range: ["component"] },
+    supersedes: { domain: ["decision", "rule"], range: ["decision", "rule"] },
+    contradicts: { domain: ["decision", "rule"], range: ["decision", "rule"], symmetric: true },
+};
+/** Read an object type from a canonical id prefix (`type:rest`). null = untyped/unresolved. */
+export function typeFromId(id) {
+    const prefix = id.split(":", 1)[0];
+    return OBJECT_TYPES.includes(prefix) ? prefix : null;
+}
+/**
+ * True when (srcType, tgtType) violates `rel`'s domain/range. A null type skips
+ * the side it can't determine (propose-time, unresolved ends); the confirm path
+ * passes the objects' STORED types (both non-null) so a wrong-type object cannot
+ * be promoted even though the id prefix conventionally matched.
+ */
+export function domainRangeViolated(rel, srcType, tgtType) {
+    const dr = DOMAIN_RANGE[rel];
+    if (srcType && dr.domain.length && !dr.domain.includes(srcType))
+        return true;
+    if (tgtType && dr.range.length && !dr.range.includes(tgtType))
+        return true;
+    if (dr.symmetric && srcType && tgtType && srcType !== tgtType)
+        return true;
+    return false;
+}
+//# sourceMappingURL=domain-range.js.map

package/dist/enrich/domain-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-range.js","sourceRoot":"","sources":["../../src/enrich/domain-range.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,MAAM,CAAC,MAAM,YAAY,GAA0B;IACjD,WAAW;IACX,SAAS;IACT,UAAU;IACV,MAAM;IACN,QAAQ;IACR,QAAQ;CACT,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAA4B;IACrD,QAAQ;IACR,SAAS;IACT,YAAY;IACZ,YAAY;IACZ,aAAa;IACb,aAAa;IACb,YAAY;IACZ,WAAW;CACZ,CAAC;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAgD;IACvE,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE;IACtD,aAAa,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,QAAQ,CAAC,EAAE;IACzD,WAAW,EAAE,EAAE,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,SAAS,CAAC,EAAE;IACxD,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,WAAW,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;IACnE,OAAO,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,WAAW,CAAC,EAAE;IAC7C,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,KAAK,EAAE,CAAC,WAAW,CAAC,EAAE;IAC7D,UAAU,EAAE,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE;IACzE,WAAW,EAAE,EAAE,MAAM,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE;CAC5F,CAAC;AAEF,+FAA+F;AAC/F,MAAM,UAAU,UAAU,CAAC,EAAU;IACnC,MAAM,MAAM,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACnC,OAAQ,YAAkC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAqB,CAAC,CAAC,CAAC,IAAI,CAAC;AAC9F,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,GAAiB,EACjB,OAA0B,EAC1B,OAA0B;IAE1B,MAAM,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,OAAO,IAAI,EAAE,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7E,IAAI,OAAO,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3E,IAAI,EAAE,CAAC,SAAS,IAAI,OAAO,IAAI,OAAO,IAAI,OAAO,KAAK,OAAO;QAAE,OAAO,IAAI,CAAC;IAC3E,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/enrich/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @vortex-os/ontos — agent-mediated LLM enrichment (0.2.0).
+ *
+ * The pure, testable core: build an extraction request, validate the agent's raw
+ * proposals (vocab + domain/range + id resolution), tier them (deterministic /
+ * cross-model / self), and store them as PROPOSALS — never into the trusted
+ * `relations` graph. The agent I/O (printing the request, reading JSON back) is a
+ * thin CLI wrapper layered on top (§6, a later item).
+ */
+import type { OntosStore } from "../sqlite/store.js";
+import type { RecordInput } from "../extract/types.js";
+import type { Resolver } from "./validate.js";
+import type { IngestReport, RawProposal } from "./types.js";
+export * from "./types.js";
+export { OBJECT_TYPES, RELATION_TYPES, DOMAIN_RANGE, typeFromId, validateProposal, buildEnrichmentRequest, requestFor, } from "./validate.js";
+export type { Resolver } from "./validate.js";
+export { tierProposal } from "./tier.js";
+/**
+ * Extraction hash for change detection (§4 step 3): a record needs (re-)enrichment
+ * only when its text changed. Hashes the body — frontmatter-only edits go through
+ * deterministic extraction, not the LLM gap-filler.
+ */
+export declare function extractionHash(record: Pick<RecordInput, "body">): string;
+/**
+ * True when this record's text changed since it was last enriched.
+ *
+ * KNOWN LIMITATION (first cut, by design — proposals live in a disposable index):
+ * a RENAME/DELETE leaves the old path's `enrichment_state` and any proposals it
+ * produced as orphans, and a label resolved only LATER (unresolved at ingest →
+ * aliased afterwards) gets a fresh relId on re-ingest, so the old low-trust row is
+ * not upgraded in place. Both are low-harm (disposable, weakly surfaced) and are
+ * cleaned by a future reconcile/GC pass + `enrich --rebuild`; tracked as a 0.2.0
+ * follow-up, not a blocker (Codex review 2026-06-18).
+ */
+export declare function needsEnrichment(store: OntosStore, record: RecordInput): boolean;
+export interface IngestOptions {
+    /** Resolve a proposed ref to a canonical object id (default: the store's alias table). */
+    readonly resolve?: Resolver;
+    /** Stamp stored proposals with the record's extraction hash (change-detection link). */
+    readonly sourceRecordHash?: string | null;
+    /** ISO timestamp for proposedAt (pass in — the addon never reads the wall clock itself). */
+    readonly proposedAt?: string | null;
+}
+/**
+ * Ingest the agent's raw proposals for a record: validate → tier → store as
+ * proposals. Invalid or verifier-disagreed proposals are dropped into the report,
+ * never stored. The trusted graph and objects table are untouched.
+ */
+export declare function ingestProposals(store: OntosStore, raws: readonly RawProposal[], opts?: IngestOptions): IngestReport;
+//# sourceMappingURL=index.d.ts.map

package/dist/enrich/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/enrich/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAgB,MAAM,YAAY,CAAC;AAE1E,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,sBAAsB,EACtB,UAAU,GACX,MAAM,eAAe,CAAC;AACvB,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG,MAAM,CAExE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAE/E;AAED,MAAM,WAAW,aAAa;IAC5B,0FAA0F;IAC1F,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC;IAC5B,wFAAwF;IACxF,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1C,4FAA4F;IAC5F,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,IAAI,GAAE,aAAkB,GACvB,YAAY,CA0Bd"}

package/dist/enrich/index.js

@@ -0,0 +1,67 @@
+/**
+ * @vortex-os/ontos — agent-mediated LLM enrichment (0.2.0).
+ *
+ * The pure, testable core: build an extraction request, validate the agent's raw
+ * proposals (vocab + domain/range + id resolution), tier them (deterministic /
+ * cross-model / self), and store them as PROPOSALS — never into the trusted
+ * `relations` graph. The agent I/O (printing the request, reading JSON back) is a
+ * thin CLI wrapper layered on top (§6, a later item).
+ */
+import { createHash } from "node:crypto";
+import { validateProposal } from "./validate.js";
+import { tierProposal } from "./tier.js";
+export * from "./types.js";
+export { OBJECT_TYPES, RELATION_TYPES, DOMAIN_RANGE, typeFromId, validateProposal, buildEnrichmentRequest, requestFor, } from "./validate.js";
+export { tierProposal } from "./tier.js";
+/**
+ * Extraction hash for change detection (§4 step 3): a record needs (re-)enrichment
+ * only when its text changed. Hashes the body — frontmatter-only edits go through
+ * deterministic extraction, not the LLM gap-filler.
+ */
+export function extractionHash(record) {
+    return createHash("sha256").update(record.body).digest("hex").slice(0, 16);
+}
+/**
+ * True when this record's text changed since it was last enriched.
+ *
+ * KNOWN LIMITATION (first cut, by design — proposals live in a disposable index):
+ * a RENAME/DELETE leaves the old path's `enrichment_state` and any proposals it
+ * produced as orphans, and a label resolved only LATER (unresolved at ingest →
+ * aliased afterwards) gets a fresh relId on re-ingest, so the old low-trust row is
+ * not upgraded in place. Both are low-harm (disposable, weakly surfaced) and are
+ * cleaned by a future reconcile/GC pass + `enrich --rebuild`; tracked as a 0.2.0
+ * follow-up, not a blocker (Codex review 2026-06-18).
+ */
+export function needsEnrichment(store, record) {
+    return store.getExtractionHash(record.path) !== extractionHash(record);
+}
+/**
+ * Ingest the agent's raw proposals for a record: validate → tier → store as
+ * proposals. Invalid or verifier-disagreed proposals are dropped into the report,
+ * never stored. The trusted graph and objects table are untouched.
+ */
+export function ingestProposals(store, raws, opts = {}) {
+    const resolve = opts.resolve ?? ((ref) => store.resolveAlias(ref));
+    const hasDeterministic = (relId) => store.relationProvenance(relId) === "deterministic";
+    const rejected = [];
+    let accepted = 0;
+    for (const raw of raws) {
+        const v = validateProposal(raw, resolve);
+        if (!v.ok) {
+            rejected.push({ reason: v.reason, raw });
+            continue;
+        }
+        const t = tierProposal(v.value, raw, hasDeterministic, {
+            sourceRecordHash: opts.sourceRecordHash,
+            proposedAt: opts.proposedAt,
+        });
+        if (!t.ok) {
+            rejected.push({ reason: t.reason, raw });
+            continue;
+        }
+        store.upsertProposal(t.value);
+        accepted++;
+    }
+    return { accepted, rejected };
+}
+//# sourceMappingURL=index.js.map

package/dist/enrich/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/enrich/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGzC,cAAc,YAAY,CAAC;AAC3B,OAAO,EACL,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,sBAAsB,EACtB,UAAU,GACX,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAiC;IAC9D,OAAO,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,KAAiB,EAAE,MAAmB;IACpE,OAAO,KAAK,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,cAAc,CAAC,MAAM,CAAC,CAAC;AACzE,CAAC;AAWD;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAiB,EACjB,IAA4B,EAC5B,OAAsB,EAAE;IAExB,MAAM,OAAO,GAAa,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7E,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAW,EAAE,CAClD,KAAK,CAAC,kBAAkB,CAAC,KAAK,CAAC,KAAK,eAAe,CAAC;IACtD,MAAM,QAAQ,GAAiD,EAAE,CAAC;IAClE,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,CAAC,GAAG,gBAAgB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACzC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;YACV,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YACzC,SAAS;QACX,CAAC;QACD,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,KAAK,EAAE,GAAG,EAAE,gBAAgB,EAAE;YACrD,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,UAAU,EAAE,IAAI,CAAC,UAAU;SAC5B,CAAC,CAAC;QACH,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;YACV,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC;YACzC,SAAS;QACX,CAAC;QACD,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC9B,QAAQ,EAAE,CAAC;IACb,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;AAChC,CAAC"}

package/dist/enrich/tier.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Trust tiering — the safety core (2026-06-18 decision, refined this session).
+ * Pure: takes a `hasDeterministic` predicate instead of the store, so the rule is
+ * unit-testable in isolation. The actual cross-model (Codex) / self re-check is
+ * agent-mediated and arrives as a verdict on each RawProposal.
+ *
+ *   deterministic core already has the same triple  -> HIGH (corroborated)
+ *   genuinely new + a DIFFERENT model agreed         -> MEDIUM
+ *   genuinely new + same model self-recheck agreed   -> LOW
+ *   verifier disagreed                               -> rejected
+ *
+ * HIGH is EXACT canonical-triple equality with a deterministic relation — never
+ * "a wikilink/prose suggests it". A HIGH (corroborated) proposal does NOT modify
+ * the deterministic row in `relations`; it is recorded only as a proposal.
+ */
+import type { RawProposal, RelationProposal, ValidatedProposal } from "./types.js";
+export declare function tierProposal(v: ValidatedProposal, raw: Pick<RawProposal, "verifier" | "agreed">, hasDeterministic: (relId: string) => boolean, opts?: {
+    readonly sourceRecordHash?: string | null;
+    readonly proposedAt?: string | null;
+}): {
+    ok: true;
+    value: RelationProposal;
+} | {
+    ok: false;
+    reason: "verifier-disagreed";
+};
+//# sourceMappingURL=tier.d.ts.map

package/dist/enrich/tier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier.d.ts","sourceRoot":"","sources":["../../src/enrich/tier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEnF,wBAAgB,YAAY,CAC1B,CAAC,EAAE,iBAAiB,EACpB,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAC,EAC7C,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,EAC5C,IAAI,CAAC,EAAE;IAAE,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACxF;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,gBAAgB,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,oBAAoB,CAAA;CAAE,CAoBrF"}

package/dist/enrich/tier.js

@@ -0,0 +1,38 @@
+/**
+ * Trust tiering — the safety core (2026-06-18 decision, refined this session).
+ * Pure: takes a `hasDeterministic` predicate instead of the store, so the rule is
+ * unit-testable in isolation. The actual cross-model (Codex) / self re-check is
+ * agent-mediated and arrives as a verdict on each RawProposal.
+ *
+ *   deterministic core already has the same triple  -> HIGH (corroborated)
+ *   genuinely new + a DIFFERENT model agreed         -> MEDIUM
+ *   genuinely new + same model self-recheck agreed   -> LOW
+ *   verifier disagreed                               -> rejected
+ *
+ * HIGH is EXACT canonical-triple equality with a deterministic relation — never
+ * "a wikilink/prose suggests it". A HIGH (corroborated) proposal does NOT modify
+ * the deterministic row in `relations`; it is recorded only as a proposal.
+ */
+import { TRUST_RANK } from "./types.js";
+export function tierProposal(v, raw, hasDeterministic, opts) {
+    const base = {
+        ...v,
+        sourceRecordHash: opts?.sourceRecordHash ?? null,
+        proposedAt: opts?.proposedAt ?? null,
+        confirmed: null,
+    };
+    // A verifier-disagreed proposal is rejected FIRST — even if a deterministic
+    // triple matches. If the relation is genuinely deterministic it is already in the
+    // trusted graph; recording a doubted proposal as "HIGH corroborated" would only
+    // muddy provenance and contradict the "disagreed → rejected" rule (Codex round 2).
+    if (!raw.agreed)
+        return { ok: false, reason: "verifier-disagreed" };
+    if (hasDeterministic(v.relId)) {
+        return { ok: true, value: { ...base, trust: "high", trustRank: TRUST_RANK.high, verifiedBy: "deterministic" } };
+    }
+    if (raw.verifier === "cross-model") {
+        return { ok: true, value: { ...base, trust: "medium", trustRank: TRUST_RANK.medium, verifiedBy: "cross-model" } };
+    }
+    return { ok: true, value: { ...base, trust: "low", trustRank: TRUST_RANK.low, verifiedBy: "self" } };
+}
+//# sourceMappingURL=tier.js.map

package/dist/enrich/tier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier.js","sourceRoot":"","sources":["../../src/enrich/tier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAGxC,MAAM,UAAU,YAAY,CAC1B,CAAoB,EACpB,GAA6C,EAC7C,gBAA4C,EAC5C,IAAyF;IAEzF,MAAM,IAAI,GAAG;QACX,GAAG,CAAC;QACJ,gBAAgB,EAAE,IAAI,EAAE,gBAAgB,IAAI,IAAI;QAChD,UAAU,EAAE,IAAI,EAAE,UAAU,IAAI,IAAI;QACpC,SAAS,EAAE,IAAI;KAChB,CAAC;IAEF,4EAA4E;IAC5E,kFAAkF;IAClF,gFAAgF;IAChF,mFAAmF;IACnF,IAAI,CAAC,GAAG,CAAC,MAAM;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAC;IACpE,IAAI,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;QAC9B,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,EAAE,CAAC;IAClH,CAAC;IACD,IAAI,GAAG,CAAC,QAAQ,KAAK,aAAa,EAAE,CAAC;QACnC,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,EAAE,CAAC;IACpH,CAAC;IACD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;AACvG,CAAC"}

package/dist/enrich/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @vortex-os/ontos — LLM enrichment types (0.2.0, agent-mediated).
+ *
+ * The ontos library has no generative LLM of its own (memory-extended ships only
+ * a local embedder). So enrichment is AGENT-MEDIATED: ontos emits an extraction
+ * REQUEST, the running agent (Claude Code) fulfils it and returns RAW proposals
+ * (already self/cross-checked), and the library validates → tiers → stores them as
+ * PROPOSALS — never into the trusted `relations` graph. See the 0.2.0 design.
+ */
+import type { ObjectType, RelationType } from "../types.js";
+import type { ExtractResult, RecordInput } from "../extract/types.js";
+/** Trust tier of a stored proposal (surfacing rank, NOT graph membership). */
+export type Trust = "high" | "medium" | "low";
+/** How a proposal earned its trust. */
+export type VerifiedBy = "deterministic" | "cross-model" | "self";
+export declare const TRUST_RANK: Readonly<Record<Trust, number>>;
+/** Domain/range constraint for a relation type (object types, by id prefix). */
+export interface DomainRange {
+    /** Allowed source object types; empty = any. */
+    readonly domain: readonly ObjectType[];
+    /** Allowed target object types; empty = any. */
+    readonly range: readonly ObjectType[];
+    /** Symmetric relations (contradicts): both ends must be the same type set. */
+    readonly symmetric?: boolean;
+}
+/**
+ * What ontos hands the agent for one record: the prose to read, what deterministic
+ * extraction already found (so the agent fills GAPS, not duplicates), the controlled
+ * vocabulary + domain/range, and the output contract. Pure data — no I/O.
+ */
+export interface EnrichmentRequest {
+    readonly path: string;
+    readonly category: string;
+    readonly prose: string;
+    /** Already-known objects/relations from deterministic extraction (don't re-propose). */
+    readonly alreadyFound: {
+        readonly objectIds: readonly string[];
+        readonly relations: readonly string[];
+    };
+    readonly vocabulary: {
+        readonly objectTypes: readonly ObjectType[];
+        readonly relationTypes: readonly RelationType[];
+        readonly domainRange: Readonly<Record<RelationType, DomainRange>>;
+    };
+    /** Existing canonical object ids the agent should REUSE rather than invent. */
+    readonly knownObjectIds: readonly string[];
+    readonly rules: readonly string[];
+}
+/**
+ * One relation the agent proposes, with its own cross/self verification verdict.
+ * The agent does extract + check and submits the final verdict per proposal.
+ */
+export interface RawProposal {
+    readonly sourceRef: string;
+    readonly rel: string;
+    readonly targetRef: string;
+    readonly evidencePath: string;
+    readonly evidenceSpan?: string | null;
+    readonly confidence: number;
+    /** Which checker the agent used for this proposal. */
+    readonly verifier: "cross-model" | "self";
+    /** Did the checker agree the relation is real? */
+    readonly agreed: boolean;
+}
+/** A proposal that passed validation (vocab + domain/range + id resolution). */
+export interface ValidatedProposal {
+    readonly relId: string;
+    readonly rel: RelationType;
+    readonly sourceId: string;
+    readonly targetId: string;
+    readonly sourceResolved: boolean;
+    readonly targetResolved: boolean;
+    readonly confidence: number;
+    readonly evidencePath: string;
+    readonly evidenceSpan: string | null;
+}
+/** A fully tiered proposal, ready to store in `relation_proposals`. */
+export interface RelationProposal extends ValidatedProposal {
+    readonly trust: Trust;
+    readonly trustRank: number;
+    readonly verifiedBy: VerifiedBy;
+    readonly sourceRecordHash?: string | null;
+    readonly proposedAt?: string | null;
+    /** ISO date promoted into the trusted graph; null = still a proposal. */
+    readonly confirmed?: string | null;
+    /** ISO date a human rejected it (sticky — not re-surfaced or re-asked). */
+    readonly rejectedAt?: string | null;
+    /** ISO date last surfaced as an in-context question (cooldown for re-asking). */
+    readonly askedAt?: string | null;
+}
+/** Why a raw proposal was dropped (collected into the run report; never stored). */
+export type RejectReason = "unknown-relation" | "domain-range" | "no-evidence" | "bad-confidence" | "bad-verdict" | "verifier-disagreed";
+export interface IngestReport {
+    readonly accepted: number;
+    readonly rejected: readonly {
+        readonly reason: RejectReason;
+        readonly raw: RawProposal;
+    }[];
+}
+export type { ExtractResult, RecordInput };
+//# sourceMappingURL=types.d.ts.map

package/dist/enrich/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/enrich/types.ts"],"names":[],"mappings":"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"}

package/dist/enrich/types.js

@@ -0,0 +1,11 @@
+/**
+ * @vortex-os/ontos — LLM enrichment types (0.2.0, agent-mediated).
+ *
+ * The ontos library has no generative LLM of its own (memory-extended ships only
+ * a local embedder). So enrichment is AGENT-MEDIATED: ontos emits an extraction
+ * REQUEST, the running agent (Claude Code) fulfils it and returns RAW proposals
+ * (already self/cross-checked), and the library validates → tiers → stores them as
+ * PROPOSALS — never into the trusted `relations` graph. See the 0.2.0 design.
+ */
+export const TRUST_RANK = { high: 3, medium: 2, low: 1 };
+//# sourceMappingURL=types.js.map

package/dist/enrich/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/enrich/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAWH,MAAM,CAAC,MAAM,UAAU,GAAoC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC"}

package/dist/enrich/validate.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Validation for agent-mediated enrichment (0.2.0): the controlled vocabulary,
+ * the domain/range table, id-prefix typing, and the request builder. Pure — no
+ * I/O, no store; the caller passes a resolver so this stays testable.
+ */
+import type { ExtractResult, RecordInput } from "../extract/types.js";
+import type { EnrichmentRequest, RawProposal, RejectReason, ValidatedProposal } from "./types.js";
+export { OBJECT_TYPES, RELATION_TYPES, DOMAIN_RANGE, typeFromId } from "./domain-range.js";
+/** A resolver maps a proposed ref to a canonical object id, or null if unknown. */
+export type Resolver = (ref: string) => string | null;
+/**
+ * Validate one raw proposal against the vocabulary, domain/range, and id
+ * resolution order. Returns the validated proposal or a reject reason. Domain/range
+ * is enforced only when BOTH ends resolve to a typed id; an unresolved end keeps its
+ * raw label (sourceResolved/targetResolved=false) and skips the constraint it can't
+ * check (a later resolution/confirmation re-checks it).
+ */
+export declare function validateProposal(raw: RawProposal, resolve: Resolver): {
+    ok: true;
+    value: ValidatedProposal;
+} | {
+    ok: false;
+    reason: RejectReason;
+};
+/**
+ * Build the extraction request for one record (Phase 1 §4 step 3). Pure: the
+ * caller supplies the known object ids the agent should reuse.
+ */
+export declare function buildEnrichmentRequest(record: RecordInput, deterministic: ExtractResult, knownObjectIds?: readonly string[]): EnrichmentRequest;
+/** Convenience: deterministic extraction + the request that fills its gaps. */
+export declare function requestFor(record: RecordInput, knownObjectIds?: readonly string[]): EnrichmentRequest;
+//# sourceMappingURL=validate.d.ts.map

package/dist/enrich/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/enrich/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGlG,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAM3F,mFAAmF;AACnF,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;AAEtD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,QAAQ,GAChB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAkD9E;AAYD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,WAAW,EACnB,aAAa,EAAE,aAAa,EAC5B,cAAc,GAAE,SAAS,MAAM,EAAO,GACrC,iBAAiB,CAiBnB;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,cAAc,GAAE,SAAS,MAAM,EAAO,GAAG,iBAAiB,CAEzG"}