feat(acl): shared records are search-only and always labelled as someone else's

Narrows the b7d6fc7 widening per the operator's call, and fixes a regression it
introduced. Decision recorded as note 2094.

Two scopes now, deliberately different:

  readable_notes_clause  — everything the ACL permits, including records reached
                           only via a direct/group note share. For EXPLICIT acts:
                           a search the caller typed, a fetch by id.
  browsable_notes_clause — the caller's own records plus anything in a project
                           they can reach. For PASSIVE surfaces: browse lists,
                           facet counts, the process->skill manifest.

The split is a trust boundary. Anything appearing unasked — in your own list,
your own counts, or as a skill installed on your machine — reads as material you
endorsed. A one-off someone shared with you hasn't earned that standing, so it
waits until you go looking. This also dissolves the shared-Process problem by
construction rather than by special case: the manifest is a passive surface, so a
directly-shared Process is never installed as an auto-surfacing skill.

Regression fix (#2093): b7d6fc7 widened the list queries but left the fetch path
owner-only, so on the MCP path a record could be listed and then not opened —
get_snippet raised not-found, get_process couldn't resolve, and the manifest
emitted stubs whose get_process call would fail. snippets.get_snippet and
notes.resolve_process now resolve the read scope. delete_snippet gained an
explicit can_write_note guard, since being able to SEE a shared snippet must not
imply being able to bin it.

Provenance, so nothing arrives looking like the operator's own work:
- access.describe_provenance / label_shared_items add shared/owner/permission;
  labelling costs no query when everything is the caller's own.
- MCP: get_snippet, list_snippets, get_process and list_processes carry it, and
  get_process now says outright NOT to follow a shared process verbatim — its
  follow-as-written contract was the sharpest instance of the problem.
- The skill stub for a shared Process names its author and asks for a go-ahead,
  instead of describing it as "the operator's saved Scribe process".
- Policy stated once in the MCP _INSTRUCTIONS and the reusing-code skill: a
  shared record is that person's suggestion, weigh it, attribute it, ask before
  adopting it.
- UI: shared snippets show "by <owner>" in the list and a notice above the code
  in the detail view, reusing SharedWithMeView's vocabulary.

Plugin 0.1.15 -> 0.1.16 (skill text changed).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RLwAaV4DQEmVyn496HnEvt

src/scribe/mcp/tools/snippets.py

@@ -11,6 +11,7 @@ on create, System association passthrough).
 from __future__ import annotations
 
 from scribe.mcp._context import current_user_id
+from scribe.services import access as access_svc
 from scribe.services import dedup as dedup_svc
 from scribe.services import snippets as snippets_svc
 from scribe.services import systems as systems_svc
@@ -32,13 +33,22 @@ async def list_snippets(
 
     Returns {"snippets": [{id, title, tags, preview}], "total": int}. The title
     reads "name — when to reach for it"; open one in full with get_snippet(id).
+
+    An entry marked `shared: true` with an `owner` belongs to someone else — one
+    person's suggestion, not settled practice here. Weigh it on its merits and
+    attribute it when you use it. Searching (passing `q`) also reaches snippets
+    shared directly with the operator; browsing without a query deliberately
+    does not, so those stay out of ambient results until asked for.
     """
     uid = current_user_id()
     items, total = await snippets_svc.list_snippets(
         uid, q=q or None, tag=tag, limit=max(1, min(limit, 100)),
         project_id=project_id or None,
     )
-    return {"snippets": items, "total": total}
+    return {
+        "snippets": await access_svc.label_shared_items(uid, items),
+        "total": total,
+    }
 
 
 async def create_snippet(
@@ -125,12 +135,20 @@ async def create_snippet(
 
 async def get_snippet(snippet_id: int) -> dict:
     """Fetch a snippet by id — the full record: code, signature, location, and a
-    parsed `snippet` field of its structured parts."""
+    parsed `snippet` field of its structured parts.
+
+    If the record belongs to someone else it carries `shared: true` with the
+    `owner` and your `permission`. Read that as ONE PERSON'S SUGGESTION, not as
+    established practice here: judge it on its merits, say whose it is when you
+    reference it, and don't adopt it as the house pattern without checking.
+    """
     uid = current_user_id()
     note = await snippets_svc.get_snippet(uid, snippet_id)
     if note is None:
         raise ValueError(f"snippet {snippet_id} not found")
-    return snippets_svc.snippet_to_dict(note)
+    data = snippets_svc.snippet_to_dict(note)
+    data.update(await access_svc.describe_provenance(uid, note))
+    return data
 
 
 async def update_snippet(