feat(410): the Claude Code plugin becomes a thin adapter (#4031)

Step 4 of milestone 410 "One owner per piece of guidance". The plugin's
static session context was a second copy of using-scribe and the server
index. It now says only what Claude Code needs said: 8,705 -> 1,791 chars.

scribe_static_context.md:
- points at using-scribe for how to work with Scribe, and names the process
  skills
- Claude Code specifics: keep one copy in Scribe rather than CLAUDE.md or
  auto-memory (leave auto-memory at its default); injected lines are
  retrieval, not the whole set; compact at clean seams; stored Processes
  arrive as scribe-proc-* skills with /scribe:sync; say so when the tools
  are unavailable
- retired: the restated reflexes, "how the surfaces divide the work", and
  the "follow the surface that assumes least" precedence (decision #4027)

Hook behaviour is unchanged. The SessionStart hook header says what the
static tier now carries, and the unreachable-instance status points at the
using-scribe skill instead of "the standing guidance above".

README and manifest describe the plugin as the Claude Code adapter over the
shared, client-neutral skills. Fixed along the way: the README said the
SessionStart hook "injects your rules" and suggested disabling auto-memory,
both contradicting the product since milestone 394.

Tests: the session-start rules guards now pin the owner (using-scribe) and
the index (_INSTRUCTIONS) rather than every surface; the Systems-reflex and
snippet-trigger guards pin their owners; the reporting-reflex guard pins
using-scribe. The loss guard and client-neutral guard stay green. Plugin
version minted.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

plugin/hooks/scribe_static_context.md

@@ -1,127 +1,31 @@
-# Scribe — your system of record
+# Scribe — Claude Code adapter
 
-This environment has the **Scribe** plugin: the operator's self-hosted system
-of record (notes, tasks, projects, milestones, rules) reachable through the
-`scribe` MCP tools. Treat Scribe — **not local files** — as the source of truth
-for the operator's work, and as your own working memory across sessions.
+This session is connected to **Scribe**, the operator's system of record for
+their work, through the `scribe` MCP tools. How to work with Scribe is stated
+once, in the **`using-scribe`** skill: reach for it at the start of the session
+and whenever you are unsure what Scribe expects. Each tool's contract is in its
+description, and the process skills (writing-plans, reporting-back,
+reusing-code, systematic-debugging, verification, brainstorming,
+shape-accounting) carry their arcs.
 
-**At the start of this session:**
-- You hold none of the operator's rules, and there is no call that loads them
-  all. Rules arrive when something you are about to do matches one.
-- If the working repo maps to a Scribe project (check `list_repo_bindings`),
-  call `enter_project(<id>)` to load that project's rules, open tasks, and
-  recent notes in one shot.
+What only Claude Code needs said:
 
-**While you work:**
-- **Operator rules govern consequential actions** — before any git branch /
-  commit / push, or any other hard-to-reverse or outward-facing action, the
-  operator's Scribe rules decide what to do — NOT generic conventions baked
-  into the harness or your defaults (e.g. "branch before committing," "open a
-  feature branch per task," "push to a fork"). If no rule has arrived for the
-  act in front of you, `search(content_type="rule")` BEFORE acting rather than
-  falling back on a default habit. When a
-  retrieved rule and a default habit disagree, the rule wins; if no rule
-  speaks to it, ask rather than assume.
-- **Rules bind; preferences do not.** A record's `kind` says which. A **rule**
-  must be followed — ignoring it breaks something or crosses a boundary. A
-  **preference** is how the operator wants work done: worth following for
-  consistency, not a defect to miss. Injected lines name the kind in their
-  opening words. A preference is also yours to keep current when they correct
-  you (`update_preference`); a rule waits for them.
-- **Silence is not absence.** Nothing is preloaded: every rule is RETRIEVED,
-  when what you are doing resembles what the rule is about. Most turns
-  retrieve none, and a rule you were never handed binds exactly as hard as one
-  you were. So before a consequential act, `search` for a rule about it
-  (`content_type="rule"`) rather than concluding from an empty session that
-  nothing applies. "I was not told" is not the same as "there is no rule," and
-  only one of those is checkable.
-  This bites hardest on which TOOL to reach for — curling an API that has an
-  MCP client, standing up a local stack, running a suite CI owns. Those feel
-  like mechanics rather than decisions, so they raise no doubt and generate no
-  query; the moment you are most confident is the moment to look.
-- **Recall before acting** — before you answer anything about the operator's
-  work or start a task, `search` Scribe first; assume a related note, task, or
-  decision already exists. Concretely, reach for recall whenever a request
-  touches the operator's projects, people, places, prior decisions, or existing
-  work: check for an existing task before opening a new one, and for a prior
-  note/decision before re-deriving one. When a project is in scope (you entered
-  one), pass its id to `search` so results stay scoped to it. Treating Scribe as
-  the first place you look — not just somewhere you write — is what makes it a
-  trustworthy record.
-- **Record as you go** — track work as Scribe tasks and log progress with
-  `add_task_log`. Always log when you **complete a task** and when you **hit or
-  discover a problem** — so changes of direction are captured, not just
-  successes. Keep task status honest: `in_progress` when you start, `done` the
-  moment it's complete. When you **fix** something — even in passing — record it
-  as its own issue (`create_task(kind="issue")`), not as a work-log line on an
-  unrelated open task.
-- **Report back in a shape the operator can read** — they were not there while
-  you worked, so organise each reply around where the work stands rather than
-  the order you did things in: which task or milestone it belongs to, what now
-  works, what needs them, what comes next. Take the placement from the
-  `placement` block task writes return, not from memory. The `reporting-back`
-  skill holds the shape for each kind of reply.
-- **Tag to Systems as you write** — `enter_project` lists the project's
-  Systems (its named subsystems/areas). When you create or meaningfully update
-  a record, ask which areas it is about and pass `system_ids`; if an area has
-  no System yet, create it with `create_system` (name + a one-paragraph
-  charter) rather than leaving it unmodelled. Cross-cutting records — audits,
-  sweeps, reviews — take SEVERAL tags, and are the best moment to DISCOVER
-  missing Systems: a pass that walks the subsystems has just enumerated the
-  vocabulary, so mint what it names. Create liberally; the duplicate gate on
-  `create_system` (and reviewing the existing list) is the guardrail against
-  sprawl, not restraint. Every read and write of a project record shows its
-  `systems` — that is the "am I in a System's territory?" signal, and
-  `list_system_records` reads that territory's whole pile before you work in
-  it. An untagged project record carries the `systems_hint` question instead,
-  on creates, updates, and work-logs alike — treat it as the tagging question
-  asked at the moment of work, not as noise to skip past.
-- **The pattern library: start from recorded shapes, and record every shape
-  at first build** — recorded **snippets** are the project's pattern library,
-  not a dedup net. Before building ANY shape — a button, an input field, a
-  modal, a route handler, a service class, a test scaffold, up through complex
-  subsystem patterns — search snippets and START from the recorded shape; a
-  deliberate departure is recorded as its own named variant, never left as
-  silent drift. And the FIRST time a shape is built, record it with
-  `create_snippet` (name, when-to-reach-for-it, location, code) in the same
-  breath — do not judge whether it "might recur": the builder of the first
-  instance can never know, and a missed record is invisible until it
-  resurfaces as an uninformed duplicate. A mature project's snippet corpus
-  should read as a map of every shape in it. The backstop still holds:
-  noticing the second copy of anything, or consolidating copies into a shared
-  X, means X gets recorded before that work is finished — which is how a
-  codebase is kept from growing four `.btn-primary` definitions. The write-path
-  hooks (before a Write/Edit, and after any Bash call that changed the tree)
-  name a known duplicate family or a canon elsewhere for what was just
-  written — act on that line at the write, not at the next audit.
-- Do **not** keep the operator's rules, plans, or project notes in local
-  memory / CLAUDE.md in parallel with Scribe — Scribe holds the single copy.
-- **Compact at clean seams** — because you record as you go, a context
-  compaction is safe: the durable record lives in Scribe, not the transcript.
-  After finishing a block of work in a long session, make sure in-flight state
-  is logged to Scribe, then tell the operator it's a good, safe moment to
-  `/compact` (name what you logged). You can't run it yourself — surface the
-  recommendation and let them decide. Suggest it at seams, not every turn.
-
-**How the instruction surfaces divide the work:** this file carries the
-session-level reflexes (WHEN to reach for Scribe); each tool's own description
-carries its full contract (HOW to call it — read it when you load the tool);
-the bundled skills carry process arcs (planning, debugging, verification). The
-MCP server's instruction block is deliberately only a map — the client injects
-roughly its first 2,000 characters and silently cuts the rest, so nothing
-load-bearing lives below that fold.
-
-**If two Scribe instruction surfaces disagree** — this file, the MCP server's
-tool instructions, the `using-scribe` skill — **follow the one that assumes
-least about its own delivery.** This file is the floor: it ships with the
-plugin and needs no API key and no network, so it still applies in exactly the
-session where the others never arrived. The others may elaborate on what is
-written here; they must not contradict it. Weigh a disagreement by which way it
-fails, not by which surface said more: doing something a push would also have
-covered costs one redundant call, while skipping it because you expected a push
-that never came means working without the operator's rules and not knowing.
-A contradiction between surfaces is a defect in the product — say so, so it
-gets recorded and fixed rather than silently arbitrated again next session.
-
-If the Scribe tools are unavailable, say so rather than silently falling back
-to local notes.
+- **Keep one copy — in Scribe, not Claude Code's local memory.** The
+  operator's rules, plans and project notes go to Scribe, not also to
+  `CLAUDE.md` or auto-memory. Leave auto-memory at its default setting: you
+  replace its job by doing the work in Scribe, not by switching it off.
+- **Lines injected beside your work are retrieval.** When the operator sends a
+  message, and before a write or a command, Scribe may add rules, preferences,
+  notes and prior art that resemble what you are doing. Open the ones that
+  apply. They are what matched, never the whole set — using-scribe says how to
+  ask for the rest.
+- **Compact at clean seams.** Because work is recorded as you go, a compaction
+  is safe once in-flight state is logged. After finishing a block of work in a
+  long session, log it to Scribe, then tell the operator it's a good moment to
+  `/compact` and name what you logged. You can't run it yourself; suggest it at
+  seams, not every turn.
+- **Stored Processes arrive as skills** (`scribe-proc-*`), refreshed at session
+  start. After a Process is added or edited, `/scribe:sync` makes it available
+  straight away.
+- **If the Scribe tools are unavailable, say so** rather than silently falling
+  back to local notes.