@vortex-os/ontos 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# @vortex-os/ontos
+
+A lightweight **ontology of your operational world** — objects, typed relations,
+and multi-hop traversal — built from your VortEX records, layered on
+`@vortex-os/base`. It is a distinct add-on from `@vortex-os/memory-extended`:
+memory-extended *recalls* what was said; ontos *models* what is and how it
+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)
+
+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
+traversal — no graph DB (TypeDB/Neo4j) and no formal OWL/RDF reasoner.
+
+Implemented and verified (typecheck/build/verify 15/15; 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 →
+  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.
+
+Design: the concept and Phase 1 build spec live in the maintainer's VortEX
+instance (Codex-reviewed, 2 rounds).
+
+## Develop
+
+```
+npm run typecheck --workspace=@vortex-os/ontos
+npm run build     --workspace=@vortex-os/ontos
+npm run verify    --workspace=@vortex-os/ontos
+```

package/dist/actions/index.d.ts

@@ -0,0 +1,26 @@
+import type { OntosStore } from "../sqlite/index.js";
+import type { WalkStep } from "../types.js";
+/**
+ * §5B — decision archaeology. Walks the reasoning relations (supersedes /
+ * contradicts / causes) from an object, returning short, evidence-first chains
+ * capped at ≤ 3 hops (cycle-guarded by the store).
+ *
+ * TODO(phase1): shape the raw walk into chains with the backing evidence
+ * snippets (the store already carries `evidence` on each relation).
+ */
+export declare function why(store: OntosStore, objectId: string, maxHops?: number): WalkStep[];
+export interface GuardHit {
+    readonly failureId: string;
+    readonly recurrence: number;
+}
+/**
+ * §5A — recurring-failure guard. Given a situation already resolved to a failure
+ * object id (the §6 trigger surface does that resolution), report whether it
+ * recurs at/over the threshold, so the caller can surface the covering rule /
+ * guard.
+ *
+ * TODO(phase1): join `covered-by` (→Rule) and `resolved-by` (→Action/Guard) to
+ * return the remedy alongside the recurrence signal.
+ */
+export declare function recurringFailureGuard(store: OntosStore, failureId: string, threshold?: number): GuardHit | null;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

package/dist/actions/index.js

@@ -0,0 +1,34 @@
+/**
+ * §5B — decision archaeology. Walks the reasoning relations (supersedes /
+ * contradicts / causes) from an object, returning short, evidence-first chains
+ * capped at ≤ 3 hops (cycle-guarded by the store).
+ *
+ * TODO(phase1): shape the raw walk into chains with the backing evidence
+ * snippets (the store already carries `evidence` on each relation).
+ */
+export function why(store, objectId, maxHops = 3) {
+    return store.traverse(objectId, {
+        maxHops,
+        rels: ["supersedes", "contradicts", "causes"],
+    });
+}
+/**
+ * §5A — recurring-failure guard. Given a situation already resolved to a failure
+ * object id (the §6 trigger surface does that resolution), report whether it
+ * recurs at/over the threshold, so the caller can surface the covering rule /
+ * guard.
+ *
+ * TODO(phase1): join `covered-by` (→Rule) and `resolved-by` (→Action/Guard) to
+ * return the remedy alongside the recurrence signal.
+ */
+export function recurringFailureGuard(store, failureId, threshold = 2) {
+    // Recurrence is counted on the canonical CLASS id. Resolve an occurrence to
+    // its class STRUCTURALLY — follow its recurs-as edge — rather than by string
+    // surgery on "@" (a recurrence_key could itself contain "@"). A class id has
+    // no outgoing recurs-as edge, so it resolves to itself.
+    const viaEdge = store.neighbors(failureId, ["recurs-as"]).find((r) => r.sourceId === failureId);
+    const classId = viaEdge ? viaEdge.targetId : failureId;
+    const recurrence = store.recurrenceCount(classId);
+    return recurrence >= threshold ? { failureId: classId, recurrence } : null;
+}
+//# sourceMappingURL=index.js.map

package/dist/actions/index.js.map

@@ -0,0 +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"}

package/dist/extract/deterministic.d.ts

@@ -0,0 +1,9 @@
+import type { ExtractResult, RecordInput } from "./types.js";
+/**
+ * Deterministic extraction (Phase 1 §4 step 2) — the fast-proof core, no LLM.
+ * Dispatches by record category. Confidently extracts the failure-recurrence +
+ * coverage subgraph and the object set; supersedes/causes chains arrive as
+ * wikilink candidates until an `ontos:` block or LLM enrichment types them.
+ */
+export declare function extractDeterministic(record: RecordInput): ExtractResult;
+//# sourceMappingURL=deterministic.d.ts.map

package/dist/extract/deterministic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deterministic.d.ts","sourceRoot":"","sources":["../../src/extract/deterministic.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAiB,WAAW,EAAE,MAAM,YAAY,CAAC;AAkG5E;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAWvE"}

package/dist/extract/deterministic.js

@@ -0,0 +1,110 @@
+import { makeRelId } from "../sqlite/store.js";
+const WIKILINK = /\[\[([^\]]+)\]\]/g;
+function basenameSlug(path) {
+    const base = path.replace(/\\/g, "/").split("/").pop() ?? path;
+    return base.replace(/\.md$/i, "");
+}
+function str(v) {
+    return typeof v === "string" && v.length > 0 ? v : null;
+}
+function rel(sourceId, r, targetId, evidence) {
+    return {
+        relId: makeRelId(sourceId, r, targetId),
+        rel: r,
+        sourceId,
+        targetId,
+        provenance: "deterministic",
+        confidence: 1,
+        confirmed: null,
+        evidence,
+    };
+}
+function wikilinks(sourceId, body, evidence) {
+    const out = [];
+    for (const m of body.matchAll(WIKILINK)) {
+        const parts = (m[1] ?? "").split("|");
+        const targetRef = (parts[0] ?? "").trim();
+        if (targetRef)
+            out.push({ sourceId, targetRef, evidence });
+    }
+    return out;
+}
+function empty() {
+    return { objects: [], relations: [], links: [] };
+}
+/**
+ * Failure ledger -> the recurring-failure subgraph (powers the §5A guard,
+ * fully deterministic). One canonical `problem:failure:<key>` class object;
+ * each occurrence file becomes its own object with a `recurs-as` edge to the
+ * class (so the store's recurrence count = number of occurrences). The optional
+ * `rule` field becomes a `covered-by` edge to a `rule:<slug>` object.
+ */
+function fromFailure(record) {
+    const key = str(record.frontmatter["recurrence_key"]);
+    if (!key)
+        return empty();
+    const classId = `problem:failure:${key}`;
+    // Occurrence id uses the file basename. The extracted categories (_failures,
+    // decision-log, _memory) are FLAT directories, so basenames are unique there;
+    // nested categories (worklog) are not extracted. If a category ever nests,
+    // switch this to a full-relative-path discriminator.
+    const occId = `${classId}@${basenameSlug(record.path)}`;
+    const objects = [
+        { id: classId, type: "problem", subtype: "failure", label: key, source: null },
+        { id: occId, type: "problem", subtype: "failure", label: key, source: record.path },
+    ];
+    const relations = [rel(occId, "recurs-as", classId, record.path)];
+    const ruleSlug = str(record.frontmatter["rule"]);
+    if (ruleSlug) {
+        objects.push({ id: `rule:${ruleSlug}`, type: "rule", label: ruleSlug, source: null });
+        relations.push(rel(classId, "covered-by", `rule:${ruleSlug}`, record.path));
+    }
+    return { objects, relations, links: [] };
+}
+/**
+ * Decision log -> a `decision:<slug>` object (label = the H1 title). Typed
+ * relations like `supersedes` are not structured in the records yet, so they
+ * surface as wikilink candidates for human typing (§4).
+ */
+function fromDecision(record) {
+    const slug = basenameSlug(record.path);
+    const id = `decision:${slug}`;
+    const title = (record.body.match(/^#\s+(.+)$/m)?.[1] ?? slug).trim();
+    return {
+        objects: [{ id, type: "decision", label: title, source: record.path }],
+        relations: [],
+        links: wikilinks(id, record.body, record.path),
+    };
+}
+/** Memory -> a `rule:<slug>` object (label = frontmatter `name`); body wikilinks as candidates. */
+function fromMemory(record) {
+    const slug = basenameSlug(record.path);
+    if (slug === "_INDEX" || slug === "MEMORY")
+        return empty();
+    const id = `rule:${slug}`;
+    const label = str(record.frontmatter["name"]) ?? slug;
+    return {
+        objects: [{ id, type: "rule", label, source: record.path }],
+        relations: [],
+        links: wikilinks(id, record.body, record.path),
+    };
+}
+/**
+ * Deterministic extraction (Phase 1 §4 step 2) — the fast-proof core, no LLM.
+ * Dispatches by record category. Confidently extracts the failure-recurrence +
+ * coverage subgraph and the object set; supersedes/causes chains arrive as
+ * wikilink candidates until an `ontos:` block or LLM enrichment types them.
+ */
+export function extractDeterministic(record) {
+    switch (record.category) {
+        case "failure":
+            return fromFailure(record);
+        case "decision":
+            return fromDecision(record);
+        case "memory":
+            return fromMemory(record);
+        default:
+            return empty();
+    }
+}
+//# sourceMappingURL=deterministic.js.map

package/dist/extract/deterministic.js.map

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

package/dist/extract/index.d.ts

@@ -0,0 +1,12 @@
+export type { RecordCategory, RecordInput, LinkCandidate, ExtractResult } from "./types.js";
+export { extractDeterministic } from "./deterministic.js";
+import type { ExtractResult, RecordInput } from "./types.js";
+/**
+ * LLM enrichment (Phase 1 §4 step 3) — runs ONLY on changed, weakly-structured
+ * files after deterministic extraction shows gaps, proposing typed relations
+ * with confidence + evidence (never auto-confirmed).
+ *
+ * TODO(phase1): implement against the host LLM. The skeleton is a pass-through.
+ */
+export declare function enrichWithLlm(_record: RecordInput, deterministic: ExtractResult): ExtractResult;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/extract/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,GAAG,aAAa,CAE/F"}

package/dist/extract/index.js

@@ -0,0 +1,12 @@
+export { extractDeterministic } from "./deterministic.js";
+/**
+ * LLM enrichment (Phase 1 §4 step 3) — runs ONLY on changed, weakly-structured
+ * files after deterministic extraction shows gaps, proposing typed relations
+ * with confidence + evidence (never auto-confirmed).
+ *
+ * TODO(phase1): implement against the host LLM. The skeleton is a pass-through.
+ */
+export function enrichWithLlm(_record, deterministic) {
+    return deterministic;
+}
+//# sourceMappingURL=index.js.map

package/dist/extract/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/extract/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAI1D;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,OAAoB,EAAE,aAA4B;IAC9E,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/dist/extract/types.d.ts

@@ -0,0 +1,29 @@
+import type { OntObject, OntRelation } from "../types.js";
+/** Which record family a file came from (the rebuild walk knows this from the dir). */
+export type RecordCategory = "failure" | "decision" | "memory" | "worklog" | "handoff" | "other";
+/** A parsed VortEX markdown record, the input to extraction. */
+export interface RecordInput {
+    readonly path: string;
+    readonly category: RecordCategory;
+    readonly frontmatter: Readonly<Record<string, unknown>>;
+    readonly body: string;
+}
+/**
+ * An untyped `[[wikilink]]` seed (§4). NOT stored as a typed relation — it is a
+ * candidate connection that still needs a human to *type* it (supersedes? causes?)
+ * and confirm. Kept separate from `relations` on purpose.
+ */
+export interface LinkCandidate {
+    readonly sourceId: string;
+    /** The wikilink target text (a slug/title), `[[target|alias]]` reduced to `target`. */
+    readonly targetRef: string;
+    readonly evidence: string;
+}
+export interface ExtractResult {
+    readonly objects: OntObject[];
+    /** Explicit, deterministic typed relations (recurrence_key, the `rule` field, an `ontos:` block). */
+    readonly relations: OntRelation[];
+    /** Untyped wikilink seeds — for human typing + confirmation, never auto-stored. */
+    readonly links: LinkCandidate[];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/extract/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1D,uFAAuF;AACvF,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAEjG,gEAAgE;AAChE,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,uFAAuF;IACvF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC;IAC9B,qGAAqG;IACrG,QAAQ,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;IAClC,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC;CACjC"}

package/dist/extract/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/extract/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/extract/types.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * as sqlite from "./sqlite/index.js";
+export * as extract from "./extract/index.js";
+export * as actions from "./actions/index.js";
+export type * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,mBAAmB,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * as sqlite from "./sqlite/index.js";
+export * as extract from "./extract/index.js";
+export * as actions from "./actions/index.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,oBAAoB,CAAC"}

package/dist/internal/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export interface FrontmatterDoc<T> {
+    readonly frontmatter: T;
+    readonly body: string;
+}
+export declare function parseFrontmatter<T = Record<string, unknown>>(source: string): FrontmatterDoc<T>;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/internal/frontmatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.d.ts","sourceRoot":"","sources":["../../src/internal/frontmatter.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,CAAC,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,CAe/F"}

package/dist/internal/frontmatter.js

@@ -0,0 +1,30 @@
+import { parse as parseYaml } from "yaml";
+/**
+ * Inlined YAML-frontmatter parser — mirrors memory-extended's own inlined copy.
+ *
+ * ontos ships as a public add-on, so it cannot import the internal, unpublished
+ * `@vortex-os/core` `parseFrontmatter`. The single helper needed is inlined here
+ * (only `yaml` is an external dependency). BOM-safe; returns empty frontmatter +
+ * the source unchanged when no fence is present; tolerates a malformed fence by
+ * treating it as no frontmatter.
+ */
+const FENCE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+const BOM = "";
+export function parseFrontmatter(source) {
+    const cleaned = source.startsWith(BOM) ? source.slice(1) : source;
+    const match = cleaned.match(FENCE);
+    if (!match) {
+        return { frontmatter: {}, body: cleaned };
+    }
+    const yaml = match[1] ?? "";
+    const body = cleaned.slice(match[0].length);
+    let parsed;
+    try {
+        parsed = (parseYaml(yaml) ?? {});
+    }
+    catch {
+        parsed = {};
+    }
+    return { frontmatter: parsed, body };
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/internal/frontmatter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontmatter.js","sourceRoot":"","sources":["../../src/internal/frontmatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,MAAM,CAAC;AAE1C;;;;;;;;GAQG;AACH,MAAM,KAAK,GAAG,mCAAmC,CAAC;AAClD,MAAM,GAAG,GAAG,GAAG,CAAC;AAOhB,MAAM,UAAU,gBAAgB,CAA8B,MAAc;IAC1E,MAAM,OAAO,GAAG,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAClE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACnC,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,EAAE,WAAW,EAAE,EAAO,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IACjD,CAAC;IACD,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC5B,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC5C,IAAI,MAAS,CAAC;IACd,IAAI,CAAC;QACH,MAAM,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,CAAM,CAAC;IACxC,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,GAAG,EAAO,CAAC;IACnB,CAAC;IACD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACvC,CAAC"}

package/dist/sqlite/index.d.ts

@@ -0,0 +1,4 @@
+export { OntosStore, makeRelId } from "./store.js";
+export type { TraverseOptions } from "./store.js";
+export { SCHEMA } from "./schema.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sqlite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACnD,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/sqlite/index.js

@@ -0,0 +1,3 @@
+export { OntosStore, makeRelId } from "./store.js";
+export { SCHEMA } from "./schema.js";
+//# sourceMappingURL=index.js.map

package/dist/sqlite/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/sqlite/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/sqlite/schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * SQLite schema for the ontos derived index.
+ *
+ * The markdown frontmatter `ontos:` block is the source of truth; this index is
+ * a regenerable derivative (delete the .sqlite file and re-run `rebuild-ontos`).
+ * Multi-hop traversal is a recursive CTE over `relations` — no graph DB
+ * (TypeDB/Neo4j) is needed at Phase 1 scale (see the build spec, storage section).
+ */
+export declare const SCHEMA = "\nCREATE TABLE IF NOT EXISTS objects (\n  id TEXT PRIMARY KEY,\n  type TEXT NOT NULL,\n  subtype TEXT,\n  label TEXT NOT NULL,\n  source TEXT\n);\nCREATE INDEX IF NOT EXISTS idx_objects_type ON objects(type);\n\nCREATE TABLE IF NOT EXISTS relations (\n  rel_id TEXT PRIMARY KEY,\n  rel TEXT NOT NULL,\n  source_id TEXT NOT NULL,\n  target_id TEXT NOT NULL,\n  provenance TEXT NOT NULL,\n  confidence REAL NOT NULL DEFAULT 1.0,\n  confirmed TEXT,\n  evidence TEXT,\n  FOREIGN KEY (source_id) REFERENCES objects(id) ON DELETE CASCADE,\n  FOREIGN KEY (target_id) REFERENCES objects(id) ON DELETE CASCADE\n);\nCREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_id, rel);\nCREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_id, rel);\n\nCREATE TABLE IF NOT EXISTS aliases (\n  alias TEXT PRIMARY KEY,\n  canonical_id TEXT NOT NULL,\n  FOREIGN KEY (canonical_id) REFERENCES objects(id) ON DELETE CASCADE\n);\n";
+//# sourceMappingURL=schema.d.ts.map

package/dist/sqlite/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,86BA8BlB,CAAC"}

package/dist/sqlite/schema.js

@@ -0,0 +1,40 @@
+/**
+ * SQLite schema for the ontos derived index.
+ *
+ * The markdown frontmatter `ontos:` block is the source of truth; this index is
+ * a regenerable derivative (delete the .sqlite file and re-run `rebuild-ontos`).
+ * Multi-hop traversal is a recursive CTE over `relations` — no graph DB
+ * (TypeDB/Neo4j) is needed at Phase 1 scale (see the build spec, storage section).
+ */
+export const SCHEMA = `
+CREATE TABLE IF NOT EXISTS objects (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  subtype TEXT,
+  label TEXT NOT NULL,
+  source TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_objects_type ON objects(type);
+
+CREATE TABLE IF NOT EXISTS relations (
+  rel_id TEXT PRIMARY KEY,
+  rel TEXT NOT NULL,
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  provenance TEXT NOT NULL,
+  confidence REAL NOT NULL DEFAULT 1.0,
+  confirmed TEXT,
+  evidence TEXT,
+  FOREIGN KEY (source_id) REFERENCES objects(id) ON DELETE CASCADE,
+  FOREIGN KEY (target_id) REFERENCES objects(id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_id, rel);
+CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_id, rel);
+
+CREATE TABLE IF NOT EXISTS aliases (
+  alias TEXT PRIMARY KEY,
+  canonical_id TEXT NOT NULL,
+  FOREIGN KEY (canonical_id) REFERENCES objects(id) ON DELETE CASCADE
+);
+`;
+//# sourceMappingURL=schema.js.map

package/dist/sqlite/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BrB,CAAC"}

package/dist/sqlite/store.d.ts

@@ -0,0 +1,51 @@
+import type { OntObject, OntRelation, RelationType, WalkStep } from "../types.js";
+/**
+ * §5-bis relation-id recipe. Stable over the (source, relation, target) triple,
+ * so re-accepting the same relation is idempotent (never duplicates).
+ */
+export declare function makeRelId(sourceId: string, rel: RelationType, targetId: string): string;
+export interface TraverseOptions {
+    /** Hop limit, capped at 3 (§5B). */
+    readonly maxHops?: number;
+    /** Restrict to these edge types (empty = all). */
+    readonly rels?: readonly RelationType[];
+}
+/**
+ * SQLite-backed ontos index. Markdown `ontos:` frontmatter is the source of
+ * truth; this is a regenerable derived index. Sync API (better-sqlite3); call
+ * `close()` to release the file lock (matters on Windows).
+ */
+export declare class OntosStore {
+    readonly dbPath: string;
+    private db;
+    constructor(dbPath: string);
+    close(): void;
+    /** Run a function inside one transaction (bulk upserts during a rebuild). */
+    transaction(fn: () => void): void;
+    /**
+     * Empty all tables so a walk-and-upsert becomes a TRUE rebuild: stale objects
+     * and relations from deleted/renamed records, or from a changed recurrence_key
+     * / removed rule, do not linger (which would skew recurrenceCount). Call before
+     * re-populating from a full record walk.
+     */
+    clear(): void;
+    upsertObject(obj: OntObject): void;
+    /** Idempotent on relId (§5-bis): re-accepting the same relation updates, never duplicates. */
+    upsertRelation(rel: OntRelation): void;
+    addAlias(alias: string, canonicalId: string): void;
+    /** §3 identity: resolve a name to a canonical object id (a real object id wins, then an alias). */
+    resolveAlias(name: string): string | null;
+    getObject(id: string): OntObject | null;
+    /** Outgoing relations from an object, optionally filtered by relation type. */
+    neighbors(id: string, rels?: readonly RelationType[]): OntRelation[];
+    /**
+     * Multi-hop walk via recursive CTE — capped at maxHops (default 3, §5B) and
+     * cycle-guarded: a node never re-enters its own path. The path is delimited
+     * with ">" so the membership check is token-exact (not a loose substring).
+     * No graph DB is needed for this scale.
+     */
+    traverse(startId: string, opts?: TraverseOptions): WalkStep[];
+    /** §5A helper: how many failures recur as (share a pattern with) this one. */
+    recurrenceCount(problemId: string): number;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/sqlite/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/sqlite/store.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAElF;;;GAGG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKvF;AAED,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CACzC;AA0BD;;;;GAIG;AACH,qBAAa,UAAU;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,CAAoB;gBAElB,MAAM,EAAE,MAAM;IAS1B,KAAK,IAAI,IAAI;IAIb,6EAA6E;IAC7E,WAAW,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjC;;;;;OAKG;IACH,KAAK,IAAI,IAAI;IAIb,YAAY,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI;IAkBlC,8FAA8F;IAC9F,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAqBtC,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IASlD,mGAAmG;IACnG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAWzC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAgBvC,+EAA+E;IAC/E,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,YAAY,EAAE,GAAG,WAAW,EAAE;IAapE;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,QAAQ,EAAE;IAyBjE,8EAA8E;IAC9E,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAQ3C"}

package/dist/sqlite/store.js

@@ -0,0 +1,169 @@
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import Database from "better-sqlite3";
+import { SCHEMA } from "./schema.js";
+/**
+ * §5-bis relation-id recipe. Stable over the (source, relation, target) triple,
+ * so re-accepting the same relation is idempotent (never duplicates).
+ */
+export function makeRelId(sourceId, rel, targetId) {
+    // Newline separates the triple in the preimage: ids derive from filenames /
+    // frontmatter keys and never contain a newline, so distinct triples cannot
+    // collide on the preimage (a "|"-separated preimage could, since ids may hold "|").
+    return createHash("sha256").update(`${sourceId}\n${rel}\n${targetId}`).digest("hex").slice(0, 16);
+}
+function rowToRelation(r) {
+    return {
+        relId: r.rel_id,
+        rel: r.rel,
+        sourceId: r.source_id,
+        targetId: r.target_id,
+        provenance: r.provenance,
+        confidence: r.confidence,
+        confirmed: r.confirmed,
+        evidence: r.evidence,
+    };
+}
+/**
+ * SQLite-backed ontos index. Markdown `ontos:` frontmatter is the source of
+ * truth; this is a regenerable derived index. Sync API (better-sqlite3); call
+ * `close()` to release the file lock (matters on Windows).
+ */
+export class OntosStore {
+    dbPath;
+    db;
+    constructor(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        this.dbPath = dbPath;
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.db.exec(SCHEMA);
+    }
+    close() {
+        this.db.close();
+    }
+    /** Run a function inside one transaction (bulk upserts during a rebuild). */
+    transaction(fn) {
+        this.db.transaction(fn)();
+    }
+    /**
+     * Empty all tables so a walk-and-upsert becomes a TRUE rebuild: stale objects
+     * and relations from deleted/renamed records, or from a changed recurrence_key
+     * / removed rule, do not linger (which would skew recurrenceCount). Call before
+     * re-populating from a full record walk.
+     */
+    clear() {
+        this.db.exec("DELETE FROM relations; DELETE FROM aliases; DELETE FROM objects;");
+    }
+    upsertObject(obj) {
+        this.db
+            .prepare(`INSERT INTO objects (id, type, subtype, label, source)
+         VALUES (@id, @type, @subtype, @label, @source)
+         ON CONFLICT(id) DO UPDATE SET
+           type = excluded.type, subtype = excluded.subtype,
+           label = excluded.label, source = excluded.source`)
+            .run({
+            id: obj.id,
+            type: obj.type,
+            subtype: obj.subtype ?? null,
+            label: obj.label,
+            source: obj.source ?? null,
+        });
+    }
+    /** Idempotent on relId (§5-bis): re-accepting the same relation updates, never duplicates. */
+    upsertRelation(rel) {
+        this.db
+            .prepare(`INSERT INTO relations (rel_id, rel, source_id, target_id, provenance, confidence, confirmed, evidence)
+         VALUES (@relId, @rel, @sourceId, @targetId, @provenance, @confidence, @confirmed, @evidence)
+         ON CONFLICT(rel_id) DO UPDATE SET
+           provenance = excluded.provenance, confidence = excluded.confidence,
+           confirmed = excluded.confirmed, evidence = excluded.evidence`)
+            .run({
+            relId: rel.relId,
+            rel: rel.rel,
+            sourceId: rel.sourceId,
+            targetId: rel.targetId,
+            provenance: rel.provenance,
+            confidence: rel.confidence,
+            confirmed: rel.confirmed ?? null,
+            evidence: rel.evidence ?? null,
+        });
+    }
+    addAlias(alias, canonicalId) {
+        this.db
+            .prepare(`INSERT INTO aliases (alias, canonical_id) VALUES (?, ?)
+         ON CONFLICT(alias) DO UPDATE SET canonical_id = excluded.canonical_id`)
+            .run(alias, canonicalId);
+    }
+    /** §3 identity: resolve a name to a canonical object id (a real object id wins, then an alias). */
+    resolveAlias(name) {
+        const direct = this.db.prepare(`SELECT id FROM objects WHERE id = ?`).get(name);
+        if (direct)
+            return direct.id;
+        const row = this.db.prepare(`SELECT canonical_id FROM aliases WHERE alias = ?`).get(name);
+        return row ? row.canonical_id : null;
+    }
+    getObject(id) {
+        const row = this.db
+            .prepare(`SELECT id, type, subtype, label, source FROM objects WHERE id = ?`)
+            .get(id);
+        if (!row)
+            return null;
+        return {
+            id: row.id,
+            type: row.type,
+            subtype: row.subtype ?? null,
+            label: row.label,
+            source: row.source,
+        };
+    }
+    /** Outgoing relations from an object, optionally filtered by relation type. */
+    neighbors(id, rels) {
+        const rows = (rels && rels.length
+            ? this.db
+                .prepare(`SELECT * FROM relations WHERE source_id = ? AND rel IN (${rels.map(() => "?").join(",")})`)
+                .all(id, ...rels)
+            : this.db.prepare(`SELECT * FROM relations WHERE source_id = ?`).all(id));
+        return rows.map(rowToRelation);
+    }
+    /**
+     * Multi-hop walk via recursive CTE — capped at maxHops (default 3, §5B) and
+     * cycle-guarded: a node never re-enters its own path. The path is delimited
+     * with ">" so the membership check is token-exact (not a loose substring).
+     * No graph DB is needed for this scale.
+     */
+    traverse(startId, opts = {}) {
+        const maxHops = Math.min(opts.maxHops ?? 3, 3);
+        const rels = opts.rels ?? [];
+        const relFilter = rels.length ? `AND r.rel IN (${rels.map(() => "?").join(",")})` : "";
+        // Path tokens are newline-delimited: ids never contain a newline, so the
+        // membership check is exact (a ">"-delimiter could false-match an id that
+        // legitimately contains ">").
+        const sql = `
+      WITH RECURSIVE walk(node, depth, path) AS (
+        SELECT ?, 0, char(10) || ? || char(10)
+        UNION ALL
+        SELECT r.target_id, w.depth + 1, w.path || r.target_id || char(10)
+        FROM relations r JOIN walk w ON r.source_id = w.node
+        WHERE w.depth < ? AND instr(w.path, char(10) || r.target_id || char(10)) = 0 ${relFilter}
+      )
+      SELECT node, depth, path FROM walk WHERE depth > 0 ORDER BY depth`;
+        const params = [startId, startId, maxHops, ...rels];
+        const rows = this.db.prepare(sql).all(...params);
+        return rows.map((r) => ({
+            nodeId: r.node,
+            depth: r.depth,
+            path: r.path.split("\n").filter(Boolean),
+        }));
+    }
+    /** §5A helper: how many failures recur as (share a pattern with) this one. */
+    recurrenceCount(problemId) {
+        const row = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM relations WHERE rel = 'recurs-as' AND (source_id = ? OR target_id = ?)`)
+            .get(problemId, problemId);
+        return row.n;
+    }
+}
+//# sourceMappingURL=store.js.map

package/dist/sqlite/store.js.map

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

package/dist/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @vortex-os/ontos — core types (Phase 1, text-first).
+ *
+ * Six object types, eight relation types. Object identity ("same-as") is handled
+ * by the alias layer (see the sqlite store), NOT as a graph relation — keeping
+ * dedup separate from `recurs-as` (pattern recurrence). See the maintainer's
+ * instance Phase 1 build spec for the full rationale.
+ */
+export type ComponentKind = "host" | "service" | "module" | "repo";
+export type ProblemKind = "incident" | "failure";
+/** §1 — the six object types. `action` includes executable/checkable Guards. */
+export type ObjectType = "component" | "problem" | "decision" | "rule" | "action" | "person";
+export interface OntObject {
+    /** Canonical id, e.g. "component:vortex-os/base" or "problem:failure:dist-trap". */
+    readonly id: string;
+    readonly type: ObjectType;
+    /** Component/Problem subtype, when applicable. */
+    readonly subtype?: ComponentKind | ProblemKind | null;
+    /** Human-readable label. */
+    readonly label: string;
+    /** Record path this object was extracted from (provenance). */
+    readonly source?: string | null;
+}
+/** §2 — the eight relation types (standard-friendly names). */
+export type RelationType = "causes" | "affects" | "depends-on" | "supersedes" | "contradicts" | "resolved-by" | "covered-by" | "recurs-as";
+/** Where a relation came from (§4 / §5-bis provenance). */
+export type RelationProvenance = "deterministic" | "llm" | "wikilink-promoted";
+export interface OntRelation {
+    /** §5-bis: relId = hash(sourceId | rel | targetId) — the idempotent upsert key. */
+    readonly relId: string;
+    readonly rel: RelationType;
+    readonly sourceId: string;
+    readonly targetId: string;
+    readonly provenance: RelationProvenance;
+    /** 0..1; deterministic extraction = 1.0. */
+    readonly confidence: number;
+    /** ISO date a human confirmed it; null = proposed/unconfirmed. */
+    readonly confirmed?: string | null;
+    /** Record path / snippet pointer backing the relation. */
+    readonly evidence?: string | null;
+}
+/** §3 — alias → canonical object id (identity layer; replaces a `same-as` relation). */
+export interface OntAlias {
+    readonly alias: string;
+    readonly canonicalId: string;
+}
+/** A single result of a multi-hop walk (§5B; capped at ≤ 3 hops, cycle-guarded). */
+export interface WalkStep {
+    readonly nodeId: string;
+    readonly depth: number;
+    readonly path: readonly string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AACnE,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AAEjD,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG,WAAW,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7F,MAAM,WAAW,SAAS;IACxB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,GAAG,IAAI,CAAC;IACtD,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED,+DAA+D;AAC/D,MAAM,MAAM,YAAY,GACpB,QAAQ,GACR,SAAS,GACT,YAAY,GACZ,YAAY,GACZ,aAAa,GACb,aAAa,GACb,YAAY,GACZ,WAAW,CAAC;AAEhB,2DAA2D;AAC3D,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG,KAAK,GAAG,mBAAmB,CAAC;AAE/E,MAAM,WAAW,WAAW;IAC1B,mFAAmF;IACnF,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,UAAU,EAAE,kBAAkB,CAAC;IACxC,4CAA4C;IAC5C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kEAAkE;IAClE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAED,wFAAwF;AACxF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,oFAAoF;AACpF,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC"}

package/dist/types.js

@@ -0,0 +1,10 @@
+/**
+ * @vortex-os/ontos — core types (Phase 1, text-first).
+ *
+ * Six object types, eight relation types. Object identity ("same-as") is handled
+ * by the alias layer (see the sqlite store), NOT as a graph relation — keeping
+ * dedup separate from `recurs-as` (pattern recurrence). See the maintainer's
+ * instance Phase 1 build spec for the full rationale.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@vortex-os/ontos",
+  "version": "0.1.0",
+  "description": "Add-on — a lightweight ontology of your operational world (objects, typed relations, multi-hop traversal) built from VortEX records, layered on @vortex-os/base. Phase 1 is text-first and sqlite-backed; no formal OWL/RDF reasoner.",
+  "license": "MIT",
+  "author": "vortex-os-project",
+  "homepage": "https://github.com/vortex-os-project/vortex#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vortex-os-project/vortex.git",
+    "directory": "modules/ontos"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./sqlite": {
+      "types": "./dist/sqlite/index.d.ts",
+      "default": "./dist/sqlite/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts/rebuild-ontos.mjs",
+    "README.md"
+  ],
+  "bin": {
+    "rebuild-ontos": "scripts/rebuild-ontos.mjs"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "verify": "node scripts/verify.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "yaml": "^2.6.0"
+  },
+  "peerDependencies": {
+    "@vortex-os/base": ">=0.3.0 <1.0.0",
+    "better-sqlite3": "^12.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@vortex-os/base": {
+      "optional": false
+    },
+    "better-sqlite3": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.10.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/rebuild-ontos.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// Rebuild the ontos sqlite index from a VortEX instance's records (Phase 1,
+// deterministic — no LLM, read-only on your files). Walks the record dirs,
+// parses frontmatter, runs deterministic extraction, and upserts objects +
+// typed relations. Untyped wikilink candidates are counted but not stored
+// (they need human typing/confirmation — that lands with the confirm UX).
+//
+// Usage:  rebuild-ontos [--data-dir <dir>] [--db <path>]
+import { readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { OntosStore } from "../dist/sqlite/index.js";
+import { extractDeterministic } from "../dist/extract/index.js";
+import { parseFrontmatter } from "../dist/internal/frontmatter.js";
+
+const args = process.argv.slice(2);
+let dataDir = resolve(process.cwd(), "data");
+let dbPath = null;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--data-dir" && args[i + 1]) dataDir = resolve(args[++i]);
+  else if (args[i] === "--db" && args[i + 1]) dbPath = resolve(args[++i]);
+}
+if (!dbPath) dbPath = join(dataDir, "_indexes", "ontos.sqlite");
+
+const SOURCES = [
+  { dir: join(dataDir, "_failures"), category: "failure" },
+  { dir: join(dataDir, "decision-log"), category: "decision" },
+  { dir: join(dataDir, "_memory"), category: "memory" },
+];
+
+// FLAT listing (non-recursive): the extracted categories (_failures, decision-log,
+// _memory) are flat dirs, so file basenames are unique within each — which keeps
+// occurrence ids unique AND portable across machines (a full-path id would differ
+// by OS path separator). Subdirectories are intentionally not descended.
+function listMd(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return []; // dir absent — skip
+  }
+  // isFile() is false for symlinks, so a symlinked *.md is not followed out of data/.
+  return entries
+    .filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== "_INDEX.md")
+    .map((e) => join(dir, e.name));
+}
+
+const store = new OntosStore(dbPath);
+let files = 0;
+let skipped = 0;
+let objects = 0;
+let relations = 0;
+let links = 0;
+try {
+  // One transaction = a TRUE rebuild: clear first (drop stale rows from deleted/
+  // renamed records), then repopulate from the full walk. Atomic + fast.
+  store.transaction(() => {
+    store.clear();
+    for (const { dir, category } of SOURCES) {
+      for (const path of listMd(dir)) {
+        files++;
+        const { frontmatter, body } = parseFrontmatter(readFileSync(path, "utf8"));
+        const res = extractDeterministic({ path, category, frontmatter, body });
+        if (res.objects.length === 0) skipped++; // no recognizable fields (e.g. malformed/empty frontmatter)
+        for (const o of res.objects) {
+          store.upsertObject(o);
+          objects++;
+        }
+        for (const r of res.relations) {
+          store.upsertRelation(r);
+          relations++;
+        }
+        links += res.links.length;
+      }
+    }
+  });
+  console.log(
+    `[rebuild-ontos] files=${files} skipped=${skipped} objects=${objects} relations=${relations} link-candidates=${links}`,
+  );
+  console.log(`[rebuild-ontos] db: ${store.dbPath}`);
+} finally {
+  store.close();
+}