Milestone 334 step 3. 0.1.48 was the last of 48 numbers a person typed by
hand; forgetting to type the 49th is #2209, #1040 and #2220, three separate
times a shipped fix reached the repo and stopped there.

WHY A SCRIPT AND NOT A BUILD STEP. plugin/ is not in the image -- installs
fetch it from this repo via marketplace.json, so the push IS the release and
there is no moment at which CI could stamp a version in. Every other artifact
in the family derives during a build (#3127 section 2). This one has no build
to derive during, so the value is minted before the commit and CI's job is to
prove it moved when it had to.

MINT TIME, a fourth clock section 2 does not name. It prescribes commit time
so two lanes building one source report one string; the plugin has one lane
and no build, so that reason does not reach it. What is given up is
reproducibility-from-history -- you cannot recompute the value, only verify it
moved. That is acceptable ONLY because #3325 read the installer's code and
found the refresh test is `P.version === H`, plain equality, with zero
ordering comparisons anywhere. Where a comparator orders, an unreproducible
version would be unverifiable too.

Two artifacts in one repo now derive from different clocks on purpose, one
directory apart. "Let's make these consistent" is the obvious tidy-up and
breaks whichever loses, so the divergence is pinned in tests rather than only
explained in a comment -- including an AST assertion that the mint script
never imports subprocess, since a mint that can read history is a commit-time
deriver wearing the wrong name.

check_version_bump becomes check_version_is_minted. It gains the shape gate
and a future-value gate, and it keeps deliberately NOT failing when the
version moved without content changing: a needless re-mint costs one cache
refresh, and failing the lane over a harmless act is how a check earns a
--no-version in somebody's muscle memory and stops running at all. The
implication that matters is one-directional.

The mint script joins the version-relevant set, which is step 2's DERIVERS
table finally being read by something. Section 3's asymmetry is why it is not
optional: change the format string, change nothing else, and a diff over the
shipped paths alone says "no content change" while the manifest keeps a value
in the old format forever. Its own introduction demonstrates this -- adding
the deriver is itself the version-relevant change that forced this mint.

fetch-depth: 0 was NOT added, against this step's own brief. The plugin job
carries a comment refusing it, backed by an observed act_runner failure (any
`with:` block made checkout fail to extract, run 3027), and the reasoning
holds: the check diffs two trees and the workflow already fetches main at
depth 1. Checklist 6 is about jobs that derive; this one checks.

Verified live before pushing: the session-context marker reports
v2026.09.01.2252 keylessly, and both failure arms were probed by hand rather
than assumed. The shape gate fires first on a reverted 0.1.48, so the stale
arm is covered by unit test rather than by that probe.

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

2026-09-01 18:54:55 -04:00

.claude-plugin

feat(plugin): mint the version, and make CI the control that it moved (#3327 )

2026-09-01 18:54:55 -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): a session is told when its rules move under it (#3244 , milestone 323 step 5)

2026-08-30 13:02:00 -04:00

skills

fix(rules): the staleness signal must not wait for prior art to match (#3244 )

2026-08-30 13:10:04 -04:00

README.md

fix(plugin): write-path hooks say when Scribe did not answer — once per outage, shared marker, record nudge withheld on an unanswered call; check_plugin allows exactly that line when unreachable; plugin 0.1.43 (#2932 )

2026-08-23 10:59:54 -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

Set a version bump in .claude-plugin/plugin.json per release so clients pick up changes.
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.