Lucern

Showing 25 of 137 from the live probe.

• Create Belief

  Commit a new belief (knowledge unit) to the reasoning graph. Like `git commit` — creates an atomic, traceable knowledge object with a prior. Creation requires a topic epistemic-node anchor and writes a `belongs_to` edge directly from belief node to topic node; orphan beliefs are invalid. Creation stores the vacuous opinion `(0, 0, 1, a)`; attach supporting or contradicting evidence with create_evidence or link_evidence_to_belief to record evidential updates.

• Get Belief

  Read one belief by ID. Like `git show` — resolves the canonical belief payload for a single identifier.

• Refine Belief

  Amend a draft belief in-place within an active worktree. Like `git commit --amend` — rewrites the last commit on a feature branch. Only valid before merge to main. Fails if the belief is already scored.

• Fork Belief

  Branch off an evidence-bearing belief to create a new formulation. Like `git fork` — the parent remains immutable with full history, and every fork must cite evidence already attached to the parent through SL scoring. `forkMode=supersede` marks the parent superseded and requires contradicting evidence; `forkMode=branch` preserves the parent and creates a derived child.

• Archive Belief

  Soft-delete a belief by setting its status to archived. Like `git rm` — removed from the working tree but preserved in history. Beliefs are never truly deleted. Archived beliefs retain full lineage and confidence history.

• Create Evidence

  Commit evidence to the reasoning graph. Like `git commit` — creates a traceable evidence record with canonical public IDs. Evidence creation must link to at least one belief and must include a signed impact score. Positive scores support the belief; negative scores contradict it. SL confidence is derived from these weighted evidence relations.

• Get Evidence

  Read one evidence record by ID. Like `git show` — resolves the canonical evidence payload for a single identifier.

• List Evidence

  List evidence records within a topic or linked to a target. Like `git log -- path` — returns the canonical evidence page for a topic, belief, or question scope.

• Archive Evidence

  Archive an evidence record while preserving its reasoning history. Like `git rm` — removes evidence from active workflows without erasing the audit trail. Use this for evidence hygiene after the evidence has been superseded, corrected, or ruled out.

• Flag Contradiction

  Flag a contradiction between two beliefs. Contradictions are first-class objects with their own lifecycle — they may remain permanently unresolved. Like a merge conflict that is allowed to persist. Contradictions can trigger structural changes: forking, confidence collapse, or decision blocking. Resolution is NEVER automatic — always surfaces for human review.

• List Lenses

  List reusable lenses for a workspace, optionally scored by whether they are active on a topic. Like `git branch --list` — shows the available named frames you can activate. When topicId is provided, the response can indicate which lenses are already applied there.

• Apply Lens To Topic

  Apply a lens to a topic so it becomes an active perspective overlay. Like `git checkout <branch>` for a reusable frame — the topic keeps its knowledge, but the active lens shapes guidance and retrieval. Multiple active lenses can coexist on the same topic.

• Remove Lens From Topic

  Remove an active lens overlay from a topic. Like `git switch` away from a frame — the topic remains, but the lens stops shaping the investigation context. Historical binding state is preserved for auditability.

• Add Worktree

  Check out a branch into an active worktree for investigation. Like `git worktree add <branch>` — creates independent working state on a thematic branch. Beliefs committed within the worktree can be freely amended (draft code on a feature branch). When investigation is complete, `merge` integrates findings into main.

• Merge

  Merge a worktree's findings into the stable knowledge base (main). Like `git merge` to main — formulations freeze, confidence is recorded, findings are integrated. Each belief gets a confidence score and rationale. After merge, beliefs can only evolve via fork. Low-confidence beliefs may need forking.

• Query Lineage

  Trace a belief's full ancestry — every fork, score, and SL scoring event. Like `git log --graph`. Returns the complete evolution chain showing how understanding developed over time. Lineage is permanent and can never be erased (Invariant #3).

• Query Anchor History

  Resolve anchor provenance history for a reasoning node. Like `git log --ancestry-path` for derived reasoning — follows canonical derived_from lineage while preserving the storage-only extracted_from alias.

• Traverse Graph

  Walk the reasoning graph from a starting node. Like `git log --graph` — traverses connected lineage across nodes and edges. Traversal follows epistemic layers: L4 (judgments) → L3 (beliefs, questions) → L2 (evidence) → L1 (sources). Never skips layers. Use direction 'up' to trace what a piece of evidence supports, 'down' to trace what supports a judgment.

• Get Graph Neighborhood

  Retrieve the local neighborhood around one or more graph nodes. Like `git log --graph --boundary` for a focused reasoning window. Returns the canonical neighborhood payload shared by HTTP and SDK graph surfaces.

• Trace Entity Impact

  Returns code-grounded beliefs, contracts, migration states, and failed attempts anchored to a specific file or function path. Like `git log -- <path>` — filters the knowledge graph to nodes anchored to a file path via metadata.codeAnchors. Results are separated by coding belief type: decisions, contracts, migrations, patterns, deprecations, and failures.

• Search Beliefs

  Search for beliefs in the reasoning graph. Like `git grep` — finds relevant beliefs across the full history and active state. Supports semantic search, filtering by status (unscored, scored, archived), confidence thresholds, and topic scope. Returns beliefs with their current confidence, lineage depth, and contradiction count.

• Find Contradictions

  Find contradictions in the reasoning graph — beliefs that are in tension with each other. Like a merge conflict in `git` — surfaces incompatible states that require explicit resolution. Contradictions are first-class objects that may remain permanently unresolved. They can block judgments, trigger forks, or collapse confidence. Filter by project, status (unresolved, resolved, accepted), and severity.

• Bisect Confidence

  Find when a belief's confidence diverged from reality. Like `git bisect` — binary search through the credence history to find the inflection point. Given a belief that is now known to be wrong (or right), traces back through SL scoring events to identify which evidence or event caused the divergence.

• List Missing Embeddings

  List epistemic nodes missing fresh Convex embeddings. Like `git status` for the semantic index — shows which graph nodes still need indexing before retrieval can be trusted.

• Search Embeddings

  Search topic-scoped epistemic nodes through the Convex vector index. Like `git grep` with semantic distance — finds matching beliefs, questions, evidence, and other nodes even when wording differs.