@littlebigbrain/mcp 0.5.2 → 0.7.0

package/README.md

@@ -64,8 +64,8 @@ Requires Node.js 18+. Copy the complete endpoint and a stack API key from
 ```
 
 The client starts the server and communicates through standard input and output
-(stdio). Keep the key in your local configuration. Set `LBB_GRAPH` or
-`LBB_BRANCH` to change the default scope from `main`.
+(stdio). Keep the key in your local configuration. Set `LBB_GRAPH` to change
+the default graph from `main`.
 
 ## Run a first query
 
@@ -112,7 +112,7 @@ its original identifiers; inspect it with SPARQL when choosing query predicates.
 
 | Tool | Purpose |
 | --- | --- |
-| `lbb_inspect` | Read the schema, graph status, entities, history, and evidence. |
+| `lbb_inspect` | Read the schema, graph status, and entities. |
 | `lbb_query` | Run SPARQL queries, search by meaning, or request summary statistics. |
 | `lbb_rdf` | Import RDF documents or add facts with SPARQL `INSERT DATA`. |
 | `lbb_embeddings` | Inspect search setup and preview the text to embed. |
@@ -120,8 +120,6 @@ its original identifiers; inspect it with SPARQL when choosing query predicates.
 | `lbb_embeddings_delete` | Delete an embedding and its stored vectors. |
 | `lbb_commit` | Write or retract JSON facts, or record search feedback. |
 | `lbb_configure` | Define record types and relationships, or publish validation rules. |
-| `lbb_branch` | Create branches and merge reviewed changes. |
-| `lbb_observe` | Store conversation episodes and reviewed facts extracted from them. |
 | `lbb_evals` | Label query results and check whether later queries return the expected answers. |
 | `lbb_models` | Compare retrieval settings and read model training datasets. |
 
@@ -130,8 +128,8 @@ for embedding setup. To define constraints with the Shapes Constraint Language
 (SHACL), see [query and validation](https://docs.littlebigbrain.com/guides/sparql-and-shacl/).
 
 RDF imports and JSON facts use different write workflows. A graph first written
-through `lbb_rdf` does not accept JSON fact writes through `lbb_commit`, or branch
-forks and merges. Choose the workflow when creating the graph. RDF updates
+through `lbb_rdf` does not accept JSON fact writes through `lbb_commit`. Choose
+the workflow when creating the graph. RDF updates
 support additive `INSERT DATA`;
 see the [RDF guide](https://docs.littlebigbrain.com/guides/load-rdf/) for format and
 update limits.

package/dist/http-server.d.ts

@@ -22,7 +22,6 @@ export interface McpHttpServerOptions {
         baseUrl: string;
         apiKey: string;
         graph?: string;
-        branch?: string;
     }) => LbbClient;
 }
 export declare function bearer(req: IncomingMessage): string | undefined;

package/dist/http-server.js

@@ -150,7 +150,6 @@ export function createMcpHttpServer(options) {
                 baseUrl,
                 apiKey,
                 graph: url.searchParams.get("graph") ?? undefined,
-                branch: url.searchParams.get("branch") ?? undefined,
             };
             const client = options.clientFactory
                 ? options.clientFactory(clientOptions)

package/dist/metadata-pages.d.ts

@@ -4,7 +4,6 @@ import { metadataPageSchema } from "./tool-contracts.js";
 type Request = z.infer<z.ZodObject<typeof metadataPageSchema>> & {
     action: "ontology" | "schema";
     graph?: string;
-    branch?: string;
 };
 /** Stateless pagination of complete entries, including their full nested values.
  * A digest rejects mixed-version reads instead of skipping/repeating definitions
@@ -24,7 +23,6 @@ export declare function metadataPage(client: LbbClient, args: Request): Promise<
     next: {
         action: "ontology" | "schema";
         graph: string | undefined;
-        branch: string | undefined;
         section: string | undefined;
         page_size: number;
         cursor: string;

package/dist/metadata-pages.js

@@ -7,7 +7,6 @@ const cursorSchema = z
     v: z.literal(1),
     action: z.enum(["ontology", "schema"]),
     graph: z.string().optional(),
-    branch: z.string().optional(),
     section: z.string().optional(),
     page_size: z.number().int().min(1).max(500),
     offset: z.number().int().nonnegative().safe(),
@@ -27,23 +26,16 @@ export async function metadataPage(client, args) {
         catch {
             throw new Error("invalid lbb_inspect cursor; restart without cursor");
         }
-        for (const key of [
-            "action",
-            "graph",
-            "branch",
-            "section",
-            "page_size",
-        ]) {
+        for (const key of ["action", "graph", "section", "page_size"]) {
             if (args[key] !== undefined && args[key] !== cursor[key]) {
                 throw new Error(`cursor ${key} does not match the supplied ${key}`);
             }
         }
     }
     const graph = cursor?.graph ?? args.graph;
-    const branch = cursor?.branch ?? args.branch;
     const section = cursor?.section ?? args.section;
     const pageSize = cursor?.page_size ?? args.page_size ?? 50;
-    const target = client.withScope({ graph, branch });
+    const target = client.withScope({ graph });
     const value = (args.action === "ontology"
         ? await target.ontologyView({ counts: true })
         : await target.schema.view());
@@ -62,7 +54,6 @@ export async function metadataPage(client, args) {
         v: 1,
         action: args.action,
         graph,
-        branch,
         section,
         page_size: pageSize,
         fingerprint,
@@ -94,7 +85,6 @@ export async function metadataPage(client, args) {
                 ? {
                     action: args.action,
                     graph,
-                    branch,
                     section,
                     page_size: pageSize,
                     cursor: Buffer.from(JSON.stringify({

package/dist/rdf-tool.js

@@ -49,13 +49,12 @@ export function registerRdfTool(server, client) {
             return errorResult(parsed.error);
         const args = parsed.data;
         return run(client, `lbb_rdf.${args.action}`, args.detail, async () => {
-            const target = scoped(client, args.graph, args.branch);
+            const target = scoped(client, args.graph);
             const { idempotency_key } = args;
             const operation = { ...args };
             delete operation.detail;
             delete operation.idempotency_key;
-            const key = idempotency_key ??
-                contentHashKey({ graph: args.graph, branch: args.branch }, operation);
+            const key = idempotency_key ?? contentHashKey({ graph: args.graph }, operation);
             if (args.action === "import") {
                 return target.importRdf(args.source, {
                     format: args.format ?? "turtle",

package/dist/stdio.js

@@ -12,7 +12,7 @@ const BASE_URL_HELP = "LBB_BASE_URL is required. Copy endpoint_url from your Lit
  *
  *   LBB_BASE_URL  (required for tool calls; copy endpoint_url from the stack Connect page)
  *   LBB_API_KEY   stack API key (lbb_sk_live_…) or single-mode token
- *   LBB_GRAPH / LBB_BRANCH  (optional; server defaults to main/main)
+ *   LBB_GRAPH     (optional; server defaults to main)
  *
  * The base URL is required lazily, at the first tool invocation, not at
  * process start: MCP hosts launch servers to complete the initialize
@@ -44,7 +44,6 @@ async function main() {
             baseUrl,
             apiKey: process.env.LBB_API_KEY,
             graph: process.env.LBB_GRAPH,
-            branch: process.env.LBB_BRANCH,
         })
         : unconfiguredClient();
     const server = buildLbbServer(client);

package/dist/tool-contracts.js

@@ -40,10 +40,6 @@ export const graphScope = {
         .string()
         .optional()
         .describe("Graph to target; defaults to the connection's graph"),
-    branch: z
-        .string()
-        .optional()
-        .describe("Branch to target; defaults to the connection's branch"),
 };
 export const jsonObjectSchema = z.record(z.string(), z.unknown());
 export const jsonObjectArraySchema = z.array(jsonObjectSchema);
@@ -375,56 +371,7 @@ export const inspectInputSchema = z.discriminatedUnion("action", [
             .int()
             .nonnegative()
             .optional()
-            .describe("Snapshot pin: reproduce the node (state, edges, history) as of this commit_seq."),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("state"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z.string().optional(),
-        as_of: z.string().optional(),
-        as_of_commit_seq: z
-            .number()
-            .int()
-            .nonnegative()
-            .optional()
-            .describe("Snapshot pin: reproduce the state as of this commit_seq, hiding later commits. Errors if past head."),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("history"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z.string().optional(),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("why"),
-        source_type: z.string(),
-        source_name: z.string(),
-        relation: z.string(),
-        target_type: z.string(),
-        target_name: z.string(),
-        ...readScope,
-    })
-        .strict(),
-    z
-        .object({
-        action: z.literal("transitions"),
-        entity_type: z.string(),
-        name: z.string(),
-        relation: z
-            .string()
-            .describe("State/status relation to trace, e.g. IN_STAGE or HAS_STATUS"),
-        as_of: z.string().optional(),
-        as_of_commit_seq: z.number().int().nonnegative().optional(),
+            .describe("Snapshot pin: reproduce the node's attributes and relationships as of this commit_seq."),
         ...readScope,
     })
         .strict(),
@@ -576,7 +523,6 @@ export const configureInputSchema = z.discriminatedUnion("action", [
             .optional()
             .describe("Preview the exact definition without creating a graph or writing metadata."),
         graph: z.string().describe("Graph to create or redefine"),
-        branch: graphScope.branch,
         entity_types: z.array(z.union([z.string(), jsonObjectSchema])).optional(),
         relations: z.array(z.union([z.string(), jsonObjectSchema])).optional(),
         source: z.string().optional(),
@@ -627,7 +573,7 @@ export const configureInputSchema = z.discriminatedUnion("action", [
  * rejects as `Expected object, received string`.
  *
  * Flatten the union into a single ZodObject purely for advertisement and
- * transport: the discriminant becomes an enum, every branch field is merged in
+ * transport: the discriminant becomes an enum, every variant field is merged in
  * as optional, and unknown keys pass through. Each handler still `safeParse`s the
  * raw args against the original strict union before dispatching, so per-variant
  * required/forbidden fields are enforced exactly as before.

package/dist/tool-runtime.js

@@ -2,9 +2,7 @@ import { Buffer } from "node:buffer";
 import { createHash } from "node:crypto";
 import { LbbError } from "@littlebigbrain/client";
 import { DEFAULT_DETAIL, HARD_OUTPUT_CHARS, MAX_QUERY_ROW_LIMIT, } from "./tool-contracts.js";
-export const scoped = (client, graph, branch) => graph !== undefined || branch !== undefined
-    ? client.withScope({ graph, branch })
-    : client;
+export const scoped = (client, graph) => graph !== undefined ? client.withScope({ graph }) : client;
 export function normalizeDetail(detail) {
     return detail === "standard" || detail === "full" ? detail : DEFAULT_DETAIL;
 }
@@ -50,9 +48,6 @@ export function assertCursorScope(args, cursor) {
     if (args.graph !== undefined && args.graph !== cursor.graph) {
         throw new Error("cursor graph does not match the supplied graph argument");
     }
-    if (args.branch !== undefined && args.branch !== cursor.branch) {
-        throw new Error("cursor branch does not match the supplied branch argument");
-    }
 }
 export function rowPageFrom(value) {
     if (!value || typeof value !== "object")
@@ -190,7 +185,7 @@ export function normalizeLbbIris(query) {
 export function contentHashKey(scope, payload) {
     const digest = createHash("sha256")
         .update(stableJson({
-        scope: { graph: scope.graph ?? null, branch: scope.branch ?? null },
+        scope: { graph: scope.graph ?? null },
         payload,
     }))
         .digest("hex");
@@ -440,60 +435,38 @@ export function errorResult(error) {
     };
 }
 /**
- * A graph-scope 404 surfaces as a raw object-storage key
- * (`not found: tenants/<t>/graphs/<g>/branches/<b>/heads/current.json`), which
- * only means something if you already know the graph's real name. Rewrite it
- * into an actionable message: name the graph/branch this request targeted, and —
- * via the tenant-scoped `GET /v1/graphs`, which resolves even when the scoped
- * graph is absent — list the graphs (or branches) that do exist and tell the
- * caller to pass `graph=`/`branch=`. Every other error passes through untouched.
+ * A graph-scope 404 surfaces as a raw object-storage key ending in
+ * `heads/current.json`, which only means something if you already know the
+ * graph's real name. Rewrite it into an actionable message: name the graph this
+ * request targeted and — via the tenant-scoped `GET /v1/graphs`, which resolves
+ * even when the scoped graph is absent — list the graphs that do exist and tell
+ * the caller to pass `graph=`. Every other error passes through untouched,
+ * including a head 404 on a graph the listing still reports.
  */
 export async function enrichError(client, error) {
     if (!(error instanceof LbbError) || error.status !== 404)
         return error;
-    const match = /graphs\/([^/]+)\/branches\/([^/]+)\/heads\/current\.json/.exec(error.message);
+    const match = /graphs\/([^/\s]+)\/(?:[^/\s]+\/)*heads\/current\.json/.exec(error.message);
     if (!match)
         return error;
-    const [, graph, branch] = match;
-    let graphs = [];
+    const [, graph] = match;
+    let names = [];
     try {
         const listed = (await client.listGraphs());
-        graphs = (listed.data ?? []).flatMap((g) => typeof g.graph_id === "string"
-            ? [
-                {
-                    graph_id: g.graph_id,
-                    branches: Array.isArray(g.branches)
-                        ? g.branches
-                        : undefined,
-                },
-            ]
-            : []);
+        names = (listed.data ?? []).flatMap((g) => typeof g.graph_id === "string" ? [g.graph_id] : []);
     }
     catch {
         // Listing failed too (auth, transport); fall back to the generic-but-actionable hint.
     }
-    const existing = graphs.find((g) => g.graph_id === graph);
-    let message;
-    if (existing) {
-        const branches = existing.branches ?? [];
-        const list = branches.length > 0
-            ? ` Existing branches: ${branches.slice(0, 50).join(", ")}.`
-            : "";
-        message =
-            `branch "${branch}" was not found on graph "${graph}" in this tenant.${list} ` +
-                "Pass an existing branch as the `branch` argument.";
-    }
-    else {
-        const names = graphs.map((g) => g.graph_id);
-        const list = names.length > 0
-            ? ` Available graphs in this tenant: ${names.slice(0, 50).join(", ")}.`
-            : "";
-        const example = names.length > 0 ? ` (e.g. graph="${names[0]}")` : "";
-        message =
-            `graph "${graph}" was not found in this tenant — this request targeted graph "${graph}", branch "${branch}" ` +
-                `(either you passed it or it is the connection default).${list} ` +
-                `Pass an existing graph as the \`graph\` argument${example}.`;
-    }
+    if (names.includes(graph))
+        return error;
+    const list = names.length > 0
+        ? ` Available graphs in this tenant: ${names.slice(0, 50).join(", ")}.`
+        : "";
+    const example = names.length > 0 ? ` (e.g. graph="${names[0]}")` : "";
+    const message = `graph "${graph}" was not found in this tenant — this request targeted graph "${graph}" ` +
+        `(either you passed it or it is the connection default).${list} ` +
+        `Pass an existing graph as the \`graph\` argument${example}.`;
     return new LbbError(error.status, error.body, {
         type: error.type,
         code: error.code,
@@ -683,8 +656,8 @@ export async function guide(scopedClient) {
         relations,
         capability: {
             search_feedback: "When a result set is useful or clearly wrong, write relevance labels with lbb_commit mode=search_feedback. Use grade 3 for ideal/good results, grade 1 for partially relevant results, and grade 0 for bad results. Include the original query, search_id when present, target identity, rank, score, and an optional split train/eval/unspecified. These labels are stored in __lbb_feedback/main and later exported as qrels-style training/eval data; they are not customer facts.",
-            inspect: "Use lbb_inspect for ontology, schema metadata, the published conformance report, metadata, state/history/why, and this guide. Use lbb_query with SPARQL property paths for exact path queries.",
-            ontology_decorations: "lbb_inspect action=ontology returns a decoration_status catalog: each ontology decoration is enforced (the engine acts on it — state_reducer, value_type, super_types, properties, supernode_policy; cardinality, which GET /v1/ontology/conformance audits as sh:maxCount; and inverse_name/symmetric, which SPARQL resolves as relation aliases — an inverse name is queryable directly (lowered to ^forward, no stored inverse triple) and a symmetric relation matches both directions), advisory (transitive, temporal_semantics, required), or reserved (stored but unwired — default_weight, resolvable, alias/embedding_fields). You can also always reverse any relation in SPARQL by flipping the triple pattern or using ^forward. Each relation_def also carries edge_count — the number of current edges of that relation in this branch's snapshot — so you can tell at a glance which declared relations are actually populated (edge_count 0 = declared but unused) without a separate summary call.",
+            inspect: "Use lbb_inspect for ontology, schema metadata, the published conformance report, metadata, entities, and this guide. Use lbb_query with SPARQL property paths for exact path queries.",
+            ontology_decorations: "lbb_inspect action=ontology returns a decoration_status catalog: each ontology decoration is enforced (the engine acts on it — state_reducer, value_type, super_types, properties, supernode_policy; cardinality, which GET /v1/ontology/conformance audits as sh:maxCount; and inverse_name/symmetric, which SPARQL resolves as relation aliases — an inverse name is queryable directly (lowered to ^forward, no stored inverse triple) and a symmetric relation matches both directions), advisory (transitive, temporal_semantics, required), or reserved (stored but unwired — default_weight, resolvable, alias/embedding_fields). You can also always reverse any relation in SPARQL by flipping the triple pattern or using ^forward. Each relation_def also carries edge_count — the number of current edges of that relation in this graph's snapshot — so you can tell at a glance which declared relations are actually populated (edge_count 0 = declared but unused) without a separate summary call.",
             search: "Use lbb_query mode=search to find instances by meaning. It covers every searchable class; filter narrows it by class and by relationship, and the graph checks every hit. To plan a search: (1) lbb_embeddings action=list gives the searchable classes, the facts each text is made from, and the graph's model. (2) lbb_query mode=sparql shows the relationships of a class on a sample: PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> SELECT ?p (COUNT(DISTINCT ?s) AS ?n) (SAMPLE(?l) AS ?example) WHERE { { SELECT ?s WHERE { ?s a <CLASS> } LIMIT 500 } ?s ?p ?o . FILTER(isIRI(?o) && ?p != rdf:type) OPTIONAL { ?o rdfs:label ?l } } GROUP BY ?p ORDER BY DESC(?n); write ?o ?p ?s for the links into the class, and SELECT ?c WHERE { ?c rdfs:subClassOf* <CLASS> } (same prefixes) for its subclasses. (3) lbb_query mode=search with filter [{class}, {via, to}] and explain=true returns the plan: the resolved relationship and entities, the allowed count, and the mode, with no model call. Check it, then run the search without explain. A name in to resolves against labels (a small typo too); an unknown relationship or name answers with the options.",
             query: "Use lbb_query for structured SPARQL-subset bodies, SPARQL text, and canned analysis. SPARQL is the only query surface. A mode=structured body is { patterns: [{ subject, predicate, object }], filters?, group_by?, group_keys?, aggregates?, having? }; a pattern `predicate` is a relation name and is case-insensitive. mode=structured GROUP BY is not limited to entity identity: group_keys can key on a typed scalar property or calendar bucket. In SPARQL text, relations are <https://littlebigbrain.com/r/NAME> and types <https://littlebigbrain.com/class/NAME>. Each query pins one published watermark.",
             write: "Use lbb_commit for fact writes and relevance feedback; omitted idempotency keys are content-derived so retries dedupe. Set typed scalar attributes via entity_properties once the field is registered (add it on a live graph with lbb_configure evolve_ontology add_property). For feedback, use mode=search_feedback rather than fact triplets.",

package/dist/tools.js

@@ -7,7 +7,7 @@ import { analyze, assertCursorScope, contentHashKey, decodeQueryCursor, effectiv
 export function registerLbbTools(server, client, options = {}) {
     registerRdfTool(server, client);
     server.registerTool("lbb_inspect", {
-        description: "Read graph context and exact graph facts. Actions: guide, graphs, publication, ontology, ontology_conformance, schema, ontology_search, metadata, entity, state, history, transitions, why. graphs works before bootstrap; publication reports whether writes are queryable. ontology and schema return complete entries with page_size, section and cursor; follow next until absent. schema reads active native ontology/SHACL metadata without running validation. Query asserted RDF/OWL axioms separately with lbb_query. ontology_conformance serves the durable report referenced by the pinned published root. entity returns one node's metadata, scalar attributes, bounded Base-backed edge neighborhood, history, and observations. Use lbb_query with SPARQL property paths for precise path selection.",
+        description: "Read graph context and exact graph facts. Actions: guide, graphs, publication, ontology, ontology_conformance, schema, ontology_search, metadata, entity. graphs works before bootstrap; publication reports whether writes are queryable. ontology and schema return complete entries with page_size, section and cursor; follow next until absent. schema reads active native ontology/SHACL metadata without running validation. Query asserted RDF/OWL axioms separately with lbb_query. ontology_conformance serves the durable report referenced by the pinned published root. entity returns one node's attributes and current relationships from the RDF read. For a node's past values, run SPARQL with as_of_commit_seq through lbb_query. Use lbb_query with SPARQL property paths for precise path selection.",
         inputSchema: inspectWireSchema,
         annotations: READ_ONLY,
     }, (rawArgs) => {
@@ -21,7 +21,7 @@ export function registerLbbTools(server, client, options = {}) {
                 .catch(async (error) => errorResult(await enrichError(client, error)));
         }
         return run(client, `lbb_inspect.${args.action}`, args.detail, () => {
-            const target = scoped(client, args.graph, args.branch);
+            const target = scoped(client, args.graph);
             switch (args.action) {
                 case "guide":
                     return guide(target);
@@ -51,46 +51,6 @@ export function registerLbbTools(server, client, options = {}) {
                         asOf: args.as_of,
                         asOfCommitSeq: args.as_of_commit_seq,
                     });
-                case "state":
-                    return target.currentState({
-                        entity: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relations: args.relation ? [args.relation] : null,
-                        as_of_valid_time: args.as_of ?? null,
-                        as_of_commit_seq: args.as_of_commit_seq ?? null,
-                    });
-                case "history":
-                    return target.history({
-                        source: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relation: args.relation ?? null,
-                    });
-                case "why":
-                    return target.why({
-                        source: {
-                            entity_type: args.source_type,
-                            name: args.source_name,
-                        },
-                        relation: args.relation,
-                        target: {
-                            entity_type: args.target_type,
-                            name: args.target_name,
-                        },
-                    });
-                case "transitions":
-                    return target.transitions({
-                        entity: {
-                            entity_type: args.entity_type,
-                            name: args.name,
-                        },
-                        relation: args.relation,
-                        as_of_valid_time: args.as_of ?? null,
-                        as_of_commit_seq: args.as_of_commit_seq ?? null,
-                    });
             }
         });
     });
@@ -110,7 +70,7 @@ export function registerLbbTools(server, client, options = {}) {
                     if (cursor && cursor.mode !== args.mode) {
                         throw new Error(`cursor is for ${cursor.mode}, not ${args.mode}`);
                     }
-                    assertCursorScope({ graph: args.graph, branch: args.branch }, cursor);
+                    assertCursorScope({ graph: args.graph }, cursor);
                     if (cursor &&
                         args.row_limit !== undefined &&
                         args.row_limit !== cursor.row_limit) {
@@ -119,9 +79,8 @@ export function registerLbbTools(server, client, options = {}) {
                     const detail = normalizeDetail(args.detail ?? cursor?.detail);
                     const rowLimit = effectiveRowLimit(detail, args.row_limit ?? cursor?.row_limit);
                     const graph = cursor?.graph ?? args.graph;
-                    const branch = cursor?.branch ?? args.branch;
                     const offset = cursor?.offset ?? 0;
-                    const target = scoped(client, graph, branch);
+                    const target = scoped(client, graph);
                     const timing = queryTiming(options, {
                         mode: args.mode,
                         continuation: cursor !== undefined,
@@ -230,7 +189,6 @@ export function registerLbbTools(server, client, options = {}) {
                             v: 1,
                             mode: "structured",
                             graph,
-                            branch,
                             detail,
                             row_limit: rowLimit,
                             body,
@@ -284,7 +242,6 @@ export function registerLbbTools(server, client, options = {}) {
                         v: 1,
                         mode: "sparql",
                         graph,
-                        branch,
                         detail,
                         row_limit: rowLimit,
                         query,
@@ -305,7 +262,7 @@ export function registerLbbTools(server, client, options = {}) {
         if (args.mode === "search") {
             const searchArgs = args;
             return run(client, "lbb_query.search", undefined, async () => {
-                const target = scoped(client, searchArgs.graph, searchArgs.branch);
+                const target = scoped(client, searchArgs.graph);
                 return target.embeddings.search({
                     embedding: searchArgs.embedding,
                     text: searchArgs.text,
@@ -319,7 +276,7 @@ export function registerLbbTools(server, client, options = {}) {
             });
         }
         return run(client, `lbb_query.${args.mode}`, args.detail, async () => {
-            const target = scoped(client, args.graph, args.branch);
+            const target = scoped(client, args.graph);
             return analyze(target, {
                 metric: args.metric,
                 chart: args.chart,
@@ -333,13 +290,7 @@ export function registerLbbTools(server, client, options = {}) {
     server.registerTool("lbb_models", {
         description: "Read model-training inputs or compare retrieval configurations over one pinned published snapshot. shadow_eval takes the API ShadowEvalRequest body; dataset actions return bounded training examples at an optional signal split.",
         inputSchema: {
-            action: z.enum([
-                "shadow_eval",
-                "planner_dataset",
-                "planner_preference_dataset",
-                "suggest_dataset",
-                "extractor_dataset",
-            ]),
+            action: z.enum(["shadow_eval", "suggest_dataset", "extractor_dataset"]),
             body: jsonObjectSchema.optional(),
             limit: z.number().int().positive().optional(),
             split_seq: z.number().int().nonnegative().optional(),
@@ -347,20 +298,13 @@ export function registerLbbTools(server, client, options = {}) {
             ...graphScope,
         },
         annotations: READ_ONLY,
-    }, ({ action, body, limit, split_seq, detail, graph, branch }) => run(client, `lbb_models.${action}`, detail, () => {
-        const target = scoped(client, graph, branch);
+    }, ({ action, body, limit, split_seq, detail, graph }) => run(client, `lbb_models.${action}`, detail, () => {
+        const target = scoped(client, graph);
         switch (action) {
             case "shadow_eval":
                 if (!body)
                     throw new Error("shadow_eval requires body");
                 return target.shadowEval(body);
-            case "planner_dataset":
-                return target.plannerDataset({ limit, splitSeq: split_seq });
-            case "planner_preference_dataset":
-                return target.plannerPreferenceDataset({
-                    limit,
-                    splitSeq: split_seq,
-                });
             case "suggest_dataset":
                 return target.suggestDataset({ limit, splitSeq: split_seq });
             case "extractor_dataset":
@@ -416,7 +360,7 @@ export function registerLbbTools(server, client, options = {}) {
         },
         annotations: READ_ONLY,
     }, (args) => run(client, `lbb_embeddings.${args.action}`, args.detail, () => {
-        const target = scoped(client, args.graph, args.branch);
+        const target = scoped(client, args.graph);
         switch (args.action) {
             case "list":
                 return target.embeddings.list();
@@ -446,7 +390,7 @@ export function registerLbbTools(server, client, options = {}) {
         },
         annotations: MUTATING,
     }, (args) => run(client, `lbb_embeddings_manage.${args.action}`, args.detail, () => {
-        const target = scoped(client, args.graph, args.branch);
+        const target = scoped(client, args.graph);
         switch (args.action) {
             case "declare":
                 return target.embeddings.declare(recipeOf(args));
@@ -472,11 +416,11 @@ export function registerLbbTools(server, client, options = {}) {
             ...graphScope,
         },
         annotations: DESTRUCTIVE,
-    }, ({ name, confirm, detail, graph, branch }) => run(client, "lbb_embeddings_delete", detail, () => {
+    }, ({ name, confirm, detail, graph }) => run(client, "lbb_embeddings_delete", detail, () => {
         if (confirm !== name) {
             throw new Error("confirm must repeat the embedding name");
         }
-        return scoped(client, graph, branch).embeddings.delete(name);
+        return scoped(client, graph).embeddings.delete(name);
     }));
     server.registerTool("lbb_evals", {
         description: "Managed evals: the thumbs up / thumbs down of the graph, per result. A query run with `request` (lbb_query) records a trace with one item per result (hit or row); trace reads it back with the item ids. label marks one result (item + valid) or several (items) relevant or not; the labels become the golden's ground truth. golden freezes a query (every result it returns now is relevant). run replays every golden at the current commit: pass when every relevant result is back and no wrong one is; new results open a review trace. judge lets the platform's judge model (the hosted frontier model) label unlabeled results. summary, traces, goldens, results, and settings read state.",
@@ -562,8 +506,8 @@ export function registerLbbTools(server, client, options = {}) {
             ...graphScope,
         },
         annotations: MUTATING,
-    }, ({ action, trace_id, item, valid, items, by, note, sparql, surface, embedding, top_k, request, golden_id, limit, unlabeled, consistency, detail, graph, branch, }) => run(client, `lbb_evals.${action}`, detail, () => {
-        const target = scoped(client, graph, branch);
+    }, ({ action, trace_id, item, valid, items, by, note, sparql, surface, embedding, top_k, request, golden_id, limit, unlabeled, consistency, detail, graph, }) => run(client, `lbb_evals.${action}`, detail, () => {
+        const target = scoped(client, graph);
         switch (action) {
             case "summary":
                 return target.evals.summary();
@@ -684,7 +628,7 @@ export function registerLbbTools(server, client, options = {}) {
             ...graphScope,
         },
         annotations: IDEMPOTENT_WRITE,
-    }, ({ idempotency_key, mode, triplets, entity_embeddings, entity_properties, search_feedback, dry_run, observed_at, edge_idempotency, retract_edges, retract_entities, graph, branch, }) => run(client, "lbb_commit", "standard", () => {
+    }, ({ idempotency_key, mode, triplets, entity_embeddings, entity_properties, search_feedback, dry_run, observed_at, edge_idempotency, retract_edges, retract_entities, graph, }) => run(client, "lbb_commit", "standard", () => {
         const commitMode = mode ??
             (search_feedback
                 ? "search_feedback"
@@ -700,8 +644,8 @@ export function registerLbbTools(server, client, options = {}) {
                 throw new Error("lbb_commit mode=retract requires retract_edges or retract_entities");
             }
             const key = idempotency_key ??
-                contentHashKey({ graph, branch }, { mode: "retract", edges, entities });
-            return scoped(client, graph, branch).retract({ edges, entities }, {
+                contentHashKey({ graph }, { mode: "retract", edges, entities });
+            return scoped(client, graph).retract({ edges, entities }, {
                 idempotencyKey: key,
             });
         }
@@ -709,8 +653,8 @@ export function registerLbbTools(server, client, options = {}) {
             if (!search_feedback)
                 throw new Error("lbb_commit mode=search_feedback requires search_feedback");
             const key = idempotency_key ??
-                contentHashKey({ graph, branch }, { mode: "search_feedback", search_feedback });
-            return scoped(client, graph, branch).searchFeedback(search_feedback, { idempotencyKey: key });
+                contentHashKey({ graph }, { mode: "search_feedback", search_feedback });
+            return scoped(client, graph).searchFeedback(search_feedback, { idempotencyKey: key });
         }
         if (search_feedback) {
             throw new Error("lbb_commit facts mode cannot include search_feedback");
@@ -727,10 +671,10 @@ export function registerLbbTools(server, client, options = {}) {
             payload.entity_properties.length === 0) {
             throw new Error("lbb_commit requires at least one triplet, entity embedding, or entity property");
         }
-        const key = idempotency_key ?? contentHashKey({ graph, branch }, payload);
+        const key = idempotency_key ?? contentHashKey({ graph }, payload);
         if (dry_run)
-            return scoped(client, graph, branch).commitDryRun(payload);
-        return scoped(client, graph, branch).commit(payload, {
+            return scoped(client, graph).commitDryRun(payload);
+        return scoped(client, graph).commit(payload, {
             idempotencyKey: key,
         });
     }));
@@ -745,9 +689,7 @@ export function registerLbbTools(server, client, options = {}) {
         const args = parsed.data;
         return run(client, `lbb_configure.${args.action}`, "standard", () => {
             if (args.action === "define_ontology") {
-                return client
-                    .withScope({ graph: args.graph, branch: args.branch })
-                    .ontologyDefine(ontologyDefineBody({
+                return client.withScope({ graph: args.graph }).ontologyDefine(ontologyDefineBody({
                     entity_types: args.entity_types,
                     relations: args.relations,
                     source: args.source,
@@ -757,7 +699,7 @@ export function registerLbbTools(server, client, options = {}) {
                 }));
             }
             if (args.action === "evolve_ontology") {
-                return scoped(client, args.graph, args.branch).ontology.evolve({
+                return scoped(client, args.graph).ontology.evolve({
                     ops: args.ops,
                     allow_data_conflicts: args.allow_data_conflicts ?? false,
                 }, { dryRun: args.dry_run });
@@ -765,7 +707,7 @@ export function registerLbbTools(server, client, options = {}) {
             if (args.shapes === undefined) {
                 throw new Error("publish_schema requires a SHACL shapes source; use define_ontology or evolve_ontology for native metadata changes");
             }
-            return scoped(client, args.graph, args.branch).schema.publish({
+            return scoped(client, args.graph).schema.publish({
                 ontology: args.ontology,
                 shapes: args.shapes,
                 desired_mode: args.desired_mode,
@@ -773,85 +715,4 @@ export function registerLbbTools(server, client, options = {}) {
             }, { dryRun: args.dry_run });
         });
     });
-    server.registerTool("lbb_branch", {
-        description: "Branch lifecycle. Actions: create (fork a new branch off from_branch — the tool's `branch` argument names the NEW branch) and merge (validate-then-merge: replay from_branch's post-fork commits onto the scoped target branch — its fork parent — as ONE commit with event ids preserved; SHACL-validates the would-be merged state first and refuses with the report on violations; a fact superseded on the target after the fork wins over the branch's version, reported as a supersedure_race conflict; delete_source consumes the merged branch).",
-        inputSchema: {
-            action: z
-                .enum(["create", "merge"])
-                .describe("create = fork a new branch; merge = replay a child branch onto its fork parent"),
-            from_branch: z
-                .string()
-                .describe("create: the branch to fork from; merge: the child branch whose commits are replayed"),
-            validate: z
-                .boolean()
-                .optional()
-                .describe("merge only: refuse on SHACL violations of the would-be merged state (default true)"),
-            delete_source: z
-                .boolean()
-                .optional()
-                .describe("merge only: delete every object under the merged branch after success"),
-            ...graphScope,
-        },
-        annotations: MUTATING,
-    }, ({ action, from_branch, validate, delete_source, graph, branch }) => run(client, `lbb_branch.${action}`, "standard", () => {
-        const target = scoped(client, graph, branch);
-        if (action === "create")
-            return target.createBranch({ from_branch });
-        return target.mergeBranch({
-            from_branch,
-            validate: validate ?? true,
-            delete_source: delete_source ?? false,
-        });
-    }));
-    server.registerTool("lbb_observe", {
-        description: "Remember a conversation: store the turns verbatim as an EPISODE evidence entity, then anchor + gate the supplied facts on an observe branch (LLM extraction cannot poison the main graph). Facts with both endpoints already in the graph are anchored; unanchored facts need confidence >= 0.8 to mint new entities, else they come back needs_review. auto_merge merges the branch onto the scoped branch when SHACL validation is clean (the validate-then-merge). Server flag-gated (--enable-observe). This build takes caller-extracted facts (each with a structured triplet); bare statements come back needs_review.",
-        inputSchema: {
-            session_id: z
-                .string()
-                .describe("Caller's conversation id (drives the default observe branch name)"),
-            turns: z
-                .array(z.object({
-                role: z.string().describe("user | assistant | tool"),
-                content: z.string(),
-                name: z.string().optional(),
-                ts: z.string().optional().describe("RFC 3339 timestamp"),
-            }))
-                .min(1)
-                .describe("The conversation slice to remember (stored verbatim)"),
-            source: z
-                .string()
-                .optional()
-                .describe("Source label, e.g. support-bot"),
-            facts: z
-                .array(z.object({
-                fact: z.string().describe("Natural-language statement"),
-                confidence: z.number().optional().describe("0..1 (default 0.9)"),
-                triplet: jsonObjectSchema
-                    .optional()
-                    .describe("Structured form {source:{type,name}, relation, target:{type,name}} — required for the fact to commit"),
-            }))
-                .optional()
-                .describe("Caller-extracted candidate facts; omit with extract:false to store the episode only"),
-            extract: z
-                .boolean()
-                .optional()
-                .describe("false = store the episode only (default true)"),
-            observe_branch: z
-                .string()
-                .optional()
-                .describe("Branch for the facts (default observe-<hash12(session_id)>)"),
-            auto_merge: z
-                .boolean()
-                .optional()
-                .describe("Merge onto the scoped branch when validation is clean"),
-            ...graphScope,
-        },
-        annotations: MUTATING,
-    }, ({ session_id, turns, source, facts, extract, observe_branch, auto_merge, graph, branch, }) => run(client, "lbb_observe", "standard", () => scoped(client, graph, branch).observe({
-        episode: { turns, session_id, source },
-        extract: extract ?? true,
-        extraction: { byo_completion: (facts ?? []) },
-        branch: observe_branch,
-        auto_merge: auto_merge ?? false,
-    })));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@littlebigbrain/mcp",
-  "version": "0.5.2",
+  "version": "0.7.0",
   "description": "MCP server for little big brain: search, graph queries, and data import",
   "license": "Apache-2.0",
   "repository": {
@@ -52,7 +52,7 @@
     "test:coverage": "npm run clean:test && tsc -p tsconfig.test.json && node --test --experimental-test-coverage --test-coverage-include=test-dist/*.js --test-coverage-exclude=test-dist/*.test.js --test-coverage-exclude=test-dist/stdio.js --test-coverage-exclude=test-dist/test-support.js --test-coverage-lines=90 --test-coverage-branches=70 --test-coverage-functions=85 \"test-dist/**/*.test.js\""
   },
   "dependencies": {
-    "@littlebigbrain/client": "^0.13.2",
+    "@littlebigbrain/client": "^0.15.0",
     "@modelcontextprotocol/sdk": "^1",
     "zod": "^3"
   },