The third rule arm, and the one the other two cannot reach. `write_path_rule`
is keyed on code, `pre_tool_rule` on a command — both things the session is
about to DO. A rule that governs what to SAY has no such trigger: extract
intent from loose phrasing, raise a conflict before acting, hand off an
action with its reason, end a finding with an offer all bind on a RESPONSE,
and no tool call precedes one.

The operator's message is the only query that exists before a response is
composed. That hook searched notes alone, so no rule had ever been retrieved
against a thing the operator actually said — and residency was the only
surface those rules had, which is what milestone 394 removes.

A SEPARATE FUNCTION, not a branch in build_autoinject_hint, because of its
early returns. That arm bails when auto-inject is disabled, when the query is
blank, when nothing clears the note bar — every one a statement about NOTES.
Folded in, an operator who turned the awareness menu off would silently lose
their rules, a coupling with no symptom since both look like a quiet hook.
Two functions, two sets of gates, composed in the route. Guarded as "the rule
arm never asks the notes arm's config", which is the structural fact.

Joins _ARMS rather than getting its own test file. #3497's history is that
the pre-tool arm inherited a defect from its sibling by being MODELLED on it
instead of sharing with it, and a third arm modelled on two is two chances to
repeat that. Repeat rendering, fresh-only counting, log-before-bailout, the
kind register and the two-recorders identity are properties of every arm or
of none.

The bar is INHERITED and says so. 0.72 was tuned against code and commands;
prose is a different query shape against the same documents, and triggers are
written in the vocabulary of the moment — which for most rules is act
vocabulary. Starting at the only number with evidence behind it and logging
every call from the first deploy is what makes it settleable; guessing lower
would put an unmeasured bar in front of a corpus that binds.

k=3, anchored on this hook's own budget rather than the act arms'.
RULEHINT_LIMIT is 1 because that arm fires before every Bash call; this one
fires once per turn, beside a notes menu already spending three slots. And a
prompt genuinely contains more than one act — "merge to main and then start
on X" is two — where a command is one thing.

`prompt_rule` added to RANKED_SOURCES: a ranker picked it, and a ranked
source missing from that tuple is silently counted as bulk delivery and drops
out of the pull-through denominator.

The hook reads and writes the SHARED rule ledger under scribe-priorart, not a
private one — one session keeps one list, aged (#3751), so a rule named here
is not re-announced before the next Bash call.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011cPyzNnegXHr5iRMzzy5KJ

2026-09-11 07:56:19 -04:00

.claude-plugin

feat(rules): rules retrieve against the operator's message (#3852 )

2026-09-11 07:56:19 -04:00

commands

feat(plugin): Phase 4 — Scribe Processes auto-surface as local skills

2026-06-14 13:00:32 -04:00

hooks

feat(rules): rules retrieve against the operator's message (#3852 )

2026-09-11 07:56:19 -04:00

skills

fix(plugin): the instruction surfaces still said every rule binds (#3849 )

2026-09-10 23:20:04 -04:00

README.md

feat(frontend): the app says what it is running, and says so honestly when it cannot find out (#3329 )

2026-09-02 11:23:43 -04:00

README.md

Scribe plugin for Claude Code

Turns a self-hosted Scribe instance into a first-class Claude Code extension:

MCP tools over your notes, tasks, projects, milestones, systems, and rulebook (the scribe server).
Session-start push channel — a SessionStart hook injects your always-on rules + active-project context so Scribe surfaces without being asked.
Prior-art recall on writes — a PreToolUse hook on Write/Edit checks the file about to be written against your recorded snippets (what's kept at that path, and what resembles the code) and offers them before the helper is rewritten. Titles only, never blocks the edit.
Universal process-skills — using-scribe, writing-plans, systematic-debugging, verification, brainstorming, reusing-code (record and recall reusable code as snippets). Replaces superpowers.
Your Scribe Processes as skills — saved Processes are synced into local ~/.claude/skills/scribe-proc-* stubs that auto-surface by relevance; the stub fetches the live procedure via get_process. Refreshed each session and on demand with /scribe:sync.

It is designed so you can uninstall superpowers and disable auto-memory and depend on neither.

Install

The plugin ships inside the Scribe app repo, so the marketplace is that repo — you always get the plugin version that matches your Scribe instance.

/plugin marketplace add https://git.fabledsword.com/bvandeusen/FabledScribe.git
/plugin install scribe@scribe-plugin

On install you'll be asked for:

Setting	What
Scribe base URL	e.g. `https://scribe.example.com` (no trailing slash)
Scribe API key	an `fmcp_` key from Settings → API Keys (stored in your OS keychain)
Active project id	optional — numeric project id to scope the session-start context

What gets wired

plugin.json mcpServers → the scribe MCP server at <base URL>/mcp (Bearer auth).
hooks/hooks.json → SessionStart hook (hooks/scribe_session_context.sh), fail-open: if Scribe is unreachable it injects nothing and never blocks the session.
hooks/hooks.json → PreToolUse hook on Write|Edit (hooks/scribe_prior_art.sh) → GET /api/plugin/prior-art. Returns additionalContext with no permission decision, so it can inform the write but never stop it; silent when nothing is recorded, which is most of the time. Two framings: a REUSE menu (similar/nearby records), and a SYNC nudge when a snippet records the exact file being edited — "updating the record is part of the edit" — each with its own once-per-session dedup. A third, ledger-fed line names a duplicate family (no canon) or a canon recorded elsewhere for the names being written (its own dedup channel, exclude_derive). Fail-open but not fail-silent: a configured instance that does not answer in time is said, once per outage ("Scribe did not answer … this write went UNCHECKED"), so a session can tell "checked, nothing there" from "never checked"; an answer clears the marker. The local by-name arm needs no server and always runs. Toggle in Settings → Knowledge auto-inject.
hooks/hooks.json → PostToolUse hook on Bash (hooks/scribe_after_write.sh): code written through sed/heredocs/scripts never reaches the PreToolUse hook, so this one diffs the working tree after every Bash call (per-session path+blob snapshot; one git status when nothing changed) and runs the same arms on the definitions just written, through the same endpoint and the same dedup channels. additionalContext only; never blocks, and shares the pre-write hook's once-per-outage "did not answer" line (8 s budget here — it runs after the tool, so it gates nothing). The extractor, the prose/data skip list, the local by-name duplicate arm and the outage line are shared in hooks/scribe_defs.sh.
skills/ → the universal process-skills, surfaced by description match.
hooks/scribe_sync_processes.sh (a 2nd SessionStart hook) + the /scribe:sync command → generate ~/.claude/skills/scribe-proc-* stubs from your Scribe Processes (via GET /api/plugin/processes); also fail-open, and pruned to match what exists in Scribe.

Notes

Do not hand-edit version in .claude-plugin/plugin.json. It is minted from the clock — run python3 scripts/mint_plugin_version.py (or make mint-plugin, where make is installed) after changing anything under plugin/, and commit the result. The installer decides whether to refresh the cache it executes from by comparing that string, so content that ships without a new version reaches the repo and stops there (#2209). CI fails the lane if you forget.
The session-start, auto-inject and prior-art hooks need only a read-scoped key; the MCP tools need write scope to create/update. Every hook is a GET for that reason — a read key cannot POST.