okf 1.7.0 → 1.8.0

data/lib/okf/server/graph.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rack/utils"
+
 module OKF
   module Server
     # Renders an OKF::Bundle::Graph as the interactive graph page served by
@@ -40,7 +42,12 @@ module OKF
       # fetches a concept's raw markdown and metadata fragment from — relative so
       # the page works whether served at "/" or mounted under a Rails prefix.
       # +embed+ is the render-mode payload (nil = server mode); see the class doc.
-      def initialize(graph, title: nil, link: nil, layout: "cose", node_endpoint: "node", meta_endpoint: "node/meta", embed: nil)
+      # +siblings+/+self_slug+/+hub_path+ carry the hub's bundle switcher into the
+      # page (server mode only). nil — the standalone-server and `okf render`
+      # default — injects an empty SIBLINGS, so the switcher never appears in a
+      # single bundle or a static file.
+      def initialize(graph, title: nil, link: nil, layout: "cose", node_endpoint: "node", meta_endpoint: "node/meta", embed: nil,
+                     siblings: nil, self_slug: nil, hub_path: nil)
         @graph = graph
         @title = title
         @link = link
@@ -48,6 +55,9 @@ module OKF
         @node_endpoint = node_endpoint
         @meta_endpoint = meta_endpoint
         @embed = embed
+        @siblings = siblings
+        @self_slug = self_slug
+        @hub_path = hub_path
       end
 
       def render
@@ -102,6 +112,20 @@ module OKF
         json_for_script(@embed)
       end
 
+      # The hub switcher's data: the other bundles (empty when standalone/static),
+      # this bundle's slug, and the hub root — all </script>-escaped like the rest.
+      def siblings_json
+        json_for_script(@siblings || [])
+      end
+
+      def self_slug_json
+        json_for_script(@self_slug)
+      end
+
+      def hub_path_json
+        json_for_script(@hub_path)
+      end
+
       # JSON-encode for safe embedding in an inline <script>: escaping every `<` to
       # its JSON unicode escape neutralizes </script>, <!-- and <script in one
       # stroke, and the result stays valid JSON *and* JavaScript.
@@ -120,8 +144,10 @@ module OKF
         end
       end
 
+      # Rack's, not a hand-rolled one — this output goes into attributes
+      # (`href="…"`), so the escape set is load-bearing rather than cosmetic.
       def html_escape(str)
-        str.to_s.gsub("&", "&amp;").gsub('"', "&quot;").gsub("<", "&lt;").gsub(">", "&gt;")
+        Rack::Utils.escape_html(str.to_s)
       end
     end
   end

data/lib/okf/server/hub.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "rack"
+
+require "okf/server/app"
+
+module OKF
+  module Server
+    # Multiplexes N bundles behind one server. Each bundle is mounted at
+    # /b/<slug>/ and served by its own OKF::Server::App; `/` redirects to the
+    # default bundle (explicitly chosen, or the first), or shows an empty-state
+    # page when none are registered. The graph page is already mount-relative (its fetch endpoints
+    # are relative), so hosting under a prefix needs only a clean PATH_INFO strip
+    # here plus a trailing-slash redirect. Part of the shell — it is a Rack app.
+    #
+    #   GET /               302 -> /b/<default>/   (empty-state page when no bundles)
+    #   GET /b/             the bundle index — every hosted bundle, default marked
+    #   GET /b/<slug>       301 -> /b/<slug>/      (query string preserved)
+    #   GET /b/<slug>/...   delegated to that bundle's App (the prefix stripped)
+    #   GET (unknown slug)  404 as a page listing the hosted bundles — a stale
+    #                       bookmark after a rename gets a way home, not bare text
+    #
+    # +bundles+ is an ordered array of Hub::Bundle (slug, folder, title). Apps are
+    # built up front, each carrying the *other* bundles as siblings so the in-page
+    # switcher can jump between them; static `okf render` files get no siblings and
+    # so cannot switch.
+    class Hub
+      MOUNT = "/b"
+
+      # One hosted bundle: its +slug+ (unique mount key), the on-disk +folder+, and
+      # its display +title+.
+      Bundle = Struct.new(:slug, :folder, :title)
+
+      # Shared style for the hub's own pages (empty landing, /b/ index, 404) —
+      # self-contained and theme-aware, no external requests, in keeping with the
+      # graph page's own no-CDN-at-rest rule.
+      STYLE = <<~CSS
+        body{margin:0;min-height:100vh;display:grid;place-items:center;background:#f4f5f7;color:#1f2328;font:15px/1.5 system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+        main{max-width:34rem;width:calc(100% - 4rem);padding:2rem}h1{font-size:1.3rem;margin:0 0 .5rem}
+        code{background:#e6e8eb;padding:.15rem .4rem;border-radius:.35rem}
+        ul.bundles{list-style:none;margin:1rem 0 0;padding:0}
+        ul.bundles li{padding:.45rem 0;border-top:1px solid #e6e8eb;display:flex;justify-content:space-between;gap:1rem;align-items:baseline}
+        ul.bundles a{color:inherit;font-weight:600;text-decoration:none}ul.bundles a:hover{text-decoration:underline}
+        .meta{color:#63697a;font-size:.85rem;white-space:nowrap}
+        .def{margin-left:.5rem;padding:.05rem .45rem;border-radius:99px;background:#e6e8eb;font-size:.75rem}
+        @media(prefers-color-scheme:dark){body{background:#111318;color:#eceef1}code,.def{background:#232833}
+        ul.bundles li{border-color:#2a2e36}.meta{color:#9aa0aa}}
+      CSS
+
+      # The hosted bundles in mount order, and the one `/` redirects to — so a
+      # caller printing the mount table asks the hub instead of re-deriving the
+      # rule and drifting from it.
+      attr_reader :bundles, :default
+
+      # The first bundle is the one `/` redirects to — the registry hands them over
+      # in its own order, where first *is* the default (`okf registry default`
+      # moves an entry to the front), and an ephemeral run takes the dirs as typed.
+      def initialize(bundles, layout: "cose")
+        @bundles = bundles
+        @default = bundles.first
+        @apps = build_apps(layout)
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        return not_found unless request.get?
+
+        path = request.path_info
+        query = request.query_string.to_s
+        # Everything this class *emits* must carry the prefix a host mounted it
+        # under; PATH_INFO is already relative to it.
+        base = env["SCRIPT_NAME"].to_s
+        return landing(base, query) if [ "", "/" ].include?(path)
+        return html(200, index_page(base)) if [ MOUNT, "#{MOUNT}/" ].include?(path)
+
+        slug, rest = split(path)
+        app = slug && @apps[slug]
+        return html(404, missing_page(base, path)) unless app
+        return redirect("#{base}#{MOUNT}/#{slug}/", 301, query) if rest.empty?
+
+        app.call(mounted(env, slug, rest))
+      end
+
+      private
+
+      # Split "/b/<slug>/rest" into [ "<slug>", "/rest" ] (rest "" for just
+      # "/b/<slug>"). A path outside the mount prefix, or an empty slug, is [ nil, nil ].
+      def split(path)
+        prefix = "#{MOUNT}/"
+        return [ nil, nil ] unless path.start_with?(prefix)
+
+        slug, slash, rest = path[prefix.length..-1].partition("/")
+        return [ nil, nil ] if slug.empty?
+
+        [ slug, slash + rest ]
+      end
+
+      # Concept counts for the listing pages, computed once. Bundle#graph is not
+      # memoized (App memoizes its own), and /b/ and every stray 404 render this
+      # list — without the memo a 404 flood reparses every hosted bundle.
+      def counts
+        @counts ||= @bundles.each_with_object({}) do |bundle, memo|
+          memo[bundle.slug] = bundle.folder.graph(minimal: true).nodes.size
+        end
+      end
+
+      # A copy of env aimed at the bundle's App: the /b/<slug> prefix moves from
+      # PATH_INFO to SCRIPT_NAME. The App ignores SCRIPT_NAME (its endpoints are
+      # relative), but keeping the split correct leaves the env well-formed.
+      def mounted(env, slug, rest)
+        env.merge(
+          "SCRIPT_NAME" => "#{env["SCRIPT_NAME"]}#{MOUNT}/#{slug}",
+          "PATH_INFO" => rest
+        )
+      end
+
+      def build_apps(layout)
+        @bundles.each_with_object({}) do |bundle, apps|
+          apps[bundle.slug] = App.new(
+            bundle.folder,
+            title: bundle.title,
+            layout: layout,
+            siblings: siblings_of(bundle),
+            self_slug: bundle.slug,
+            hub_path: "/"
+          )
+        end
+      end
+
+      # Every other bundle, as { slug:, title:, path:, default: } — what the
+      # switcher lists; default marks the bundle `/` opens. The path is
+      # *relative* because these are baked into each App at boot, before any
+      # request names a SCRIPT_NAME: every page lives at <prefix>/b/<slug>/, so
+      # "../<other>/" reaches its sibling under any mount and needs no prefix.
+      def siblings_of(bundle)
+        @bundles.reject { |other| other.slug == bundle.slug }
+                .map { |other| { slug: other.slug, title: other.title, path: "../#{other.slug}/", default: other.equal?(@default) } }
+      end
+
+      def landing(base, query = "")
+        return redirect("#{base}#{MOUNT}/#{@default.slug}/", 302, query) if @default
+
+        html(200, page("OKF · no bundles", <<~BODY))
+          <h1>No bundles registered</h1>
+          <p>Register one with <code>okf registry set &lt;dir&gt;</code>, then restart <code>okf server</code>.</p>
+        BODY
+      end
+
+      # The /b/ index — every hosted bundle with its mount link, concept count,
+      # and the default marked. The browser counterpart of `okf registry`.
+      def index_page(base)
+        page("OKF · bundles", "<h1>Bundles</h1>#{bundle_list(base)}")
+      end
+
+      # The 404 for a slug the hub does not host: name what was asked for, then
+      # list what exists — a stale bookmark after a rename gets a way home.
+      def missing_page(base, path)
+        body = "<h1>No bundle here</h1><p><code>#{escape(path)}</code> does not match a hosted bundle.</p>"
+        body += bundle_list(base) unless @bundles.empty?
+        page("OKF · not found", body)
+      end
+
+      def bundle_list(base)
+        rows = @bundles.map do |bundle|
+          count = counts[bundle.slug]
+          badge = bundle.equal?(@default) ? %(<span class="def">default</span>) : ""
+          %(<li><a href="#{escape(base)}#{MOUNT}/#{escape(bundle.slug)}/">#{escape(bundle.title)}</a>) +
+            %(<span class="meta">#{escape(bundle.slug)} · #{count} concepts#{badge}</span></li>)
+        end
+        %(<ul class="bundles">#{rows.join}</ul>)
+      end
+
+      def page(title, body)
+        <<~HTML
+          <!doctype html><html lang="en"><head><meta charset="utf-8">
+          <meta name="viewport" content="width=device-width,initial-scale=1">
+          <title>#{escape(title)}</title>
+          <style>#{STYLE}</style>
+          </head><body><main>#{body}</main></body></html>
+        HTML
+      end
+
+      def html(status, body)
+        [ status, { "content-type" => "text/html; charset=utf-8" }, [ body ] ]
+      end
+
+      # Keep the query string across redirects — `/b/notes?view=files` must land
+      # on the Files view, not reset to the default graph.
+      def redirect(location, status, query = "")
+        location += "?#{query}" unless query.empty?
+        [ status, { "location" => location, "content-type" => "text/plain; charset=utf-8" }, [ "" ] ]
+      end
+
+      def not_found
+        OKF::Server::App.not_found
+      end
+
+      # Rack's, not a fourth hand-rolled one: the server layer had three, each
+      # escaping a different set — App's left `"` alone, which is safe only
+      # while nothing interpolates it into an attribute. Rack::Utils covers
+      # & " ' < > and ships with the dependency we already have.
+      def escape(str)
+        Rack::Utils.escape_html(str.to_s)
+      end
+    end
+  end
+end

data/lib/okf/skill/SKILL.md

@@ -150,7 +150,7 @@ Read the referenced playbook before executing — it *is* the procedure.
 | `consume`  | Use    | use the bundle as context for a task | [playbooks/consume.md](playbooks/consume.md) |
 | `curate`   | Curate | structural upkeep as it stands: validate + lint + loose | [playbooks/curate.md](playbooks/curate.md) |
 | `doctor`   | Setup  | install and verify the CLI, then doctor the bundle | [playbooks/doctor.md](playbooks/doctor.md) |
-| `<okf-cli-verb>` | Read | validate, lint, loose, index, catalog, files, tags, types, stats, graph, server, render, skill | `okf <verb> --help` + [reference/cli.md](reference/cli.md) |
+| `<okf-cli-verb>` | Read | validate, lint, loose, index, catalog, files, tags, types, stats, graph, server, render, registry, skill | `okf <verb> --help` + [reference/cli.md](reference/cli.md) |
 
 Two boundaries worth keeping sharp: `curate` is structural upkeep only — when
 the *content* no longer matches reality, that is `maintain` — and `doctor` is

data/lib/okf/skill/playbooks/search.md

@@ -21,6 +21,9 @@ reads, and full bodies are read last, and only the winners.
    for patterns like `err_[a-z]+_409`). Scope it with what the map taught you:
    `--area billing`, `--type Decision`, `--tag idempotency`, `--in body`.
    Matches rank by where they hit, and the snippet often *is* the answer.
+   When the answer may live in another registered bundle, span them — leading
+   @slugs (`okf search @handbook @notes <terms>`) or `@all` for every registered
+   one — and read the per-row bundle slug before following an id home.
 4. **Read only the winners.** A match row's `id` is its file: `<dir>/<id>.md`.
    Read that file — not its folder, never the whole tree. Follow its links (§5)
    one hop at a time; check `log.md` when freshness matters.

data/lib/okf/skill/reference/cli.md

@@ -38,9 +38,36 @@ difference between a few hundred bytes and hundreds of KB, since the per-item ro
 (`listing`) dominate at scale. `okf index --no-body` is shorthand for dropping just
 `body`.
 
+**Every output names its bundle.** Two keys, one meaning each: `bundle` is
+always a directory, `slug` always a registry slug. Name a bundle by `@slug` and
+the answer comes back in that identity — `OKF lint — @handbook (/path/to/one)`,
+and `{ "bundle": "/path/to/one", "slug": "handbook", … }` — so an agent holding
+several bundles never has to remember which invocation produced which output.
+A bundle named by path carries no `slug`: it may not have one, and inventing a
+name it was never given would imply a registration that does not exist.
+
+**@slug — point any verb at a registered bundle.** Wherever a `<dir>` goes,
+`@slug` names a bundle registered via `okf registry set`, and bare `@` the
+registry's default. They resolve through `$OKF_HOME` (default `~/.okf`) — the
+single lever on which registry *any* verb reads, and it names exactly one, with
+no fallback behind it. The slug is normalized as registration
+normalized it — `@One` finds the bundle from dir `One` — but never to a
+placeholder: `@***` names nothing, not a bundle. An unknown slug, a
+registered-but-gone directory, or a malformed registry file is a usage error
+(exit 2) whose message names the registry file consulted and the next move —
+an explicit ask fails hard, never silently skipped. So `okf lint @handbook`
+or `okf index @` work from any directory, no path recall needed.
+
 **Exit codes:** `0` success · `1` non-conformant bundle (or a `lint --fail-on`
 threshold crossed) · `2` usage error. `graph`, `server`, and `render` are best-effort
-(§9): a file with invalid frontmatter is skipped and noted on stderr, never fatal.
+(§9): a file the reader cannot use — frontmatter that will not parse, or a file it
+cannot open at all — is skipped and noted on stderr, never fatal. The note counts;
+`validate` names each file and why.
+
+**One bundle per verb, except two.** Only `search` merges several bundles and only
+`server` mounts them; hand a second bundle to any other verb — two dirs, two refs,
+or a mix — and it is a usage error (exit 2), never a silent answer about the first.
+To ask the same question of several bundles, ask `search`, or ask each in turn.
 
 ## validate — the hard gate (§9)
 
@@ -119,16 +146,55 @@ expressions with `--regexp`/`-e` (an invalid pattern is a usage error, exit 2).
 body); the shared `--type/--area/--tag` filters narrow the candidates *first*,
 so a search scoped by what `index` taught you stays surgical.
 
+**Search spans bundles.** Leading @refs pick several registered bundles
+(`okf search @handbook @notes auth`); **`@all`** is the ref that means every one.
+The per-bundle rankings merge — scores are absolute term weights, so they
+compare across bundles — and each row carries its bundle's slug. This is the
+cross-bundle retrieval the in-page search does not have: one question, every
+bundle you keep. <!-- rule:okf-search-all -->
+
+`@all` is a ref, not a flag, which is what keeps the grammar single: slot 1 is
+always a bundle identity, so a directory there is a directory and nothing can
+flip it into a term. Being a ref, it is normalized like one — `@ALL` and `@All`
+name every bundle just as `@One` names the bundle registered from dir `One`. It composes accordingly — `@all @docs` expands and dedupes
+(all ⊇ docs), needing no diagnostic. **Asking for everything tolerates gaps;
+naming one bundle demands it**: `@all` skips a bundle whose directory has
+vanished with a note on stderr, while `@docs` fails hard. `@all` is only
+`search`'s: every other verb answers about one bundle, so it refuses `@all` by
+name rather than letting the answer depend on how many bundles you happen to
+have registered. `all` is reserved as a slug — a directory named `all/` registers
+as `all-2`, `--as all` is refused, and an `all` row already in the registry file
+(hand-typed, or written before the name was reserved) is read as `all-2` rather
+than taken as grounds to reject the file — so `@all` is never ambiguous, and the
+reservation never strands a registry it inherited. **The read normalizes every
+slug** the same way registration would, so a hand-typed `"slug": "My Docs"` lists
+and resolves as `my-docs`; an entry the listing shows is always an entry `@slug`,
+`rename`, and `default` can name.
+
+`--fields` projects the shape the mode actually emits: `slug` is available in
+registry mode, and a usage error naming the real fields on a path-named search,
+which has no slug to give. Two sharp edges: every *leading* @-arg is taken as a ref, so a literal @-term
+(`@babel/core`, a Ruby `@ivar`) needs a non-@ term before it or `-e '\@term'` —
+the CLI notes both traps on stderr — and any ref, even one, switches the JSON
+envelope (next paragraph).
+
 Rows rank by **where** they hit — title 5, id 4, tags 3, type/description 2,
 body 1, summed over matched fields — and carry one bounded context snippet from
 the strongest match that needs context (description or body). Deliberately not
 fuzzy: the consuming agent is the fuzzy layer — when terms miss, learn the
 bundle's vocabulary from `tags`/`types` and re-ask in its own words, rather
 than hammering synonyms. Advisory read: **exit 0 even with zero matches**.
-JSON: `{ bundle, query, count, matches: [{ id, title, type, area, tags,
-matched, score, snippet }] }`, projectable with `--fields/--except`. The
-retrieval procedure that puts this verb in sequence — map first, finder second,
-bodies last — is the [search playbook](../playbooks/search.md).
+JSON, plain-dir mode: `{ bundle, query, count, matches: [{ id, title, type,
+area, tags, matched, score, snippet }] }`. Registry mode — any leading @ref,
+`@all` among them — swaps the envelope: `{ bundles: [{ slug, dir }, …],
+query, count, matches: [{ slug, id, … }] }`; a parser must branch on which form
+it called. The head maps each slug to its dir once, so a row resolves to
+`<dir>/<id>.md` without a second lookup and without repeating a path per row.
+Both are projectable with `--fields/--except`, and projection is literal — when
+merging bundles, put `slug` in your `--fields` list or the row label drops and
+same-id concepts from different bundles become indistinguishable. The retrieval procedure that puts this verb in sequence —
+map first, finder second, bodies last — is the
+[search playbook](../playbooks/search.md).
 
 ## index — the progressive-disclosure map (§6)
 
@@ -216,6 +282,56 @@ just-appended entry shows without a restart. `?view=index` jumps straight to
 the Indexes tab. It is a Rack app, so the same server can be mounted in a
 host app (e.g. Rails).
 
+**Hosting many bundles (the hub).** `okf server` takes zero or more dirs.
+One dir is the classic single bundle at `/`. Two or more mounts each under
+`/b/<slug>/` behind a hub, `/` redirects to the default, and `/b/` is a
+self-contained **bundle index** (every hosted bundle, concept counts, default
+marked — the browser counterpart of `okf registry`). An unknown slug 404s as a
+page listing the hosted bundles, so a stale bookmark after a rename gets a way
+home. With **no** dir it serves the *persistent registry*, a plain JSON file
+under `$OKF_HOME` (default `~/.okf`), managed by the
+`okf registry` umbrella — like git's `remote` family, and split by what each
+verb keys on. **Entry verbs** take a path: `okf registry set <dir>` adds it
+(slug from the basename, or `--as`, which errors on a collision; `--default`
+puts it first), and because the entry is keyed by path, `set` on an
+already-registered dir updates it in place — refreshing its title, and renaming
+it when `--as` is given. `okf registry del <dir|@slug>` removes one — by name, so an entry whose
+directory is already gone still deletes. Slug *or* dir, never both readings at
+once: an argument with a `/` in it names a location and only a location, so
+`del ./notes` refuses when no entry points there rather than stripping to the
+slug `notes` and deleting a bundle somewhere else entirely.
+<!-- rule:okf-registry-del-path-or-slug -->
+**Slug verbs** take the name — bare, or as an `@slug`: `okf registry default <@slug>`
+chooses which bundle `/` opens **by moving that entry to the front**, and
+`okf registry rename <@slug> <new>` renames a slug (mount path and switcher
+name) — `<new>` is a name being minted, so it is never a ref. The registry is ordered and **the first entry still on disk is the
+default** — that is the whole rule, so the first bundle you register is the
+default until you move another one, a rename keeps its position, and a `del`
+promotes whatever is next. A vanished directory is stepped over (the server
+cannot open one, so starring it would name a bundle `/` never serves), and
+`registry default @slug` refuses one outright — the same refusal `registry set`
+gives a directory that is not there. The file is hand-editable and reorders
+visibly, which is the point: there is no stored slug that can dangle.
+<!-- rule:okf-registry-default-position -->
+`okf registry list` (or a bare
+`okf registry`) stars the default and flags vanished dirs `(missing)` — the
+server skips those with a note; `--json` answers
+`{ registry: <file>, count, bundles: [{ slug, title, dir, mount, default,
+missing }] }`, naming the file it read so a `$OKF_HOME` mismatch is visible. The hub roster is a
+**boot-time snapshot**: restart `okf server` after registry changes. Behind a
+hub the page gains a **bundle switcher** (⌘/Ctrl-K, or the rail button with its
+bundle-count badge): the current bundle is pinned, the default chipped; ⏎
+opens, ⌘/Ctrl-⏎ opens a new tab, and the current view carries over. Switching
+is a server-only affordance — a static `render` file has no siblings and shows
+none.
+
+**Bundle-less run.** Register bundles once, then `okf server` (no dir) hosts
+them all with the registry's first entry still on disk at `/` — the way to keep
+several bundles a keystroke apart without re-passing paths.
+`okf server @a @b` serves a registry subset, each mounted under its registered
+slug — but as with any dirs-given run, the *first argument* lands at `/`; the
+registry's own order applies only to the bundle-less run.
+
 **Trust boundary:** the page renders each fetched markdown body through
 DOMPurify and escapes everything it inlines (every `<` in the graph data is
 escaped, so it cannot break out of its `<script>`), but it still loads its
@@ -242,10 +358,12 @@ you trust.
 
 ## graph — the raw structure
 
-Prints the node/edge graph. `--json` emits a machine-readable dump (`nodes` with
+Prints the node/edge graph. `--json` emits a machine-readable dump — the
+`bundle`/`slug` head every view carries, then `nodes` (with
 `id`/`type`/`title`/`description`/`tags` **and, by default, every `body`** — the
-part that dominates the bytes on a real bundle — plus `edges`) you can pipe into
-other analysis. To *plan* a traversal, structure is all you need: `--no-body`
+part that dominates the bytes on a real bundle) plus `edges` — you can pipe into
+other analysis. A concept with a missing *or blank* `type` indexes under
+`Untyped`: §9.2 rejects both identically, so both land in one bucket. To *plan* a traversal, structure is all you need: `--no-body`
 drops each node's body, and `--minimal` ships only `id`/`title` plus the type/tag
 indexes — the lean shape the `server` page boots from. Reach for the full dump
 only when the task truly consumes every body; for one question, the

data/lib/okf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OKF
-  VERSION = "1.7.0"
+  VERSION = "1.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: okf
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Rodrigo Serradura
@@ -76,9 +76,11 @@ files:
 - lib/okf/markdown/frontmatter.rb
 - lib/okf/markdown/links.rb
 - lib/okf/path.rb
+- lib/okf/registry.rb
 - lib/okf/server/app.rb
 - lib/okf/server/graph.rb
 - lib/okf/server/graph/template.html.erb
+- lib/okf/server/hub.rb
 - lib/okf/server/runner.rb
 - lib/okf/skill.rb
 - lib/okf/skill/SKILL.md