okf-mcp 1.0.0 → 1.2.0

data/lib/okf/mcp/memory_backend.rb

@@ -10,7 +10,7 @@ module OKF
     # deliberately no disk cache here — the process is the cache; disk-side
     # state is okf-sqlite3's territory.
     class MemoryBackend
-      FILTER_KEYS = %i[type tag dir status].freeze
+      FILTER_KEYS = %i[type tag dir status trust].freeze
 
       # How many prepared corpora to hold at once, most-recently-used first.
       # It used to be unbounded, keyed on the queried subset — a long-lived
@@ -168,17 +168,21 @@ module OKF
         end
       end
 
+      # The kernel's one row predicate (Bundle::RowFilter), not a local copy:
+      # this seam diverged three recorded times, and the fix each time was to
+      # share the rule. This layer keeps only its own argument spelling —
+      # blanks mean "no filter" (an MCP client filling every optional property
+      # with "" is routine), and ""/"/" fold onto the root before the shared
+      # dir rule sees them.
       def matches?(row, filters)
-        FILTER_KEYS.all? do |key|
+        wants = {}
+        FILTER_KEYS.each do |key|
           wanted = filters[key]
-          next true if OKF.blank?(wanted)
+          next if OKF.blank?(wanted)
 
-          case key
-          when :tag then Array(row[:tags]).map { |tag| Filters.fold(tag) }.include?(Filters.fold(wanted))
-          when :dir then Filters.under_dir?(row[:dir], wanted)
-          else Filters.fold(row[key]) == Filters.fold(wanted)
-          end
+          wants[key] = key == :dir ? Filters.normalize_dir(wanted) : wanted
         end
+        Bundle::RowFilter.matches?(row, **wants)
       end
 
       # What the residency cache watches: every markdown file with its mtime

data/lib/okf/mcp/output_schemas.rb

@@ -62,7 +62,12 @@ module OKF
             bundles: ROWS,
             total: COUNT,
             results: ROWS,
-            unparseable: UNPARSEABLE
+            unparseable: UNPARSEABLE,
+            # Present only when "*" or a group forgave a vanished bundle —
+            # conditional, so never required; slugs, not rows. Omitting it
+            # entirely is how a real field failed result validation the first
+            # time it appeared.
+            skipped: { type: "array", items: SLUG }
           },
           required: %w[query engine bundles total results]
         },
@@ -70,6 +75,13 @@ module OKF
           properties: { bundle: SLUG, total: COUNT, concepts: ROWS, unparseable: UNPARSEABLE },
           required: %w[bundle total concepts]
         },
+        # `dangling` is always present (empty when nothing misses): an absent
+        # list would read as "not checked", which is the one thing an
+        # inventory must never say by accident.
+        "references" => {
+          properties: { bundle: SLUG, total: COUNT, references: ROWS, dangling: ROWS, unparseable: UNPARSEABLE },
+          required: %w[bundle total references dangling]
+        },
         # `total` is entries across every log file and `files` how many files
         # they came from — two different counts, both named, because one
         # standing for the other is what let an unbounded 119 KB answer read
@@ -78,6 +90,30 @@ module OKF
           properties: { bundle: SLUG, total: COUNT, files: COUNT, logs: ROWS },
           required: %w[bundle total files logs]
         },
+        # Two shapes, like lint's: the plain inverted index (`tags`) and the
+        # `by` regrouping (`groups`). Only what both carry is required.
+        "tags" => {
+          properties: {
+            bundle: SLUG, total: COUNT, tags: ROWS,
+            by: { type: "string" }, groups: ROWS,
+            unparseable: UNPARSEABLE
+          },
+          required: %w[bundle total]
+        },
+        "types" => {
+          properties: { bundle: SLUG, total: COUNT, types: ROWS, unparseable: UNPARSEABLE },
+          required: %w[bundle total types]
+        },
+        "stats" => {
+          properties: {
+            bundle: SLUG,
+            concepts: COUNT, dirs: COUNT, top_dirs: COUNT, concept_types: COUNT,
+            cross_links: COUNT, distinct_tags: COUNT,
+            by_type: { type: "object" }, by_dir: { type: "object" }, by_top_dir: { type: "object" },
+            unparseable: UNPARSEABLE
+          },
+          required: %w[bundle concepts dirs top_dirs concept_types cross_links distinct_tags by_type by_dir by_top_dir]
+        },
         "validate" => {
           properties: {
             bundle: SLUG,

data/lib/okf/mcp/prompts/search.md

@@ -1,7 +1,7 @@
 # Prompt: search — retrieve knowledge without paying for the whole bundle
 
 Retrieval matters as much as curation: a bundle nobody can query cheaply is
-dead weight. The discipline is progressive disclosure (spec §6): every step
+dead weight. The discipline is progressive disclosure (spec §8): every step
 pays a few hundred bytes to decide what the next step reads, and full bodies
 are read last, and only the winners.
 
@@ -49,7 +49,7 @@ are read last, and only the winners.
    an id home.
 4. **Read only the winners.** `read_concept` takes a result row's exact `id`
    and returns the file verbatim — that concept, not its folder, never the
-   whole tree. Follow its links (§5) one hop at a time; check `log` when
+   whole tree. Follow its links (§6) one hop at a time; check `log` when
    freshness matters.
 5. **Answer, then surface the friction.** Cite the concept ids you used. This
    server never writes — if the answer was missing, stale, or needlessly hard