rename(547): the server is grimoire — package, image, DB defaults, backups

Step 2 of the Scribe -> Grimoire rename.

- src/scribe -> src/grimoire, and every import, patch target, module path,
  hypercorn entry point and `python -m grimoire.restore` with it; pyproject,
  uv.lock and the frontend package are named grimoire.
- Image git.fabledsword.com/bvandeusen/fabledgrimoire; CI's Postgres service
  runs as grimoire / grimoire_test.
- Compose files default the DB user, database and (prod) volume to grimoire,
  each overridable from .env, so an install created as Scribe keeps its data
  by setting POSTGRES_USER, POSTGRES_DB and PGDATA_VOLUME.
- Backups are written as grimoire-<ts>.tar with format grimoire-backup-tar.
  Archives named scribe-* with the scribe-backup-tar manifest still restore
  and are still counted at the destination (folder and S3), with tests.
- Exports, the MCP auth realm, the ASGI scope key and the persistent logger
  carry the new name.

Kept on purpose: the secret-sealing key label stays "scribe.secrets.v1",
because every stored secret was derived under it.

Plugin identity (plugin name, hooks, env vars, .scribe marker, skills) is
step 3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/test_mcp_tool_processes.py

@@ -10,7 +10,7 @@ pytestmark = pytest.mark.usefixtures("_bind_user")
 
 @pytest.mark.asyncio
 async def test_create_process_requires_title_and_body():
-    from scribe.mcp.tools.processes import create_process
+    from grimoire.mcp.tools.processes import create_process
     with pytest.raises(ValueError):
         await create_process(title="", body="something")
     with pytest.raises(ValueError):
@@ -20,11 +20,11 @@ async def test_create_process_requires_title_and_body():
 @pytest.mark.asyncio
 async def test_create_process_sets_note_type():
     created = fake_note(title="Drift Audit", note_type="process")
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock(return_value=None)), \
-         patch("scribe.services.notes.create_note",
+         patch("grimoire.services.notes.create_note",
                AsyncMock(return_value=created)) as mock_create:
-        from scribe.mcp.tools.processes import create_process
+        from grimoire.mcp.tools.processes import create_process
         out = await create_process(title="Drift Audit", body="the prompt", tags=["audit"])
     assert out["note_type"] == "process"
     # the service was asked to create a process
@@ -37,16 +37,16 @@ async def test_create_process_blocks_a_near_duplicate():
     """The gate matters more for processes than for other kinds: each one becomes
     a skill file that auto-surfaces, so two near-identical procedures don't just
     bloat the corpus — they compete to be followed."""
-    from scribe.services.dedup import DuplicateMatch
+    from grimoire.services.dedup import DuplicateMatch
 
     # The real dataclass, not a MagicMock: a mock answers every attribute, so it
     # would pass whatever field names this test happened to guess and prove
     # nothing about the payload the tool actually returns.
     match = DuplicateMatch(id=42, title="Drift Audit", similarity=0.94, reason="semantic")
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock(return_value=match)), \
-         patch("scribe.services.notes.create_note", AsyncMock()) as mock_create:
-        from scribe.mcp.tools.processes import create_process
+         patch("grimoire.services.notes.create_note", AsyncMock()) as mock_create:
+        from grimoire.mcp.tools.processes import create_process
         out = await create_process(title="Drift Audit", body="the prompt")
     assert out["duplicate"] is True
     assert out["existing_id"] == 42
@@ -56,11 +56,11 @@ async def test_create_process_blocks_a_near_duplicate():
 @pytest.mark.asyncio
 async def test_create_process_force_bypasses_the_gate():
     created = fake_note(title="Drift Audit", note_type="process")
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock()) as find_mock, \
-         patch("scribe.services.notes.create_note",
+         patch("grimoire.services.notes.create_note",
                AsyncMock(return_value=created)):
-        from scribe.mcp.tools.processes import create_process
+        from grimoire.mcp.tools.processes import create_process
         await create_process(title="Drift Audit", body="the prompt", force=True)
     find_mock.assert_not_awaited()
 
@@ -68,9 +68,9 @@ async def test_create_process_force_bypasses_the_gate():
 @pytest.mark.asyncio
 async def test_get_process_returns_body_and_candidates():
     note = fake_note(id=7, title="Drift Audit", note_type="process")
-    with patch("scribe.services.notes.resolve_process",
+    with patch("grimoire.services.notes.resolve_process",
                AsyncMock(return_value=(note, [{"id": 9, "title": "Drift Audit Notes"}]))):
-        from scribe.mcp.tools.processes import get_process
+        from grimoire.mcp.tools.processes import get_process
         out = await get_process("drift")
     assert out["id"] == 7
     assert out["other_matches"] == [{"id": 9, "title": "Drift Audit Notes"}]
@@ -85,12 +85,12 @@ async def test_get_process_flags_another_users_process():
     the returned body', so an unlabelled one would put someone else's procedure
     in charge of the session."""
     note = fake_note(id=7, title="Drift Audit", user_id=9, note_type="process")
-    with patch("scribe.services.notes.resolve_process",
+    with patch("grimoire.services.notes.resolve_process",
                AsyncMock(return_value=(note, []))), \
-         patch("scribe.services.access.describe_provenance",
+         patch("grimoire.services.access.describe_provenance",
                AsyncMock(return_value={"shared": True, "owner": "alex",
                                        "permission": "viewer"})):
-        from scribe.mcp.tools.processes import get_process
+        from grimoire.mcp.tools.processes import get_process
         out = await get_process("deploy")
     assert out["shared"] is True
     assert out["owner"] == "alex"
@@ -98,9 +98,9 @@ async def test_get_process_flags_another_users_process():
 
 @pytest.mark.asyncio
 async def test_get_process_not_found_raises():
-    with patch("scribe.services.notes.resolve_process",
+    with patch("grimoire.services.notes.resolve_process",
                AsyncMock(return_value=(None, []))):
-        from scribe.mcp.tools.processes import get_process
+        from grimoire.mcp.tools.processes import get_process
         with pytest.raises(ValueError):
             await get_process("missing")
 
@@ -111,9 +111,9 @@ async def test_update_process_rejects_non_process_note():
     # returns (note, permission).
     plain = fake_note(id=3, title="Drift Audit", note_type="note")
     plain.deleted_at = None
-    with patch("scribe.services.notes.get_note_for_user",
+    with patch("grimoire.services.notes.get_note_for_user",
                AsyncMock(return_value=(plain, "owner"))):
-        from scribe.mcp.tools.processes import update_process
+        from grimoire.mcp.tools.processes import update_process
         with pytest.raises(ValueError):
             await update_process(process_id=3, title="x")
 
@@ -125,11 +125,11 @@ async def test_update_process_refuses_a_read_only_share_with_the_reason():
     open would just send them looking for a missing id."""
     theirs = fake_note(id=5, title="Drift Audit", user_id=9, note_type="process")
     theirs.deleted_at = None
-    with patch("scribe.services.notes.get_note_for_user",
+    with patch("grimoire.services.notes.get_note_for_user",
                AsyncMock(return_value=(theirs, "viewer"))), \
-         patch("scribe.services.access.can_write_note", AsyncMock(return_value=False)), \
-         patch("scribe.services.notes.update_note", AsyncMock()) as mock_update:
-        from scribe.mcp.tools.processes import update_process
+         patch("grimoire.services.access.can_write_note", AsyncMock(return_value=False)), \
+         patch("grimoire.services.notes.update_note", AsyncMock()) as mock_update:
+        from grimoire.mcp.tools.processes import update_process
         with pytest.raises(ValueError, match="read-only"):
             await update_process(process_id=5, title="x")
     mock_update.assert_not_awaited()
@@ -139,11 +139,11 @@ async def test_update_process_refuses_a_read_only_share_with_the_reason():
 async def test_delete_process_trashes_it_recoverably():
     proc = fake_note(id=4, title="Drift Audit", note_type="process")
     proc.deleted_at = None
-    with patch("scribe.services.notes.get_note_for_user",
+    with patch("grimoire.services.notes.get_note_for_user",
                AsyncMock(return_value=(proc, "owner"))), \
-         patch("scribe.mcp.tools.processes.trash_svc.delete",
+         patch("grimoire.mcp.tools.processes.trash_svc.delete",
                AsyncMock(return_value="batch-1")) as mock_delete:
-        from scribe.mcp.tools.processes import delete_process
+        from grimoire.mcp.tools.processes import delete_process
         out = await delete_process(process_id=4)
     assert out["deleted_batch_id"] == "batch-1"
     # Through the trash, not a hard delete — restorable like every other kind.
@@ -157,10 +157,10 @@ async def test_delete_process_refuses_a_plain_note():
     mistyped argument."""
     plain = fake_note(id=3, title="Drift Audit", note_type="note")
     plain.deleted_at = None
-    with patch("scribe.services.notes.get_note_for_user",
+    with patch("grimoire.services.notes.get_note_for_user",
                AsyncMock(return_value=(plain, "owner"))), \
-         patch("scribe.mcp.tools.processes.trash_svc.delete", AsyncMock()) as mock_delete:
-        from scribe.mcp.tools.processes import delete_process
+         patch("grimoire.mcp.tools.processes.trash_svc.delete", AsyncMock()) as mock_delete:
+        from grimoire.mcp.tools.processes import delete_process
         with pytest.raises(ValueError):
             await delete_process(process_id=3)
     mock_delete.assert_not_awaited()
@@ -172,11 +172,11 @@ async def test_delete_process_refuses_a_plain_note():
 async def test_create_process_stores_the_moments_it_is_for():
     created = fake_note(title="Release", note_type="process",
                         data={"moments": ["work.deliver"]})
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock(return_value=None)), \
-         patch("scribe.services.notes.create_note",
+         patch("grimoire.services.notes.create_note",
                AsyncMock(return_value=created)) as mock_create:
-        from scribe.mcp.tools.processes import create_process
+        from grimoire.mcp.tools.processes import create_process
         out = await create_process(title="Release", body="steps",
                                    moments=["Work.Deliver", "work.deliver"])
     assert mock_create.await_args.kwargs["data"] == {"moments": ["work.deliver"]}
@@ -187,10 +187,10 @@ async def test_create_process_stores_the_moments_it_is_for():
 async def test_create_process_refuses_an_unknown_moment_before_writing():
     """A typo'd moment would be stored and never fire — a procedure that looks
     attached and is not."""
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock(return_value=None)), \
-         patch("scribe.services.notes.create_note", AsyncMock()) as mock_create:
-        from scribe.mcp.tools.processes import create_process
+         patch("grimoire.services.notes.create_note", AsyncMock()) as mock_create:
+        from grimoire.mcp.tools.processes import create_process
         with pytest.raises(ValueError, match="unknown moment"):
             await create_process(title="Release", body="steps", moments=["work.shipped"])
     mock_create.assert_not_awaited()
@@ -199,11 +199,11 @@ async def test_create_process_refuses_an_unknown_moment_before_writing():
 @pytest.mark.asyncio
 async def test_create_process_without_moments_stores_no_data():
     created = fake_note(title="Release", note_type="process")
-    with patch("scribe.mcp.tools.processes.dedup_svc.find_duplicate_note",
+    with patch("grimoire.mcp.tools.processes.dedup_svc.find_duplicate_note",
                AsyncMock(return_value=None)), \
-         patch("scribe.services.notes.create_note",
+         patch("grimoire.services.notes.create_note",
                AsyncMock(return_value=created)) as mock_create:
-        from scribe.mcp.tools.processes import create_process
+        from grimoire.mcp.tools.processes import create_process
         out = await create_process(title="Release", body="steps")
     assert mock_create.await_args.kwargs["data"] is None
     assert out["moments"] == []
@@ -211,12 +211,12 @@ async def test_create_process_without_moments_stores_no_data():
 
 async def _update(moments, data):
     proc = fake_note(id=5, title="Release", note_type="process", data=data)
-    with patch("scribe.services.notes.get_note_for_user",
+    with patch("grimoire.services.notes.get_note_for_user",
                AsyncMock(return_value=(proc, "owner"))), \
-         patch("scribe.services.access.can_write_note", AsyncMock(return_value=True)), \
-         patch("scribe.services.notes.update_note",
+         patch("grimoire.services.access.can_write_note", AsyncMock(return_value=True)), \
+         patch("grimoire.services.notes.update_note",
                AsyncMock(return_value=proc)) as mock_update:
-        from scribe.mcp.tools.processes import update_process
+        from grimoire.mcp.tools.processes import update_process
         await update_process(process_id=5, moments=moments)
     return mock_update.await_args.kwargs
 
@@ -242,8 +242,8 @@ async def test_update_process_without_moments_leaves_data_alone():
 async def test_get_process_says_which_moments_it_is_for():
     note = fake_note(id=7, title="Release", note_type="process",
                      data={"moments": ["work.deliver"]})
-    with patch("scribe.services.notes.resolve_process", AsyncMock(return_value=(note, []))):
-        from scribe.mcp.tools.processes import get_process
+    with patch("grimoire.services.notes.resolve_process", AsyncMock(return_value=(note, []))):
+        from grimoire.mcp.tools.processes import get_process
         out = await get_process("release")
     assert out["moments"] == ["work.deliver"]
 
@@ -253,7 +253,7 @@ def test_register_attaches_every_tool_in_the_module():
     registered is invisible to an agent, and nothing else would notice."""
     import inspect
 
-    from scribe.mcp.tools import processes
+    from grimoire.mcp.tools import processes
     mcp = FakeMCP()
 
     processes.register(mcp)