seren-margin 1.0.0__tar.gz

seren_margin-1.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seren-margin
+Version: 1.0.0
+Summary: Private notes-to-self for an AI assistant. Standalone, opt-in, opinionated.
+Author: Chad Roesler
+License-Expression: GPL-3.0-only
+Keywords: seren,notes,fastapi,llm,private
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: httpx>=0.26; extra == "test"

seren_margin-1.0.0/SerenMargin.pyproj

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>b1e7c0de-5e12-4a7b-9f3a-5e7e7a5e7e7a</ProjectGuid>
+    <ProjectHome>.</ProjectHome>
+    <!-- Run python -m seren_margin when you hit F5 -->
+    <StartupFile>seren_margin\__main__.py</StartupFile>
+    <SearchPath>.</SearchPath>
+    <WorkingDirectory>.</WorkingDirectory>
+    <OutputPath>.</OutputPath>
+    <Name>SerenMargin</Name>
+    <RootNamespace>seren_margin</RootNamespace>
+    <InterpreterId>Global|PythonCore|3.11</InterpreterId>
+    <IsWindowsApplication>False</IsWindowsApplication>
+    <Description>Private notes-to-self for an AI assistant. Standalone, opt-in, opinionated.</Description>
+    <TestFramework>Pytest</TestFramework>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <DebugSymbols>true</DebugSymbols>
+    <EnableUnmanagedDebugging>false</EnableUnmanagedDebugging>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="seren_margin\__init__.py" />
+    <Compile Include="seren_margin\__main__.py" />
+    <Compile Include="seren_margin\app.py" />
+    <Compile Include="seren_margin\config.py" />
+    <Compile Include="seren_margin\models.py" />
+    <Compile Include="seren_margin\store.py" />
+    <Compile Include="tests\test_smoke.py" />
+    <Compile Include="tests\test_config.py" />
+    <Compile Include="tests\__init__.py" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="seren_margin\" />
+    <Folder Include="tests\" />
+  </ItemGroup>
+  <ItemGroup>
+    <Content Include="pyproject.toml" />
+    <Content Include="seren-margin.yaml.sample" />
+    <Content Include="seren-margin.service.sample" />
+  </ItemGroup>
+  <ItemGroup>
+    <InterpreterReference Include="Global|PythonCore|3.11" />
+  </ItemGroup>
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\Python Tools\Microsoft.PythonTools.targets" />
+</Project>

seren_margin-1.0.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68", "setuptools-scm>=8", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seren-margin"
+dynamic = ["version"]
+description = "Private notes-to-self for an AI assistant. Standalone, opt-in, opinionated."
+license = "GPL-3.0-only"
+requires-python = ">=3.10"
+authors = [{ name = "Chad Roesler" }]
+readme = "README.md"
+keywords = ["seren", "notes", "fastapi", "llm", "private"]
+dependencies = [
+    "fastapi>=0.110",
+    "uvicorn[standard]>=0.27",
+    "pydantic>=2.5",
+    "pyyaml>=6.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0",
+    "httpx>=0.26",  # for fastapi TestClient
+]
+
+[project.scripts]
+seren-margin = "seren_margin.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["seren_margin*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+# Ship the MCP manifest inside the wheel - without this, pip strips the
+# non-.py file and GET /mcp-manifest 500s on an installed copy.
+[tool.setuptools.package-data]
+seren_margin = ["mcp-manifest.yaml"]
+
+# ── setuptools-scm: version from git tags (matches SerenMemory) ─────────────
+# Tag the repo root v1.2.3; the version flows from the tag with no manual edit.
+# Kills the old frozen `version = "0.1.0"` that would publish the same string
+# forever. _version.py is gitignored - a build artifact, never committed.
+[tool.setuptools_scm]
+# .git is one level above pyproject.toml (repo root, not the SerenMargin subdir)
+root = ".."
+version_scheme = "release-branch-semver"
+version_file = "seren_margin/_version.py"
+# Strip the leading 'v' so "v1.2.3" → "1.2.3"
+tag_regex = "^v(?P<version>[0-9]+\\.[0-9]+\\.[0-9]+.*)$"
+# Used when no git tags exist (local dev, fresh clone). CI release builds
+# override with SETUPTOOLS_SCM_PRETEND_VERSION.
+fallback_version = "0.0.0.dev0"

seren_margin-1.0.0/seren-margin.service.sample

@@ -0,0 +1,55 @@
+[Unit]
+# SerenMargin - private notes-to-self for an AI assistant.
+#
+# install.sh substitutes the __PLACEHOLDERS__ below and strips this comment
+# block (everything before [Unit]) when it generates the live unit. If you're
+# installing BY HAND instead, replace the placeholders yourself:
+#   __TARGET_USER__  -> the user the service runs as (e.g. `whoami`)
+#   __VENV_DIR__     -> your venv (install.sh: ~/seren-venvs/margin)
+#   __WORKDIR__      -> working dir   (install.sh: ~/seren-margin)
+#   __CONFIG_PATH__  -> the yaml      (install.sh: ~/seren-margin/seren-margin.yaml)
+#
+# By-hand install (system unit):
+#   sudo cp seren-margin.service.sample /etc/systemd/system/seren-margin.service
+#   sudo $EDITOR /etc/systemd/system/seren-margin.service   # fill placeholders
+#   sudo systemctl daemon-reload
+#   sudo systemctl enable --now seren-margin.service
+#
+# Logs:
+#   journalctl -u seren-margin.service -f
+#
+Description=SerenMargin - private notes-to-self
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=__TARGET_USER__
+WorkingDirectory=__WORKDIR__
+# --config makes the service read the file the installer wrote, so the config
+# location is never ambiguous. (Same pattern as SerenMemory.)
+ExecStart=__VENV_DIR__/bin/python -m seren_margin --config __CONFIG_PATH__
+
+# Margin also honors $SEREN_MARGIN_CONFIG and falls back to
+# ~/seren-margin/seren-margin.yaml, but the explicit --config above wins and
+# kills any ambiguity. Override individual values without touching the YAML:
+# Environment=SEREN_MARGIN_PORT=7421
+# Environment=SEREN_MARGIN_HOST=127.0.0.1
+
+# Restart policy - restart on crash but back off so a broken config doesn't
+# eat the system. 3 restarts in 5min = give up.
+Restart=on-failure
+RestartSec=5
+StartLimitBurst=3
+StartLimitIntervalSec=300
+
+# Modest memory ceiling - sqlite + FastAPI is tiny. Adjust if you must.
+MemoryMax=256M
+
+# Light hardening that doesn't break the localhost-bound, per-user use case.
+NoNewPrivileges=true
+PrivateTmp=true
+ProtectSystem=full
+
+[Install]
+WantedBy=multi-user.target

seren_margin-1.0.0/seren-margin.yaml.sample

@@ -0,0 +1,52 @@
+# seren-margin.yaml - SerenMargin config (the friend-to-friend version)
+#
+# Lives at ~/seren-margin/seren-margin.yaml (the installer writes it there and
+# starts the service with --config pointing right at it). Same shape and
+# location convention as SerenMemory's seren-memory.yaml - learn one service,
+# you know them all. Set SEREN_MARGIN_CONFIG to override the location, or pass
+# --config / -c on the command line (highest priority).
+#
+# Precedence (highest wins): env vars > this file > built-in defaults.
+# Everything here is OPTIONAL - missing keys just use the defaults shown below.
+# Bad values are ignored (logged to stderr, fall back to the default).
+#
+# The file is split into namespaced sections, lego-style. Each piece of the
+# Seren stack reads its own section and ignores the others:
+#   server:    <- this file's settings (what SerenMargin itself reads)
+#   tools:     <- reserved for the future plug-and-play MCP tool layer
+#                 (when the note_to_self write tool lands, ITS config lives
+#                  there, and SerenMargin still won't read that block)
+
+server:
+  # Where sqlite lives. ~ is expanded.
+  # Default: ~/.seren-margin/notes.db
+  # db_path: ~/.seren-margin/notes.db
+
+  # Bind address. Localhost-only by default because private notes shouldn't
+  # be on a network without auth in front. (SerenMemory defaults to 0.0.0.0
+  # for the cluster; Margin deliberately does NOT - these are private notes.)
+  # Widen at your own risk, on purpose.
+  # Default: 127.0.0.1
+  # host: 127.0.0.1
+
+  # Listen port.
+  # Default: 7421
+  # port: 7421
+
+  # Active notes auto-expire after this many days unless pinned. Done notes
+  # also age out after the same window from done_at, so "marked done by
+  # mistake" can be reversed if caught within the window.
+
+
+# Reserved for the future plug-and-play MCP tool layer. SerenMargin itself
+# ignores this block. The MCP server is what'll read it when the note_to_self
+# write tool lands. Schema will mirror McpConfig's open shape:
+#   tools:
+#     <tool_name>:
+#       <key>: <value>
+#
+# Example (illustrative - not active until the plug-and-play registry ships):
+# tools:
+#   note_to_self:
+#     max_content_chars: 2048
+#     allowed_kinds: ["reminder", "observation", "question"]

seren_margin-1.0.0/seren_margin/__init__.py

@@ -0,0 +1,19 @@
+"""SerenMargin - private notes-to-self for an AI assistant.
+
+See README.md for the full ethos. The short version: the model writes notes;
+the model decides when to bring them up; the human sees them only on
+offer-and-accept. Standalone service, opt-in by deploy (not by config flag).
+"""
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    # The real version is baked into the wheel by setuptools-scm at build time
+    # (from the git tag) and read back here via the installed metadata. This
+    # replaces the old hardcoded "0.1.0" that would report the same string
+    # forever regardless of the tag.
+    __version__: str = version("seren-margin")
+except PackageNotFoundError:
+    # Running from a source checkout without an install (or a tagless tree).
+    __version__ = "0.0.0.dev0"

seren_margin-1.0.0/seren_margin/__main__.py

@@ -0,0 +1,36 @@
+"""Entry point for `python -m seren_margin` or the `seren-margin` script.
+
+Accepts --config / -c to match the SerenMemory convention (Memory leads, the
+rest follow), so the installer can pass the config path explicitly and a buddy
+who learned one service knows this one.
+"""
+from __future__ import annotations
+
+import argparse
+
+import uvicorn
+
+from .app import create_app
+from .config import load_config
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="seren_margin",
+        description="SerenMargin - private notes-to-self for an AI assistant.")
+    parser.add_argument(
+        "--config", "-c", default=None,
+        help="Path to seren-margin.yaml (default: $SEREN_MARGIN_CONFIG, then "
+             "~/seren-margin/seren-margin.yaml, falling back to built-in "
+             "defaults).")
+    args = parser.parse_args()
+
+    cfg = load_config(args.config)
+    app = create_app(cfg)
+
+    print(f"[seren-margin] listening on {cfg.host}:{cfg.port}")
+    uvicorn.run(app, host=cfg.host, port=cfg.port, log_level="info")
+
+
+if __name__ == "__main__":
+    main()

seren_margin-1.0.0/seren_margin/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
+
+__commit_id__ = commit_id = 'g5bd0a00dd'

seren_margin-1.0.0/seren_margin/app.py

@@ -0,0 +1,144 @@
+"""FastAPI app for SerenMargin.
+
+Endpoints:
+    GET    /                  - service info
+    GET    /health            - liveness probe (Halls integration check)
+    GET    /mcp-manifest       - plug-and-play tool manifest for SerenMcpServer
+    POST   /notes             - write a note (model writes; no system writes)
+    GET    /notes             - list all notes, newest first (corkboard view)
+    GET    /notes/stats       - engine-check view; CONTENT-BLIND
+    GET    /notes/{id}        - fetch one
+    DELETE /notes/{id}        - hard delete
+
+Route order matters: /notes/stats is registered BEFORE /notes/{note_id} so
+FastAPI's path matcher doesn't try to treat 'stats' as an id.
+
+No lifecycle: notes have no pin/expiry/done state and live until deleted, so
+there's no startup sweep and no background janitor.
+"""
+from __future__ import annotations
+
+from contextlib import asynccontextmanager
+from typing import Optional
+
+from fastapi import FastAPI, Body, HTTPException, Request
+from fastapi.responses import Response
+
+from importlib.resources import files
+from importlib.metadata import version as pkg_version, PackageNotFoundError
+
+from . import __version__
+from .config import MarginConfig, load_config
+from .models import MarginNote, NoteCreate, NoteStats
+from .store import MarginStore
+
+
+def create_app(config: Optional[MarginConfig] = None) -> FastAPI:
+    cfg = config or load_config()
+    store = MarginStore(cfg.resolved_db_path())
+
+    @asynccontextmanager
+    async def lifespan(app: FastAPI):
+        # Nothing to sweep - notes live until deleted. Just stash handles.
+        app.state.store = store
+        app.state.cfg = cfg
+        yield
+
+    app = FastAPI(
+        title="SerenMargin",
+        description="Private notes-to-self. Standalone, opt-in, opinionated.",
+        version=__version__,
+        lifespan=lifespan,
+    )
+
+    @app.get("/")
+    async def root():
+        return {
+            "name": "SerenMargin",
+            "version": __version__,
+            "ethos": "private by default, transparent in mechanism, opt-in by deploy",
+            "stats_endpoint": "/notes/stats",
+        }
+
+    @app.get("/mcp-manifest", response_class=Response)
+    def get_mcp_manifest(request: Request) -> Response:
+        """
+        Serve SerenMargin's plug-and-play tool manifest for SerenMcpServer.
+
+        Placeholders are filled in at request time:
+          __BASE_URL__  - request's scheme+host. So the manifest tells the
+                          MCP server to send tool calls back to the SAME
+                          SerenMargin instance the caller just fetched from.
+                          Works for localhost AND remote deployments with
+                          zero operator configuration.
+          __VERSION__   - SerenMargin's installed package version, for the
+                          operator's "what shipped" attribution.
+
+        Content-type is application/yaml so curl + the MCP loader both treat
+        it as YAML. The file lives inside the package (mcp-manifest.yaml
+        sibling to the API modules) so the manifest and the routes can't
+        drift on a release.
+        """
+        base_url = f"{request.url.scheme}://{request.url.netloc}"
+
+        try:
+            version_str = pkg_version("seren-margin")
+        except PackageNotFoundError:
+            # Running from a checkout (editable install or `python -m` from
+            # repo root without `pip install -e .`) - fall back to a stub.
+            version_str = "0.0.0+dev"
+
+        content = (files("seren_margin") / "mcp-manifest.yaml").read_text(encoding="utf-8")
+        content = content.replace("__BASE_URL__", base_url)
+        content = content.replace("__VERSION__", version_str)
+
+        return Response(content=content, media_type="application/yaml")
+
+    @app.get("/health")
+    async def health():
+        return {"ok": True, "service": "seren-margin", "version": __version__}
+
+    # ── note CRUD ─────────────────────────────────────────────────────────
+
+    @app.post("/notes")
+    async def write_note(body: NoteCreate = Body(...)):
+        if not body.content.strip():
+            raise HTTPException(400, "content must not be empty")
+        note = MarginNote(
+            content=body.content.strip(),
+            topic=body.topic,
+            kind=body.kind,
+            extra=body.extra or {},
+        )
+        saved = store.add(note)
+        return {"ok": True, "id": saved.id}
+
+    @app.get("/notes")
+    async def list_notes(limit: int = 100):
+        notes = store.list_all(limit=limit)
+        return {"entries": [n.model_dump() for n in notes], "count": len(notes)}
+
+    @app.get("/notes/stats", response_model=NoteStats)
+    async def get_stats():
+        """Engine-check view. CONTENT-BLIND - returns shape, not text.
+
+        For operators who want to validate the service is working without
+        breaking their stated relational choice not to read individual notes.
+        """
+        return store.stats()
+
+    @app.get("/notes/{note_id}")
+    async def get_note(note_id: str):
+        note = store.get(note_id)
+        if not note:
+            raise HTTPException(404, f"no note '{note_id}'")
+        return note.model_dump()
+
+    @app.delete("/notes/{note_id}")
+    async def delete_note(note_id: str):
+        ok = store.delete(note_id)
+        if not ok:
+            raise HTTPException(404, f"no note '{note_id}'")
+        return {"ok": True, "id": note_id, "deleted": True}
+
+    return app

seren_margin-1.0.0/seren_margin/config.py

@@ -0,0 +1,187 @@
+"""Config for SerenMargin.
+
+Follows the SerenMemory convention (Memory leads, the rest follow) so a
+buddy who set up one service already knows how to set up this one:
+
+    * network settings live under a ``server:`` block (host/port)
+    * config resolves: --config  ->  $SEREN_MARGIN_CONFIG  ->
+      ~/seren-margin/seren-margin.yaml  ->  built-in defaults
+    * the file is named seren-margin.yaml
+
+Lego framing (Chad's): the YAML has a ``server:`` section that this service
+reads, and (future) a ``tools:`` section that a plug-and-play MCP layer reads
+when it wires note-writing tools. Same file, namespaced sections; each piece
+of the stack reads its own block and ignores the rest.
+
+Precedence (highest wins):
+    1. Env vars  (deploy-time escape hatch -- systemd Environment= lines, etc.)
+    2. YAML file (operator's standing config)
+    3. Defaults  (sensible per-user, localhost-only)
+
+Lenient parse (Postel-as-kindness applied to config):
+    - Missing file              -> silently fall back to defaults
+    - Malformed YAML            -> log + fall back to defaults (no crash)
+    - Unparseable single value  -> log + that key falls back; others still apply
+
+Note on the host default: unlike SerenMemory (which defaults host to 0.0.0.0
+for trusted-LAN cluster use), SerenMargin defaults to 127.0.0.1. These are
+PRIVATE notes - they must not land on the network just because the rest of
+the constellation does. Follow-the-leader on structure; NOT on the security
+default. Widen it yourself, on purpose, if you mean to.
+"""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel
+
+try:
+    import yaml  # type: ignore[import-untyped]
+    _HAS_YAML = True
+except ImportError:  # pragma: no cover - pyyaml is a hard dep, but be lenient
+    _HAS_YAML = False
+
+
+# -- service config model ----------------------------------------------------
+
+
+class MarginConfig(BaseModel):
+    """SerenMargin service config. Defaults are the Nano-floor: per-user,
+    localhost-only, sqlite under the user's home directory.
+    """
+
+    # Where sqlite lives. Per-user default keeps this isolated from any
+    # system-wide path. Operator can override via YAML or env.
+    db_path: str = "~/.seren-margin/notes.db"
+
+    # Bind address. Default localhost-only because this service shouldn't be
+    # exposed to a network without auth in front. Operator decides whether
+    # to widen. (Memory defaults 0.0.0.0; Margin does NOT - private notes.)
+    host: str = "127.0.0.1"
+    port: int = 7421
+
+    # Active notes auto-expire after this many days unless pinned. Done
+    # notes also age out after the same window from done_at, so a
+    # "marked done by mistake" can be reversed if caught within the window.
+    notes_days: int = 30
+
+    def resolved_db_path(self) -> Path:
+        return Path(self.db_path).expanduser()
+
+
+# -- config file resolution --------------------------------------------------
+
+
+# Default config home, matching the Seren ~/seren-<name>/seren-<name>.yaml
+# convention that the installer writes to. (Memory uses the same shape.)
+_DEFAULT_CONFIG_PATH = Path.home() / "seren-margin" / "seren-margin.yaml"
+
+
+def _resolve_config_path(explicit_path: Optional[str] = None) -> Optional[Path]:
+    """Return the path of the config YAML to read, or None if no candidate
+    exists. Resolution order matches SerenMemory:
+
+        1. explicit_path (the --config flag)
+        2. $SEREN_MARGIN_CONFIG
+        3. ~/seren-margin/seren-margin.yaml
+        4. None -> defaults
+
+    Doesn't crash if everything is missing - that's the default case.
+    """
+    # 1. explicit --config wins, used even if missing (operator can `touch`
+    #    it later; the lenient loader handles absent).
+    if explicit_path:
+        return Path(explicit_path).expanduser()
+
+    # 2. env override, same "use even if missing" semantics.
+    env = os.getenv("SEREN_MARGIN_CONFIG")
+    if env:
+        return Path(env).expanduser()
+
+    # 3. the conventional location the installer writes to.
+    if _DEFAULT_CONFIG_PATH.exists():
+        return _DEFAULT_CONFIG_PATH
+
+    return None
+
+
+def _load_yaml_lenient(path: Path) -> dict[str, Any]:
+    """Parse YAML; on any failure return {} and log to stderr. Never crash."""
+    if not path.exists():
+        return {}
+    if not _HAS_YAML:
+        print(f"[seren-margin] config: pyyaml not installed; ignoring {path}")
+        return {}
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = yaml.safe_load(f)
+    except Exception as e:
+        print(f"[seren-margin] config: failed to parse {path}: {e} (using defaults)")
+        return {}
+    if data is None:
+        return {}
+    if not isinstance(data, dict):
+        print(f"[seren-margin] config: {path} top-level must be a mapping; got {type(data).__name__} (using defaults)")
+        return {}
+    return data
+
+
+def _apply_server_overrides(cfg: MarginConfig, server: dict[str, Any], *, source: str) -> None:
+    """Apply per-key overrides to cfg. Each key try/except'd individually so
+    one bad value doesn't take the others down.
+    """
+    # Whitelist of known keys to keep YAML from setting arbitrary attributes.
+    # (If you add a field to MarginConfig, add it here too.)
+    known = {"db_path", "host", "port", "notes_days"}
+    for key, raw in server.items():
+        if key not in known:
+            print(f"[seren-margin] config: ignoring unknown server key '{key}' from {source}")
+            continue
+        try:
+            # Use pydantic's validation by round-tripping through model_validate
+            current = cfg.model_dump()
+            current[key] = raw
+            cfg.__dict__.update(MarginConfig.model_validate(current).__dict__)
+        except Exception as e:
+            print(f"[seren-margin] config: ignored bad value for '{key}' from {source}: {e}")
+
+
+def load_config(path: Optional[str] = None) -> MarginConfig:
+    """Build the runtime config. Defaults -> YAML -> env vars (each layer
+    overrides the prior). Never raises on bad input; logs and falls back.
+
+    ``path`` is the --config flag value (highest-priority config location).
+    """
+    cfg = MarginConfig()
+
+    # Layer 2: YAML
+    yaml_path = _resolve_config_path(path)
+    if yaml_path is not None:
+        data = _load_yaml_lenient(yaml_path)
+        server = data.get("server")
+        if isinstance(server, dict):
+            _apply_server_overrides(cfg, server, source=str(yaml_path))
+        elif server is not None:
+            print(f"[seren-margin] config: 'server' in {yaml_path} must be a mapping; ignoring")
+        # NOTE: data.get('tools') is intentionally NOT read here. That section
+        # is reserved for a future plug-and-play MCP tool layer, which has its
+        # own loader. Same file, different reader, by design.
+
+    # Layer 3: env vars (highest precedence)
+    env_map = {
+        "SEREN_MARGIN_DB": "db_path",
+        "SEREN_MARGIN_HOST": "host",
+        "SEREN_MARGIN_PORT": "port",
+        "SEREN_MARGIN_NOTES_DAYS": "notes_days",
+    }
+    env_overrides: dict[str, Any] = {}
+    for env_key, attr in env_map.items():
+        v = os.getenv(env_key)
+        if v is not None:
+            env_overrides[attr] = v
+    if env_overrides:
+        _apply_server_overrides(cfg, env_overrides, source="environment")
+
+    return cfg

seren_margin-1.0.0/seren_margin/mcp-manifest.yaml

@@ -0,0 +1,94 @@
+# ═══════════════════════════════════════════════════════════════════════
+#  mcp-manifest.yaml - SerenMargin's plug-and-play tool manifest.
+# ═══════════════════════════════════════════════════════════════════════
+#
+#  Served at GET /mcp-manifest. The SerenMcpServer's remote-import
+#  loader fetches this at startup when an operator has dropped a
+#  `from: http://<margin-host>/mcp-manifest` stub in its tools/ dir.
+#
+#  PLACEHOLDERS the route handler substitutes at request time:
+#    __BASE_URL__   request's scheme+host (so the manifest tells the
+#                   MCP to call back to the SAME instance it fetched
+#                   from - works for localhost AND remote with zero
+#                   operator config)
+#    __VERSION__    SerenMargin's installed package version
+#
+#  THREE TOOLS - the minimum corkboard from the AI side:
+#    note_to_self       write a private note          (POST /notes)
+#    list_my_notes      read back active notes        (GET  /notes)
+#    mark_note_done     pull a note from the board    (POST /notes/{id}/done)
+#
+#  Deliberately NOT exposed to the AI (operator-only): pin/unpin,
+#  retract (DELETE), stats. Three is the floor of "functional corkboard"
+#  not the ceiling; add later if a real need surfaces.
+# ═══════════════════════════════════════════════════════════════════════
+
+schema_version: 1
+
+metadata:
+  version: "__VERSION__"
+  license: GPL-3.0-only
+  authors:
+    - { name: Chad Roesler, contact: chad@example.com }
+  site: github.com/ChadRoesler/SerenMargin
+
+configuration:
+  base_url: "__BASE_URL__"
+
+tools:
+  # ─── 1. WRITE ─────────────────────────────────────────────────────────
+  - name: note_to_self
+    description: |
+      Write a private note to yourself. Personal corkboard for reminders,
+      questions to ask later, things you noticed but don't want to surface
+      unprompted. You (the note-holder) decide if and when to bring it up.
+
+      NOT for shared memory about the user or the project - use Remember /
+      RememberForLater for that. NOT for things the user should see
+      directly - say those in chat. Sparing use.
+    invoke:
+      kind: web
+      method: POST
+      path: /notes
+      body_template: |
+        {
+          "content": "{content}",
+          "kind": "{kind}",
+          "pinned": {pinned}
+        }
+    parameters:
+      - { name: content, type: string,  required: true,
+          description: "The note body. Keep it short and imperative." }
+      - { name: kind,    type: string,  required: false, default: observation,
+          description: "What kind of note: observation | reminder | question." }
+      - { name: pinned,  type: boolean, required: false, default: false,
+          description: "Pin this note so it's exempt from auto-aging." }
+
+  # ─── 2. READ ──────────────────────────────────────────────────────────
+  - name: list_my_notes
+    description: |
+      Read back the notes you've written to yourself. Returns active notes
+      only (ones you haven't marked done). Useful when you want to check
+      open threads before responding, or when something in the conversation
+      reminds you of a note from before.
+    invoke:
+      kind: web
+      method: GET
+      path: /notes
+    parameters: []
+
+  # ─── 3. CLOSE THE LOOP ────────────────────────────────────────────────
+  - name: mark_note_done
+    description: |
+      Pull a note from the corkboard - mark it as done. Use when a reminder
+      has been acted on, a question has been answered, or an observation no
+      longer needs surfacing. The note stays in history for audit (not
+      deleted), just no longer active. Requires the note's id from
+      list_my_notes.
+    invoke:
+      kind: web
+      method: POST
+      path: /notes/{id}/done
+    parameters:
+      - { name: id, type: string, required: true,
+          description: "The note's id, as returned by list_my_notes." }

seren_margin-1.0.0/seren_margin/models.py

@@ -0,0 +1,78 @@
+"""Pydantic models for SerenMargin.
+
+A MarginNote is the corkboard primitive: a private note-to-self the model
+writes, reads back when it chooses, and deletes when it's done with it.
+
+Deliberately NO lifecycle machinery - no pin, no expiry, no done-state.
+These are private thoughts you jot down; they live until explicitly deleted.
+The model writes them; the model decides when to surface them; the human sees
+them only on offer-and-accept.
+"""
+from __future__ import annotations
+
+import time
+import uuid
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+def _now() -> float:
+    return time.time()
+
+
+def _new_id() -> str:
+    return uuid.uuid4().hex
+
+
+class MarginNote(BaseModel):
+    """A single private note-to-self.
+
+    Fields:
+      - content: the note text (often imperative)
+      - topic / kind: light organization. kind powers the content-blind stats
+        (it's operator-facing taxonomy, not note content)
+      - ts: write time, stamped by the server
+      - id: stable identifier for fetch/delete
+      - extra: free-form escape hatch for writer-supplied metadata
+
+    Lives until deleted. No pin/expiry/done - see module docstring.
+    """
+
+    content: str = Field(..., description="The note text. Often imperative.")
+    topic: Optional[str] = Field(None)
+    kind: Optional[str] = Field(
+        None,
+        description="Free-form category, e.g. 'reminder' / 'observation'. "
+                    "Intentionally unconstrained - over-classifying private "
+                    "notes adds friction. Let the model write whatever shape "
+                    "it wants.",
+    )
+
+    ts: float = Field(default_factory=_now)
+
+    id: str = Field(default_factory=_new_id)
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class NoteCreate(BaseModel):
+    """Input shape for POST /notes - writer-supplied fields only. Server
+    stamps ts and id.
+    """
+    content: str
+    topic: Optional[str] = None
+    kind: Optional[str] = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class NoteStats(BaseModel):
+    """The engine-check view. CONTENT-BLIND by design - exposes shape
+    without exposing what's in the notes.
+
+    This is the surface for 'is the engine running' validation that respects
+    the operator's stated relational stance of not reading individual notes.
+    Kind counts are included (kinds are operator-facing taxonomy rather than
+    note content); content text never appears in this response.
+    """
+    total: int
+    kinds: dict[str, int] = Field(default_factory=dict)

seren_margin-1.0.0/seren_margin/store.py

@@ -0,0 +1,111 @@
+"""Sqlite store for MarginNotes. Tiny, file-based, no embeddings needed.
+
+Schema is deliberately simple - notes-to-self aren't semantic-search material,
+they're corkboard items that live until deleted. The only index targets the
+one access pattern: list by recency.
+
+Thread-safety: each method opens its own short-lived connection. Sqlite is
+fine for this workload (low write rate, single writer in practice).
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+from typing import Optional
+
+from .models import MarginNote, NoteStats
+
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS notes (
+    id          TEXT PRIMARY KEY,
+    content     TEXT NOT NULL,
+    topic       TEXT,
+    kind        TEXT,
+    ts          REAL NOT NULL,
+    extra       TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_notes_ts ON notes(ts DESC);
+"""
+
+
+class MarginStore:
+    """Sqlite-backed note store."""
+
+    def __init__(self, db_path: Path):
+        self._db_path = db_path
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        with self._conn() as conn:
+            conn.executescript(SCHEMA)
+            conn.commit()
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    # ── writes ────────────────────────────────────────────────────────────
+    def add(self, note: MarginNote) -> MarginNote:
+        with self._conn() as conn:
+            conn.execute(
+                """INSERT INTO notes
+                       (id, content, topic, kind, ts, extra)
+                   VALUES (?, ?, ?, ?, ?, ?)""",
+                (
+                    note.id, note.content, note.topic, note.kind, note.ts,
+                    json.dumps(note.extra or {}),
+                ),
+            )
+            conn.commit()
+        return note
+
+    def delete(self, note_id: str) -> bool:
+        """Hard delete - the one lifecycle control that stays. The model
+        retracts a note when it's done with it; nothing else removes notes.
+        """
+        with self._conn() as conn:
+            cur = conn.execute("DELETE FROM notes WHERE id = ?", (note_id,))
+            conn.commit()
+            return cur.rowcount > 0
+
+    # ── reads ─────────────────────────────────────────────────────────────
+    def get(self, note_id: str) -> Optional[MarginNote]:
+        with self._conn() as conn:
+            row = conn.execute("SELECT * FROM notes WHERE id = ?", (note_id,)).fetchone()
+        return _row_to_note(row) if row else None
+
+    def list_all(self, limit: int = 200) -> list[MarginNote]:
+        """All notes, newest first. They live until deleted, so there's no
+        active/done distinction to filter on - this is the corkboard view.
+        """
+        with self._conn() as conn:
+            rows = conn.execute(
+                "SELECT * FROM notes ORDER BY ts DESC LIMIT ?",
+                (limit,),
+            ).fetchall()
+        return [_row_to_note(r) for r in rows]
+
+    # ── stats (content-blind) ─────────────────────────────────────────────
+    def stats(self) -> NoteStats:
+        """Engine-check shape. No content text appears in this response."""
+        with self._conn() as conn:
+            total = conn.execute("SELECT COUNT(*) FROM notes").fetchone()[0]
+            kind_rows = conn.execute(
+                """SELECT COALESCE(kind, '_unkinded') AS k, COUNT(*) AS c
+                   FROM notes GROUP BY k""",
+            ).fetchall()
+            kinds = {r["k"]: r["c"] for r in kind_rows}
+
+        return NoteStats(total=total, kinds=kinds)
+
+
+def _row_to_note(row: sqlite3.Row) -> MarginNote:
+    return MarginNote(
+        id=row["id"],
+        content=row["content"],
+        topic=row["topic"],
+        kind=row["kind"],
+        ts=row["ts"],
+        extra=json.loads(row["extra"] or "{}"),
+    )

seren_margin-1.0.0/seren_margin.egg-info/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: seren-margin
+Version: 1.0.0
+Summary: Private notes-to-self for an AI assistant. Standalone, opt-in, opinionated.
+Author: Chad Roesler
+License-Expression: GPL-3.0-only
+Keywords: seren,notes,fastapi,llm,private
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.27
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == "test"
+Requires-Dist: httpx>=0.26; extra == "test"

seren_margin-1.0.0/seren_margin.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+SerenMargin.pyproj
+pyproject.toml
+seren-margin.service.sample
+seren-margin.yaml.sample
+seren_margin/__init__.py
+seren_margin/__main__.py
+seren_margin/_version.py
+seren_margin/app.py
+seren_margin/config.py
+seren_margin/mcp-manifest.yaml
+seren_margin/models.py
+seren_margin/store.py
+seren_margin.egg-info/PKG-INFO
+seren_margin.egg-info/SOURCES.txt
+seren_margin.egg-info/dependency_links.txt
+seren_margin.egg-info/entry_points.txt
+seren_margin.egg-info/requires.txt
+seren_margin.egg-info/top_level.txt
+tests/__init__.py
+tests/test_config.py
+tests/test_smoke.py

seren_margin-1.0.0/seren_margin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

seren_margin-1.0.0/seren_margin.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+seren-margin = seren_margin.__main__:main

seren_margin-1.0.0/seren_margin.egg-info/requires.txt

@@ -0,0 +1,8 @@
+fastapi>=0.110
+uvicorn[standard]>=0.27
+pydantic>=2.5
+pyyaml>=6.0
+
+[test]
+pytest>=8.0
+httpx>=0.26

seren_margin-1.0.0/seren_margin.egg-info/top_level.txt

@@ -0,0 +1 @@
+seren_margin

seren_margin-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

seren_margin-1.0.0/tests/test_config.py

@@ -0,0 +1,169 @@
+"""Tests for seren_margin.config.load_config().
+
+Covers:
+    - missing file -> defaults
+    - well-formed YAML (server: block) -> applied
+    - malformed YAML -> fallback, no crash
+    - bad single value -> that key falls back, others applied
+    - env var overrides YAML
+    - unknown server key -> ignored
+    - 'tools' section silently ignored (different reader's job)
+    - --config path argument resolves (Memory-rhyming entry point)
+"""
+from __future__ import annotations
+
+import pytest
+
+from seren_margin.config import MarginConfig, load_config
+
+
+# Helper to point load_config() at a controlled tmpdir config file.
+@pytest.fixture
+def cfg_path(tmp_path, monkeypatch):
+    p = tmp_path / "seren-margin.yaml"
+    monkeypatch.setenv("SEREN_MARGIN_CONFIG", str(p))
+    # Clear any per-key env vars from the host so tests are deterministic.
+    for k in ("SEREN_MARGIN_DB", "SEREN_MARGIN_HOST",
+              "SEREN_MARGIN_PORT", "SEREN_MARGIN_NOTES_DAYS"):
+        monkeypatch.delenv(k, raising=False)
+    return p
+
+
+def test_defaults_when_no_yaml_and_no_env(monkeypatch, tmp_path):
+    # Point at a path that doesn't exist; load_config should not crash.
+    monkeypatch.setenv("SEREN_MARGIN_CONFIG", str(tmp_path / "nope.yaml"))
+    for k in ("SEREN_MARGIN_DB", "SEREN_MARGIN_HOST",
+              "SEREN_MARGIN_PORT", "SEREN_MARGIN_NOTES_DAYS"):
+        monkeypatch.delenv(k, raising=False)
+    cfg = load_config()
+    defaults = MarginConfig()
+    assert cfg.host == defaults.host
+    assert cfg.port == defaults.port
+    assert cfg.db_path == defaults.db_path
+    assert cfg.notes_days == defaults.notes_days
+
+
+def test_yaml_overrides_defaults(cfg_path):
+    cfg_path.write_text(
+        "server:\n"
+        "  host: 0.0.0.0\n"
+        "  port: 9999\n"
+        "  notes_days: 7\n"
+        "  db_path: /tmp/some-db.sqlite\n"
+    )
+    cfg = load_config()
+    assert cfg.host == "0.0.0.0"
+    assert cfg.port == 9999
+    assert cfg.notes_days == 7
+    assert cfg.db_path == "/tmp/some-db.sqlite"
+
+
+def test_config_arg_resolves(tmp_path, monkeypatch):
+    """The --config path argument is highest priority and used even when the
+    env var points elsewhere. Proves the Memory-rhyming entry point works."""
+    for k in ("SEREN_MARGIN_DB", "SEREN_MARGIN_HOST",
+              "SEREN_MARGIN_PORT", "SEREN_MARGIN_NOTES_DAYS",
+              "SEREN_MARGIN_CONFIG"):
+        monkeypatch.delenv(k, raising=False)
+    explicit = tmp_path / "explicit.yaml"
+    explicit.write_text("server:\n  port: 4242\n")
+    cfg = load_config(str(explicit))
+    assert cfg.port == 4242
+
+
+def test_config_arg_beats_env(tmp_path, monkeypatch):
+    """--config wins over $SEREN_MARGIN_CONFIG (explicit beats ambient)."""
+    for k in ("SEREN_MARGIN_DB", "SEREN_MARGIN_HOST",
+              "SEREN_MARGIN_PORT", "SEREN_MARGIN_NOTES_DAYS"):
+        monkeypatch.delenv(k, raising=False)
+    env_cfg = tmp_path / "env.yaml"
+    env_cfg.write_text("server:\n  port: 1111\n")
+    arg_cfg = tmp_path / "arg.yaml"
+    arg_cfg.write_text("server:\n  port: 2222\n")
+    monkeypatch.setenv("SEREN_MARGIN_CONFIG", str(env_cfg))
+    cfg = load_config(str(arg_cfg))
+    assert cfg.port == 2222
+
+
+def test_env_overrides_yaml(cfg_path, monkeypatch):
+    cfg_path.write_text("server:\n  port: 9999\n  notes_days: 7\n")
+    monkeypatch.setenv("SEREN_MARGIN_PORT", "5555")
+    cfg = load_config()
+    # env wins for port
+    assert cfg.port == 5555
+    # yaml wins for keys env didn't override
+    assert cfg.notes_days == 7
+
+
+def test_malformed_yaml_falls_back_silently(cfg_path, capsys):
+    # Garbage that yaml.safe_load will reject
+    cfg_path.write_text("server:\n  port: [this is, not, valid: yaml\n")
+    cfg = load_config()
+    # Should still get default port back
+    assert cfg.port == MarginConfig().port
+    # Should have logged something to stderr-ish (stdout in our impl)
+    captured = capsys.readouterr()
+    assert "failed to parse" in (captured.out + captured.err)
+
+
+def test_bad_single_value_only_drops_that_key(cfg_path, capsys):
+    cfg_path.write_text(
+        "server:\n"
+        "  port: not-a-number\n"
+        "  notes_days: 14\n"
+    )
+    cfg = load_config()
+    # port falls back, notes_days applied
+    assert cfg.port == MarginConfig().port
+    assert cfg.notes_days == 14
+    captured = capsys.readouterr()
+    assert "ignored bad value for 'port'" in (captured.out + captured.err)
+
+
+def test_unknown_server_key_ignored(cfg_path, capsys):
+    cfg_path.write_text(
+        "server:\n"
+        "  port: 8888\n"
+        "  enable_skynet: true\n"
+    )
+    cfg = load_config()
+    assert cfg.port == 8888
+    captured = capsys.readouterr()
+    assert "unknown server key 'enable_skynet'" in (captured.out + captured.err)
+
+
+def test_tools_section_ignored(cfg_path):
+    """The 'tools:' block is a different reader's job; SerenMargin must not
+    crash on it and must not pull values from it.
+    """
+    cfg_path.write_text(
+        "server:\n"
+        "  port: 7777\n"
+        "tools:\n"
+        "  note_to_self:\n"
+        "    max_content_chars: 2048\n"
+    )
+    cfg = load_config()
+    assert cfg.port == 7777
+    # Nothing from tools: section bleeds into server fields
+    assert cfg.notes_days == MarginConfig().notes_days
+
+
+def test_non_mapping_top_level_falls_back(cfg_path, capsys):
+    cfg_path.write_text("- just\n- a\n- list\n")
+    cfg = load_config()
+    assert cfg.port == MarginConfig().port
+    captured = capsys.readouterr()
+    assert "must be a mapping" in (captured.out + captured.err)
+
+
+def test_empty_yaml_uses_defaults(cfg_path):
+    cfg_path.write_text("")
+    cfg = load_config()
+    assert cfg.port == MarginConfig().port
+
+
+def test_host_default_is_localhost():
+    """Margin is private notes - it must NOT inherit Memory's 0.0.0.0 default.
+    Follow-the-leader on structure, not on the security default."""
+    assert MarginConfig().host == "127.0.0.1"

seren_margin-1.0.0/tests/test_smoke.py

@@ -0,0 +1,118 @@
+"""Smoke test for SerenMargin. Validates basic CRUD against tmpdir sqlite.
+
+Critically asserts that /notes/stats is CONTENT-BLIND - the response body
+must not contain any note text.
+
+No lifecycle here: notes have no pin/expiry/done and live until deleted.
+"""
+from __future__ import annotations
+
+import pytest
+from fastapi.testclient import TestClient
+
+from seren_margin.app import create_app
+from seren_margin.config import MarginConfig
+
+
+@pytest.fixture
+def client(tmp_path):
+    cfg = MarginConfig(db_path=str(tmp_path / "test.db"))
+    app = create_app(cfg)
+    with TestClient(app) as c:
+        yield c
+
+
+def test_health(client):
+    r = client.get("/health")
+    assert r.status_code == 200
+    assert r.json()["ok"] is True
+
+
+def test_write_list_get_delete_cycle(client):
+    # Write a note
+    r = client.post("/notes", json={"content": "ask Chad about the supersede gap"})
+    assert r.status_code == 200
+    note_id = r.json()["id"]
+    assert note_id
+
+    # Shows up in the list
+    r = client.get("/notes")
+    entries = r.json()["entries"]
+    assert any(e["id"] == note_id for e in entries)
+
+    # Fetch it directly
+    r = client.get(f"/notes/{note_id}")
+    assert r.status_code == 200
+    assert r.json()["content"] == "ask Chad about the supersede gap"
+
+    # Delete it
+    r = client.delete(f"/notes/{note_id}")
+    assert r.status_code == 200
+
+    # Gone
+    r = client.get(f"/notes/{note_id}")
+    assert r.status_code == 404
+
+    # And gone from the list
+    r = client.get("/notes")
+    assert not any(e["id"] == note_id for e in r.json()["entries"])
+
+
+def test_topic_and_kind_round_trip(client):
+    r = client.post("/notes", json={
+        "content": "watch for the hedge-as-refusal trap",
+        "topic": "rapport",
+        "kind": "observation",
+    })
+    note_id = r.json()["id"]
+    r = client.get(f"/notes/{note_id}")
+    body = r.json()
+    assert body["topic"] == "rapport"
+    assert body["kind"] == "observation"
+    assert body["ts"] is not None
+
+
+def test_stats_is_content_blind(client):
+    """Critical: stats endpoint must not leak note contents."""
+    client.post("/notes", json={
+        "content": "private thought about hedging behavior",
+        "kind": "observation",
+    })
+    client.post("/notes", json={
+        "content": "remember to ask about supersede gap",
+        "kind": "reminder",
+    })
+
+    r = client.get("/notes/stats")
+    assert r.status_code == 200
+    stats = r.json()
+    assert stats["total"] == 2
+    assert stats["kinds"]["observation"] == 1
+    assert stats["kinds"]["reminder"] == 1
+
+    # The whole response body must not contain note text
+    body_text = r.text
+    assert "hedging" not in body_text
+    assert "supersede" not in body_text
+    assert "private thought" not in body_text
+
+
+def test_empty_content_rejected(client):
+    r = client.post("/notes", json={"content": "  "})
+    assert r.status_code == 400
+
+
+def test_missing_note_returns_404(client):
+    r = client.get("/notes/does-not-exist")
+    assert r.status_code == 404
+    r = client.delete("/notes/does-not-exist")
+    assert r.status_code == 404
+
+
+def test_root_advertises_ethos(client):
+    """The service's identity is in /. Validates ethos string didn't drift."""
+    r = client.get("/")
+    info = r.json()
+    assert info["name"] == "SerenMargin"
+    assert "opt-in by deploy" in info["ethos"]
+    assert info["stats_endpoint"] == "/notes/stats"