durable local memory for coding agents.
kb keeps sources, notes, plans, and repository context beside your code in ordinary Markdown and Git. Agents can retrieve an exact identifier, filter metadata and tags, search locally by words or meaning, follow explicit backlinks and typed relations, and inspect the Git history behind a note. The TypeScript SDK reuses one live vault scan across queries, while bounded DAG workflows let independent retrieval steps run in parallel.
The vault stays independent from application code. Markdown and repository Git history are authoritative; the QMD search database, graph views, catalog, and Git index are derived and replaceable.
bun add --global github:hraness/kb#v0.11.0the command-line tool runs with Bun. exact search, metadata filters, repository context, links, Git provenance, capture, and PDF conversion need no hosted service. hybrid search adds QMD's local keyword and embedding index. graph and Git evidence stay separate from the primary exact and text relevance rank.
Give coding agents durable, searchable memory beside the repository with plain Markdown, Git history, local hybrid search, explicit relationships, and a TypeScript SDK.
Coding agents lose useful context when a session ends. The next agent can search the code again, but it cannot recover a source that was never saved, a decision that stayed in chat, or the relationship between two notes that nobody recorded. Repeating that work costs time and produces inconsistent answers.
hraness/kb gives agents durable, repository-adjacent memory without making the application depend on a knowledge system. Sources, maintained notes, plans, and scope context stay in ordinary Markdown under Git. Agents can find an exact identifier, filter frontmatter and tags, search locally by words or meaning, follow backlinks and typed relations, and inspect the Git history behind a note. A reusable TypeScript API lets one agent session share that context across several queries.
hraness/kb turns source material into memory that agents can link and find again.
Rules that must govern an edit still belong in a scoped AGENTS.md file. KB is the pull-based knowledge plane for rationale, history, examples, evidence, plans, and neighboring decisions. It can explain an applicable AGENTS.md rule, but it does not override one or force the whole vault into every prompt.
The control plane stays on the repository path, while the knowledge plane remains an ordinary Markdown vault. Scope hubs are optional, and application code imports neither KB nor its indexes:
Conceptual control plane, KB vault, and derived views
repository/
├── AGENTS.md # inherited root rules
├── packages/parser/
│ ├── AGENTS.md # scoped rules and checks
│ └── src/
└── kb/
├── scopes/
│ └── packages-parser--94a91e4eddfa.md
├── articles/<slug>/ # captured evidence and assets
├── notes/ # maintained synthesis
├── plans/ # decisions and verification
├── riffs/ # voice-preserving source thought
└── index.md # regenerated catalog
authored Markdown + frontmatter + wikilinks + Git history
├── exact identifiers, metadata, tags, and prose
├── QMD keyword + vector retrieval # derived local index
├── backlinks, typed relations, and Git provenance
└── TypeScript sessions and workflows
Markdown and repository Git history are authoritative in this map. The catalog, graph views, QMD search database, and bounded Git index can be deleted and rebuilt. A search session scans the live vault once, then combines exact results with QMD keyword and vector results. It returns graph neighbors and Git provenance as separate evidence instead of letting either one silently change the primary relevance rank.
AGENTS.md belongs on the path to the code it governs. A root guide carries repository-wide policy; nested guides add the constraints owned by a package, product, or source boundary. Keep every load-bearing edit-time rule on that inherited path. If an edit would be wrong when the agent misses a sentence, that sentence does not belong only in KB. Agent docs hygiene explains how to keep that path scoped and checked.
KB holds material whose value depends on the question. A scope hub can explain why a parser rejects a tempting shortcut, link the plan that introduced the rule, preserve a source that supports it, and point to neighboring decisions. An agent pulls that prose when the task reaches the boundary. If a hub and an applicable guide disagree, the guide controls the edit and the hub needs repair.
A mapped hub declares optional frontmatter with type: agent-context and an exact repository-relative directory in scope. For packages/parser, the canonical hub at kb/scopes/packages-parser--94a91e4eddfa.md begins:
Optional parser scope hub
---
title: Parser context
type: agent-context
scope: packages/parser
---
# Parser contextIts guide at packages/parser/AGENTS.md carries the reciprocal marker <!-- kb:context scopes/packages-parser--94a91e4eddfa --> before its required # Contents and # Guidelines headings. This one-line link lets validation check both sides without loading the hub into every task.
kb agents identity <scope> emits the normalized scope, note ID and path, owning guide path, and exact marker without writing files. The canonical ID is scopes/<readable normalized slug>--<12-char SHA-256 prefix>. The bounded slug avoids mirroring a deep repository tree under scopes/, while the hash makes paths with the same leaf name, such as packages/parser and projects/parser, distinct. The full path remains in scope metadata. Moving a directory deliberately changes its identity, so the hub ID and reciprocal marker must change together.
kb context <path> --root kb --repo . returns the inherited guide chain from the repository root to the target and identifies the valid hubs mapped to that chain. It does not load hub prose. The agent receives the normative rules first, then opens the nearest useful hub only when the task needs its explanation.
From that hub, the agent can expand a bounded neighborhood with kb links, inspect backlinks, filter exact metadata, or use semantic search when vocabulary differs. The command is a routing aid, not an instruction loader for the whole vault. A small guide that needs no explanatory neighborhood can remain unmapped.
kb agents check validates both sides of every declared mapping: the hub type and exact scope, canonical slug-and-hash identity, reciprocal guide marker, and real guide and scope paths confined to the repository. Missing mappings on otherwise valid small guides are allowed. The check catches broken identity and unsafe paths; it cannot decide whether the prose is true or the rule is wise.
kb agents audit is advisory. It ranks individual guides and cumulative inherited context, then surfaces long bullets and exact duplicates for review. Length is not a correctness test: a long guide may encode necessary constraints, and a short one may be wrong. The audit identifies where attention may pay off without turning a word limit into policy.
This design direction did not begin with one recent proposal. Cognition's 2024 Devin release history described Knowledge that Devin could recall across future sessions by September 2024 and automatic Repo Knowledge from repository scans by November. On April 3, 2025, Devin 2.0 introduced Devin Wiki and Devin Search. Cognition launched the public DeepWiki service on May 5, then a DeepWiki Model Context Protocol server on May 22 for programmatic retrieval.
In April 2026, Andrej Karpathy published an LLM Wiki proposal with three layers: raw sources, an agent-maintained Markdown wiki, and an instruction schema. Its operations are ingest, query, and lint, with QMD suggested when the collection outgrows an index file. hraness/kb is not an implementation of Cognition's products, and the resemblance does not establish direct lineage. The sequence shows convergence on one pressure: useful reasoning must become a durable artifact before a session ends.
A knowledge base earns trust differently from a chat transcript. Its records need stable paths, reviewable changes, and a format that remains legible when the current agent is gone. Plain Markdown, YAML frontmatter, explicit wikilinks, and Git meet that bar with little codebase coupling. An agent can begin with index.md and ordinary file tools or use the KB commands, skills, and TypeScript API. Neither path requires a hosted database or a proprietary document format.
Directory names express editing authority without becoming a framework. Captured articles preserve what a source said. Notes hold current synthesis. Plans record intended work, evidence, and outcomes. Riffs preserve a speaker's claims and uncertainty. Scope hubs organize optional repository context. QMD and Git indexes live outside the authored graph and remain replaceable. The application under development does not need to import KB.
Durable reasoning needs inspectable evidence. kb clip can read a public URL, saved HTML, rendered page, or the page already open in an authenticated browser. The capture documentation defines layered extraction routes. A capture writes readable Markdown beside localized assets and capture.json, whose manifest records the source URL, attempted routes, chosen extractor, completeness state, counts, warnings, and artifact hashes. “Complete” describes the selected bounded surface, not every hidden branch or future version of the page.
PDFs use the same durable bundle for a local path or public HTTP(S) URL. kb pdf sends remote input through a DNS-pinned acquisition boundary that denies private networks, then removes sensitive URL parameters from saved provenance. Local and remote capture preserve the original bytes, infer headings from native layout, extract bounded images, and use local optical character recognition for scans and screenshots.
Capture a local or public remote PDF
kb pdf "/absolute/path/to/document.pdf" --output articles
kb pdf "https://example.com/document.pdf" --output articlesThe resulting bundle is evidence, not final interpretation. A maintained note can cite several captures, record disagreement, and change when later evidence warrants it. The sources stay available for audit. This boundary prevents an agent from silently replacing what a page said with what it now believes the page meant.
An identifier, title, alias, path, tag, or quoted phrase should not depend on an embedding. KB scans the current Markdown and ranks those exact matches first. kb list handles questions that are already structured. It parses frontmatter such as type, status, area, dates, aliases, and tags into bounded values. Repeated filters use AND semantics, dotted paths reach nested metadata, and stable path tie-breakers make the result reproducible. The vault does not need one global domain schema.
Exact, hybrid, and metadata retrieval
kb search "parser-v2" --root kb --mode exact
kb search "why does the parser reject this input?" --root kb \
--tag architecture --where status=active --json
kb list --root kb --where type=plan --where status=in-progress --sort area --jsonThe default search adds QMD, a local search engine for Markdown, for vocabulary that differs from the note. QMD combines keyword BM25 and vectors from its compact local embedding model. KB fuses the exact and QMD result orders, joins each hit back to live Markdown metadata, and explains which lane contributed. --mode exact, --mode keyword, and --mode semantic remain available when one signal fits the question. Metadata and tag filters apply to the live notes in every mode.
Backlinks, typed relations, and Git history answer different questions, so they stay outside the primary text rank. A search result can include a bounded graph neighborhood and recent commits for the returned notes as separate evidence. Git can also search commit messages and changed paths directly. This helps an agent distinguish why a note is relevant from how it is connected or when it changed.
A vector score does not mean that a passage is current, correct, or supported by its sources. Use hybrid search to find candidates, metadata to narrow them, links and Git provenance to inspect context, and the Markdown plus cited captures to verify the answer. QMD remains optional and local. Deleting its database does not delete knowledge.
A useful vault eventually contains ideas that recur across source boundaries. Keeping every occurrence as an isolated tag makes the pattern hard to inspect; moving all graph state into one generated file gives parallel agents a permanent merge conflict. KB uses a smaller convention. A reusable concept is an ordinary Markdown note with type: concept. A note stores only the typed outbound assertions it owns:
A source-owned typed relationship
---
type: note
tags:
- local-first
relations:
supports:
- notes/durable-agent-memory
contrasts-with:
- notes/conversation-history
---
# The write path
The local-first write path supports durable agent memory because ...Predicates use lower-kebab-case and targets use exact vault-root note IDs. The explanatory sentence matters: frontmatter makes an assertion queryable, but it does not supply its reason. Inverse edges, backlinks, transitive paths, and shared-concept neighborhoods are derived at read time. KB does not inject them into another note.
kb percolate <note> reviews repeated tags without concept notes, notes that share ideas but lack a contextual edge, exact unlinked title or alias mentions, and relationship-hygiene findings. Each result carries inspectable support; relationship candidates count independent shared tags or concept neighbors, not both endpoints of one match. The command is read-only. An agent opens the cited notes, promotes only concepts likely to be reused, and authors a relationship only when the prose or evidence establishes it:
Review, create, and relate without a central graph file
kb percolate notes/write-path --root kb --limit 25 --json
kb note create notes/durable-agent-memory \
--root kb --title "Durable agent memory" --type concept \
--body-file /path/to/reviewed-concept.md
kb relation add notes/write-path supports notes/durable-agent-memory \
--root kbWikilinks answer a precise question: which relationships did an author state in prose? The scanner resolves exact and relative targets or a unique basename, and reports broken or ambiguous links rather than guessing. Backlinks reverse those resolved edges at read time.
KB keeps the current surface specific: kb graph reports the resolved whole-vault structure, kb backlinks reverses authored edges, kb relation list separates authored outbound assertions from derived inbound ones, and kb links performs cycle-safe traversal with explicit depth and result limits. Traversal does not expand through semantic similarity. These commands rebuild their views from Markdown and return canonical note identities; no graph database or generated fact file becomes shared state.
A one-off whole-vault question can inspect the bounded JSON graph in an agent or a task-local script. If the same question keeps returning, it can become a named operation with an explicit output contract and regression tests. During parallel work, each lane can run kb check --no-catalog without rewriting index.md; the integrating agent performs one final refresh.
The command line covers one query at a time. The code-mode SDK opens one read-only session, scans the live vault once, and exposes exact search, metadata queries, reads, links, backlinks, hybrid search, Git provenance, and Git-history search through one typed object. An agent can keep that session open while it compares evidence or builds a report.
Reuse one live knowledge-base session
import { openKnowledgeBase } from "@hraness/kb/sdk";
const kb = await openKnowledgeBase({ root: "kb", repository: "." });
const context = await kb.search({
query: "why did the parser boundary change?",
tags: ["architecture"],
graph: { depth: 1 },
history: "auto",
});
await kb.close();For compound work, defineWorkflow and runWorkflow execute a finite dependency graph of trusted TypeScript functions. Independent nodes run in parallel, dependent nodes wait for their inputs, QMD work is serialized, Git work has its own bound, and abort or failure stops new scheduling. The bundled decision-context, explain-change, and plan-radar workflows are reusable examples for common agent questions. A staged builder infers each custom node's dependency results and final output. The workflow limit keeps code-mode tasks inspectable and prevents several agents from creating a new shared state file to coordinate retrieval.
A plan shown only in chat has the same session boundary as the reasoning that produced it. The plan-kb skill writes a normal Markdown file with an outcome, status, area, assumptions, dependencies, decisions, and verification method. During execution, the same plan accumulates deviations, review findings, command evidence, and the final result. Completed plans remain as history. A finding that becomes a load-bearing edit rule moves into the applicable AGENTS.md; its rationale and evidence may stay linked from the scope hub.
hraness/kb also ships six Agent Skills that preserve the same file contract. save-url-kb selects a URL acquisition route and records completeness; save-pdf-kb preserves a PDF's text, images, bytes, and provenance; query-kb chooses exact metadata, local hybrid search, graph context, or Git provenance; percolate-kb reviews changed notes for reusable concepts and evidence-backed relationships; refresh-kb regenerates the catalog and reviews graph diagnostics; and plan-kb keeps execution knowledge durable. The agent workflow documentation defines how these skills meet the CLI contracts across agent runners. Skills guide writes and retrieval; they do not make application code depend on KB.
Start with a short inherited AGENTS.md path for rules whose omission would make an edit wrong. Add a scope hub only when its rationale, evidence, plans, or linked decisions deserve pull-based retrieval. A small vault may need only Markdown, Git, an index, and ordinary file search. Add typed relationships, metadata queries, graph traversal, QMD, browser capture, PDF ingestion, or code-mode workflows when the simpler layer stops answering the repository's questions.
The useful property is continuity without lock-in. An agent can save evidence, leave a durable plan, find the same idea through exact or semantic language, inspect the links and commits around it, and hand the result to another agent as plain files. Checks validate structure rather than truth. Capture preserves a selected surface rather than the source's trustworthiness. A typed edge records an authored assertion, and similarity supplies candidates rather than conclusions. People and agents still have to revise the concepts, evidence, and explanations when the repository changes.
Bun is the required runtime.
Copy this prompt into Codex, Claude Code, or another coding agent:
Install hraness/kb and its bundled Agent Skills from
https://github.com/hraness/kb at the immutable v0.11.0 tag. Follow the repository
README, install the `kb` CLI, copy or link the skills I need into this agent
runner's configured skills directory, and verify the installation with
`kb doctor` and `kb --help`. Do not initialize or modify a vault until I ask.
The repository and packed package carry the same skill directories, so an agent can inspect the tagged instructions before placing them in its runner-specific discovery path.
Install the CLI from the immutable v0.11.0 tag:
bun add --global github:hraness/kb#v0.11.0
kb --helpFor programmatic use, declare the same pinned source in a project:
{
"dependencies": {
"@hraness/kb": "github:hraness/kb#v0.11.0"
}
}Contributors can install from a checkout instead:
git clone https://github.com/hraness/kb.git
cd kb
bun install --frozen-lockfile
bun link
kb --helpHTTP capture works with the installed JavaScript dependencies. Rendered capture additionally needs a local Chromium-compatible browser. yt-dlp adds YouTube metadata, thumbnails, and transcripts; full audio or video localization is opt-in and some formats also need FFmpeg. PDF ingestion uses the open-source Poppler tools pdfinfo and pdftohtml; Tesseract adds local OCR for scans and screenshots.
Structural commands and exact search read the current Markdown directly and
need no service, model, or graph database. Keyword search uses
QMD's local BM25 index. Hybrid and semantic
search also use its recommended compact local EmbeddingGemma model. The first
kb index, hybrid kb search, or semantic kb search downloads the model
(about 300 MB). The default hybrid mode combines live exact results with QMD
keyword and vector results. --mode exact, keyword search, and every structural
command work without an embedding model.
kb init my-kb
cd my-kb
kb clip https://example.com/article --output articles
kb refresh --root .
kb check --root .kb init creates an index.md front door plus articles/, notes/,
plans/, riffs/, and optional repository-context scopes/ boundaries. The
generated Markdown remains ordinary Markdown: open it in Obsidian, edit it in a
text editor, search it with standard tools, and version it with Git.
When a vault lives at kb/ inside a repository, inspect the instructions and
mapped context for a repository path from the repository root:
kb agents identity packages/parser --json
kb context packages/parser/src/index.ts --root kb --repo .
kb agents check --root kb --repo .kb agents identity derives a canonical mapping without writing files.
kb context lists inherited AGENTS.md files from the repository root toward
the target and verified context hubs from the nearest scope back toward the
root. It prints hub summaries, not their full bodies. Open the useful hub, then
use kb links, kb backlinks, kb list, or kb search to expand the
question deliberately.
| Command | Purpose |
|---|---|
kb init [directory] |
Create a new vault without merging into or overwriting an existing path; the default directory is kb. |
kb clip <url|current> |
Capture a source and write an article bundle. current reads an attached active tab without navigating it; kb capture <url> is the explicit URL form. |
kb inspect <url> |
Run acquisition and extraction without writing a bundle. |
kb pdf <file-or-url> [--slug <slug>] |
Convert a local or public remote PDF into Markdown while retaining the original bytes, extracted images, OCR-derived text, URL provenance, and page provenance. |
kb refresh --root <directory> |
Rebuild the managed catalog atomically and report graph findings. |
kb check --root <directory> |
Verify that the catalog is current and graph policy passes without changing files. --no-catalog gates an edit lane without requiring the shared catalog refresh. |
kb graph --root <directory> |
Print the resolved contextual and typed graph, broken or ambiguous targets, orphans, and advisory mention candidates. |
kb backlinks <note> --root <directory> |
Show incoming contextual links and typed relationships for a note resolved by path, title, or alias. |
kb links <note> --root <directory> |
Traverse incoming, outgoing, or bidirectional contextual links and typed relationships with explicit depth and node limits. |
kb note create <id> --title <title> --root <directory> |
Atomically create one confined Markdown note; use --type concept for a reusable concept. |
kb relation add|remove <source> <predicate> <target> |
Idempotently edit one source note's typed outbound relationship using exact canonical note IDs. |
kb relation list <note> --root <directory> |
List a note's authored outbound and derived inbound typed relationships. |
kb percolate [note] --root <directory> |
Report evidence-backed recurring-concept and missing-relationship candidates without writing notes. |
kb list --root <directory> |
Filter typed, nested frontmatter and tags; sort by metadata, title, path, or graph counts. kb notes is an alias. |
kb index --root <directory> |
Build or incrementally refresh the optional local QMD embedding index. |
kb search <query> --root <directory> |
Combine live exact matches with local QMD keyword and vector retrieval. Use --mode exact|keyword|semantic, metadata and tag filters, bounded graph context, or separate Git provenance. --require-history fails when Git provenance is unavailable; --no-history skips it. |
kb context <repository-path> --root <vault> --repo <repository> |
List inherited guides root to nearest and reciprocal context hubs nearest to root. Use --kind auto|file|directory to control how the target path is interpreted. |
kb agents identity <repository-scope> |
Derive the normalized scope, canonical hub ID and path, owning guide path, and exact reciprocal marker without writing files. |
kb agents check --root <vault> --repo <repository> |
Validate context identities, exact scopes, reciprocal markers, real guide paths, collisions, confinement, and guide shape. Unmapped guides remain valid. |
kb agents audit --root <vault> --repo <repository> |
Run the same correctness gate, then report deterministic per-guide, section, inherited-chain, long-bullet, and exact-duplicate advisories. |
kb doctor |
Report required and optional local capture capabilities. |
kb adapters |
Print the installed platform capability matrix. |
Vault commands default to the current directory and index.md; use --root and --index to select alternatives. Commands that report structured data accept --json. Run kb --help for the complete top-level surface and kb clip --help for capture, authentication, evidence, and resource-bound options.
Use the current browser tab without navigating it:
kb clip current --browser-live --output articles
kb clip current --cdp 9222 --output articlesFor --browser-live, first enable Chrome's local debugging connection at chrome://inspect/#remote-debugging (Chrome 144+). If Chrome was launched with an explicit loopback debugging port, pass that numeric port to --cdp instead.
To open a URL with state from a path-backed Chromium profile, pass its path. The capture runs against a temporary copy, leaving the source profile unchanged. A named profile selects reusable agent-browser-managed state instead:
kb clip https://example.com/private --browser-profile <path> --output articlesEach web capture writes readable Markdown, capture.json, localized assets, and optional evidence under articles/<slug>/. Unless media is disabled, YouTube captures add the title, description, duration, channel, thumbnail, and a locally extracted transcript when available; other video surfaces retain a poster or thumbnail instead of downloading the video by default. See Capture web content for scopes, saved files, browser modes, media, evidence, completeness states, and limits.
PDF capture uses the same bundle boundary:
kb pdf "/absolute/path/to/document.pdf" --output articles
kb pdf "https://example.com/document.pdf" --output articlesThe bundle includes byte-identical source.pdf, readable Markdown, capture.json, and content-addressed extracted images. A reviewed second pass also retains its hash-bound annotations.json. See Capture PDF documents for heading inference, OCR, screenshot metadata, completeness, and review.
Vault-root wikilinks such as
[[notes/context-engineering|context engineering]] and source-owned typed
frontmatter relationships are the graph's authored facts:
type: concept
relations:
supports:
- notes/durable-agent-memoryPredicates use lower-kebab-case and targets use exact vault-root IDs without
.md. kb graph, kb backlinks, kb relation list, and kb links derive
inverse edges and bounded paths without injecting reciprocal or inferred facts into notes.
kb percolate proposes reusable concepts and missing connections with explicit
support; an agent reviews the cited prose before authoring anything.
These focused views are rebuilt from current Markdown. KB never commits a graph
database, generated fact file, or engine entity ID. Parallel agents therefore
keep editing separate notes. Each lane can run kb check --no-catalog, and the
integrator runs one final kb refresh for the only shared generated region in
index.md. Use kb graph --json for a whole-vault structural question; when a
question recurs, prefer adding a focused command with a bounded output contract
over introducing a parallel query store.
Frontmatter retains nested objects, arrays, finite numbers with safe integer precision, booleans, strings, and nulls. kb list --where type=plan --tag ingestion --sort metadata.updated --order desc answers exact questions from that authored data. Unquoted true, false, null, and numeric filter values are typed; keep the quotes inside the argument to match a string with the same spelling, for example kb list --where 'external_id="9007199254740993"'. Hybrid search fuses exact and QMD result orders, then joins each match back to live metadata. Graph neighbors and Git provenance are returned as separate evidence. Similarity never becomes a link automatically.
Repository context preserves a stricter authority boundary. AGENTS.md remains
the always-loaded, normative home for ownership, required commands,
prohibitions, and edit gates. An optional type: agent-context note under
scopes/ holds rationale, history, examples, evidence, and links for one exact
repository-relative directory. Its reciprocal
<!-- kb:context scopes/<id> --> marker appears before the guide headings.
A hub cannot override its guide or become the only home of a load-bearing
editing rule. Moving the scoped directory changes its identity.
Scope hubs are ordinary Markdown in the graph and optional QMD index;
AGENTS.md files remain excluded. This workflow reads repository and vault
files at development time. Applications do not need to import KB or couple
their runtime to the vault.
The package exports its full programmatic surface from @hraness/kb. Open one
read-only vault session through @hraness/kb/sdk to share a live Markdown scan
across exact search, metadata queries, reads, navigation, hybrid search, and Git
provenance. Compose finite parallel retrieval graphs with
@hraness/kb/workflow. @hraness/kb/workflows includes editable
decision-context, explain-change, and plan-radar compositions. Focused
lower-level entry points include
@hraness/kb/search, @hraness/kb/git,
@hraness/kb/agent-context,
@hraness/kb/agent-guide-audit, @hraness/kb/authoring,
@hraness/kb/graph, @hraness/kb/navigation, @hraness/kb/percolate,
@hraness/kb/query, and @hraness/kb/semantic; web-capture orchestration and
diagnostics from
@hraness/kb/capture; PDF ingestion from @hraness/kb/pdf; and reusable
disposable-profile helpers from @hraness/kb/browser-profiles. Embedders that
need the CLI's lower-level ingestion machinery can use the explicit
capture-primitive subpaths listed in package.json, including
@hraness/kb/clip/acquire, @hraness/kb/clip/args, the DNS-pinned request and
connection-pool boundary at @hraness/kb/clip/network, and the browser proxy at
@hraness/kb/clip/network-proxy.
The repository and packed package ship six reusable Agent Skills under
skills/: save-url-kb for auditable web ingestion, save-pdf-kb for
local and public remote PDF conversion, refresh-kb for graph and
agent-context validation, query-kb for loading repository-path context
before bounded exact, metadata, hybrid, graph, or Git retrieval,
percolate-kb for reviewing and promoting reusable concepts and typed
relationships, and plan-kb for creating and growing durable implementation
plans. Copy or link a skill
directory into the location used by your agent runner. They invoke the installed
kb command and do not depend on a repository checkout path.
See Design, Agent workflow, PDF capture, and Contributing for the durable contracts and development gate. hraness/kb is available under the MIT License.