@synapsor/runner 0.1.0-alpha.9 → 0.1.1

package/examples/openai-agents-http/README.md

@@ -1,21 +1,39 @@
-# OpenAI Agents SDK + Synapsor Runner over HTTP
+# OpenAI Agents SDK + Synapsor Runner Streamable HTTP MCP
 
-This example shows an OpenAI Agents SDK app calling a long-running Synapsor
-Runner HTTP MCP service.
+This example shows an OpenAI Agents SDK app connecting to a long-running
+Synapsor Runner Streamable HTTP MCP server.
 
 Use HTTP when your agent runs as an app/server and should connect to Runner
 over a local/private network endpoint instead of launching a stdio child
 process.
 
-Runner's HTTP alpha endpoint is a small authenticated JSON-RPC surface for
-`tools/list`, `tools/call`, and `resources/read`. It is not the full MCP
-Streamable HTTP transport and does not implement `initialize`/SSE. This example
-therefore uses the OpenAI Agents SDK for the agent and wraps Synapsor's HTTP
-JSON-RPC endpoint as an OpenAI function tool.
+This example uses `synapsor-runner mcp serve-streamable-http`, the
+spec-compatible HTTP MCP transport with `initialize` and session behavior. Use
+`synapsor-runner mcp serve-http` only when you intentionally want the smaller
+JSON-RPC bridge and an app-owned wrapper.
+
+OpenAI function names cannot contain dots, so start Runner with
+`--alias-mode openai`. The model sees aliases such as
+`billing__inspect_invoice`; Runner keeps `billing.inspect_invoice` in MCP
+metadata and maps calls back to the canonical Synapsor capability.
 
 The model still sees a semantic action. It does not receive raw SQL, database
 URLs, write credentials, approval tools, or commit tools.
 
+## Smoke Check
+
+Run this without an OpenAI API key:
+
+```bash
+make smoke
+```
+
+Expected output:
+
+```text
+OpenAI Agents Streamable HTTP example smoke passed.
+```
+
 ## Terminal 1: Start Synapsor Runner HTTP MCP
 
 ```bash
@@ -24,10 +42,11 @@ export SYNAPSOR_TENANT_ID="acme"
 export SYNAPSOR_PRINCIPAL="openai_agent_demo"
 export SYNAPSOR_RUNNER_HTTP_TOKEN="dev-token"
 
-npx -y -p @synapsor/runner@alpha synapsor-runner mcp serve-http \
+npx -y -p @synapsor/runner synapsor-runner mcp serve-streamable-http \
   --config ./synapsor.runner.json \
   --store ./.synapsor/local.db \
-  --auth-token-env SYNAPSOR_RUNNER_HTTP_TOKEN
+  --auth-token-env SYNAPSOR_RUNNER_HTTP_TOKEN \
+  --alias-mode openai
 ```
 
 ## Terminal 2: Run The Agent
@@ -38,7 +57,7 @@ python -m venv .venv
 pip install -r requirements.txt
 
 export OPENAI_API_KEY="..."
-export SYNAPSOR_RUNNER_HTTP_URL="http://127.0.0.1:8765/mcp"
+export SYNAPSOR_RUNNER_HTTP_URL="http://127.0.0.1:8766/mcp"
 export SYNAPSOR_RUNNER_HTTP_TOKEN="dev-token"
 export SYNAPSOR_INVOICE_ID="INV-3001"
 
@@ -47,7 +66,9 @@ python agent.py
 
 Expected behavior:
 
-- the agent calls `billing.inspect_invoice` through Synapsor HTTP MCP;
+- the agent calls the OpenAI-safe alias `billing__inspect_invoice` through
+  Synapsor HTTP MCP;
+- Runner maps that alias back to canonical `billing.inspect_invoice`;
 - Synapsor applies trusted tenant/principal context from the server process;
 - the response includes scoped data and evidence handles;
 - no SQL/write/approval tool is exposed to the model;

package/examples/openai-agents-http/agent.py

@@ -1,63 +1,17 @@
 import asyncio
-import json
 import os
 import sys
-import urllib.error
-import urllib.request
 
 try:
-    from agents import Agent, Runner, function_tool
+    from agents import Agent, Runner
+    from agents.mcp import MCPServerStreamableHttp
 except ImportError as exc:
     raise SystemExit(
-        "This example requires the OpenAI Agents SDK. "
+        "This example requires the OpenAI Agents SDK with Streamable HTTP MCP support. "
         "Install with: pip install -r requirements.txt"
     ) from exc
 
 
-def call_synapsor_http_mcp(method: str, params: dict) -> dict:
-    url = os.environ.get("SYNAPSOR_RUNNER_HTTP_URL", "http://127.0.0.1:8765/mcp")
-    token = os.environ.get("SYNAPSOR_RUNNER_HTTP_TOKEN")
-    if not token:
-        raise RuntimeError("SYNAPSOR_RUNNER_HTTP_TOKEN is not set")
-
-    payload = json.dumps({
-        "jsonrpc": "2.0",
-        "id": 1,
-        "method": method,
-        "params": params,
-    }).encode("utf-8")
-    request = urllib.request.Request(
-        url,
-        data=payload,
-        method="POST",
-        headers={
-            "authorization": f"Bearer {token}",
-            "content-type": "application/json",
-        },
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=15) as response:
-            body = response.read().decode("utf-8")
-    except urllib.error.HTTPError as exc:
-        body = exc.read().decode("utf-8")
-        raise RuntimeError(f"Synapsor HTTP MCP returned HTTP {exc.code}: {body}") from exc
-
-    parsed = json.loads(body)
-    if "error" in parsed:
-        raise RuntimeError(f"Synapsor HTTP MCP error: {parsed['error']}")
-    return parsed["result"]
-
-
-@function_tool
-def billing_inspect_invoice(invoice_id: str) -> str:
-    """Inspect one scoped invoice through Synapsor Runner HTTP MCP."""
-    result = call_synapsor_http_mcp("tools/call", {
-        "name": "billing.inspect_invoice",
-        "arguments": {"invoice_id": invoice_id},
-    })
-    return json.dumps(result.get("structuredContent", result), indent=2)
-
-
 async def main() -> None:
     required = ["OPENAI_API_KEY", "SYNAPSOR_RUNNER_HTTP_URL", "SYNAPSOR_RUNNER_HTTP_TOKEN"]
     missing = [name for name in required if not os.environ.get(name)]
@@ -65,22 +19,32 @@ async def main() -> None:
         raise SystemExit(f"Missing required environment variables: {', '.join(missing)}")
 
     invoice_id = os.environ.get("SYNAPSOR_INVOICE_ID", "INV-3001")
-    agent = Agent(
-        name="Synapsor HTTP MCP demo agent",
-        instructions=(
-            "Use the billing_inspect_invoice tool to inspect scoped invoice data. "
-            "Do not claim that you can run SQL, approve proposals, or commit writes."
-        ),
-        tools=[billing_inspect_invoice],
-    )
-    result = await Runner.run(
-        agent,
-        (
-            f"Inspect invoice {invoice_id} using Synapsor. "
-            "Explain what you saw and whether you have write authority."
-        ),
-    )
-    print(result.final_output)
+    mcp_url = os.environ["SYNAPSOR_RUNNER_HTTP_URL"]
+    token = os.environ["SYNAPSOR_RUNNER_HTTP_TOKEN"]
+
+    async with MCPServerStreamableHttp(
+        params={
+            "url": mcp_url,
+            "headers": {"Authorization": f"Bearer {token}"},
+            "timeout": 15,
+        }
+    ) as mcp_server:
+        agent = Agent(
+            name="Synapsor Streamable HTTP MCP demo agent",
+            instructions=(
+                "Use Synapsor MCP tools to inspect scoped database data. "
+                "Do not claim that you can run SQL, approve proposals, or commit writes."
+            ),
+            mcp_servers=[mcp_server],
+        )
+        result = await Runner.run(
+            agent,
+            (
+                f"Inspect invoice {invoice_id} using Synapsor. "
+                "Explain what you saw and whether you have write authority."
+            ),
+        )
+        print(result.final_output)
 
 
 if __name__ == "__main__":

package/examples/openai-agents-stdio/Makefile

@@ -0,0 +1,6 @@
+.PHONY: smoke
+
+smoke:
+	python3 -m py_compile agent.py
+	npx -y -p @synapsor/runner synapsor-runner mcp serve --help >/dev/null
+	@printf '%s\n' "OpenAI Agents stdio example smoke passed."

package/examples/openai-agents-stdio/README.md

@@ -4,22 +4,39 @@ This example shows an OpenAI Agents SDK app launching Synapsor Runner as a
 local stdio MCP server.
 
 Use stdio when the agent process can start the MCP server on the same machine.
-The model sees Synapsor semantic tools such as `billing.inspect_invoice`. It
+The model sees Synapsor semantic tools through OpenAI-safe aliases such as
+`billing__inspect_invoice`. Runner keeps the canonical Synapsor capability
+name, such as `billing.inspect_invoice`, in MCP metadata and maps calls back to
+it. The model
 does not receive raw SQL, database URLs, write credentials, approval tools, or
 commit tools.
 
+## Smoke Check
+
+Run this without an OpenAI API key:
+
+```bash
+make smoke
+```
+
+Expected output:
+
+```text
+OpenAI Agents stdio example smoke passed.
+```
+
 ## Prerequisites
 
 Generate `synapsor.runner.json` first:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner demo
+npx -y -p @synapsor/runner synapsor-runner demo
 ```
 
 or connect your own staging database:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner init --wizard --from-env DATABASE_URL --mode read_only
+npx -y -p @synapsor/runner synapsor-runner onboard db --from-env DATABASE_URL
 ```
 
 Then install the Python dependencies:
@@ -52,11 +69,12 @@ export SYNAPSOR_INVOICE_ID="INV-3001"
 
 Expected behavior:
 
-- the agent can inspect the scoped invoice through Synapsor;
+- the agent can inspect the scoped invoice through Synapsor using an
+  OpenAI-safe tool alias;
+- Runner maps the alias back to the canonical Synapsor capability;
 - the agent cannot run SQL;
 - the agent cannot approve or commit writes;
 - evidence/query audit are saved in the local Runner store.
 
 If your installed OpenAI Agents SDK does not expose `MCPServerStdio`, update the
-SDK or use the HTTP example, which wraps Synapsor HTTP MCP with a small JSON-RPC
-client.
+SDK or use the Streamable HTTP example.

package/examples/openai-agents-stdio/agent.py

@@ -27,14 +27,16 @@ async def main() -> None:
         "args": [
             "-y",
             "-p",
-            "@synapsor/runner@alpha",
-            "synapsor",
+            "@synapsor/runner",
+            "synapsor-runner",
             "mcp",
             "serve",
             "--config",
             config_path,
             "--store",
             store_path,
+            "--alias-mode",
+            "openai",
         ],
         "env": {
             **os.environ,

package/examples/raw-sql-vs-synapsor/Makefile

@@ -0,0 +1,11 @@
+.PHONY: demo
+
+demo:
+	@printf '%s\n' "Unsafe shortcut:"
+	@printf '%s\n' '  agent -> execute_sql("UPDATE invoices SET late_fee_cents = 0 ...")'
+	@printf '%s\n' ""
+	@printf '%s\n' "Synapsor quick proof:"
+	npx -y @synapsor/runner demo --quick --no-interactive
+	@printf '%s\n' ""
+	@printf '%s\n' "Risk audit example:"
+	npx -y @synapsor/runner audit --example dangerous-db-mcp --format markdown

package/examples/raw-sql-vs-synapsor/README.md

@@ -0,0 +1,41 @@
+# Raw SQL vs Synapsor
+
+This minimal example shows the fear and the fix without requiring Docker, an
+agent SDK, or a database.
+
+## Run
+
+```bash
+make demo
+```
+
+Expected output includes:
+
+```text
+execute_sql
+Synapsor quick demo complete.
+proposal created
+source DB changed: no
+approval required outside MCP
+```
+
+The raw-SQL shortcut is:
+
+```text
+agent -> execute_sql("UPDATE invoices SET late_fee_cents = 0 ...")
+```
+
+The Synapsor path is:
+
+```text
+agent -> billing.propose_late_fee_waiver(...)
+human approves outside MCP
+guarded writeback applies exactly one row
+replay records what happened
+```
+
+## Why This Exists
+
+Use this folder when you want to show the core idea quickly. It is not a full
+database fixture; the full support/billing walkthrough lives in
+`../support-billing-agent/`.

package/examples/reference-support-billing-app/README.md

@@ -36,14 +36,14 @@ examples/reference-support-billing-app/scripts/run-demo.sh
 Validate the reviewed contract:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner config validate --config examples/reference-support-billing-app/synapsor.runner.json
-npx -y -p @synapsor/runner@alpha synapsor-runner doctor --config examples/reference-support-billing-app/synapsor.runner.json
+npx -y -p @synapsor/runner synapsor-runner config validate --config examples/reference-support-billing-app/synapsor.runner.json
+npx -y -p @synapsor/runner synapsor-runner doctor --config examples/reference-support-billing-app/synapsor.runner.json
 ```
 
 Serve MCP:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner mcp serve \
+npx -y -p @synapsor/runner synapsor-runner mcp serve \
   --config examples/reference-support-billing-app/synapsor.runner.json \
   --store ./tmp/reference-support-billing/local.db
 ```
@@ -69,11 +69,11 @@ After `synapsor-runner demo` or after starting this fixture manually, try the sa
 proposal-first loop without connecting an MCP client:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner propose billing.propose_late_fee_waiver --sample
-npx -y -p @synapsor/runner@alpha synapsor-runner proposals show latest
-npx -y -p @synapsor/runner@alpha synapsor-runner proposals approve latest --yes
-npx -y -p @synapsor/runner@alpha synapsor-runner apply latest
-npx -y -p @synapsor/runner@alpha synapsor-runner replay latest
+npx -y -p @synapsor/runner synapsor-runner propose billing.propose_late_fee_waiver --sample
+npx -y -p @synapsor/runner synapsor-runner proposals show latest
+npx -y -p @synapsor/runner synapsor-runner proposals approve latest --yes
+npx -y -p @synapsor/runner synapsor-runner apply latest
+npx -y -p @synapsor/runner synapsor-runner replay latest
 ```
 
 Expected safety output:
@@ -93,8 +93,8 @@ Guarded writeback applied.
 Other proposal examples use the same review/apply/replay path:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner propose support.propose_plan_credit --sample
-npx -y -p @synapsor/runner@alpha synapsor-runner propose orders.propose_status_change --sample
+npx -y -p @synapsor/runner synapsor-runner propose support.propose_plan_credit --sample
+npx -y -p @synapsor/runner synapsor-runner propose orders.propose_status_change --sample
 ```
 
 Safety guarantees:
@@ -115,17 +115,17 @@ or production-scale runner orchestration.
 After a proposal exists:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner proposals list --store ./tmp/reference-support-billing/local.db
-npx -y -p @synapsor/runner@alpha synapsor-runner proposals approve <proposal_id> --store ./tmp/reference-support-billing/local.db --actor local_reviewer --yes
-npx -y -p @synapsor/runner@alpha synapsor-runner proposals writeback-job <proposal_id> --store ./tmp/reference-support-billing/local.db --output ./tmp/reference-support-billing/job.json
-npx -y -p @synapsor/runner@alpha synapsor-runner apply --job ./tmp/reference-support-billing/job.json --store ./tmp/reference-support-billing/local.db
-npx -y -p @synapsor/runner@alpha synapsor-runner replay export <proposal_id> --store ./tmp/reference-support-billing/local.db --output ./tmp/reference-support-billing/replay.json
+npx -y -p @synapsor/runner synapsor-runner proposals list --store ./tmp/reference-support-billing/local.db
+npx -y -p @synapsor/runner synapsor-runner proposals approve <proposal_id> --store ./tmp/reference-support-billing/local.db --actor local_reviewer --yes
+npx -y -p @synapsor/runner synapsor-runner proposals writeback-job <proposal_id> --store ./tmp/reference-support-billing/local.db --output ./tmp/reference-support-billing/job.json
+npx -y -p @synapsor/runner synapsor-runner apply --job ./tmp/reference-support-billing/job.json --store ./tmp/reference-support-billing/local.db
+npx -y -p @synapsor/runner synapsor-runner replay export <proposal_id> --store ./tmp/reference-support-billing/local.db --output ./tmp/reference-support-billing/replay.json
 ```
 
 To inspect locally in a browser:
 
 ```bash
-npx -y -p @synapsor/runner@alpha synapsor-runner ui \
+npx -y -p @synapsor/runner synapsor-runner ui \
   --config examples/reference-support-billing-app/synapsor.runner.json \
   --store ./tmp/reference-support-billing/local.db
 ```

package/examples/reference-support-billing-app/mcp-client.generic.json

@@ -1,5 +1,5 @@
 {
-  "command": "synapsor",
+  "command": "synapsor-runner",
   "args": [
     "mcp",
     "serve",

package/examples/support-billing-agent/Makefile

@@ -0,0 +1,19 @@
+.PHONY: demo unsafe clean
+
+demo:
+	cd ../.. && examples/support-billing-agent/scripts/run-demo.sh
+
+unsafe:
+	@printf '%s\n' "Unsafe raw-SQL shortcut this demo avoids:"
+	@printf '%s\n' ""
+	@printf '%s\n' '  agent -> execute_sql("UPDATE invoices SET late_fee_cents = 0 WHERE status = '\''overdue'\''")'
+	@printf '%s\n' ""
+	@printf '%s\n' "Why it is risky:"
+	@printf '%s\n' "  - the model controls SQL shape and scope"
+	@printf '%s\n' "  - tenant filters can be omitted or hallucinated"
+	@printf '%s\n' "  - there is no proposal, approval boundary, conflict receipt, or replay"
+	@printf '%s\n' ""
+	@printf '%s\n' "Run 'make demo' to see the Synapsor path: semantic tool -> proposal -> approval -> guarded writeback -> replay."
+
+clean:
+	docker compose down -v --remove-orphans

package/examples/support-billing-agent/README.md

@@ -0,0 +1,89 @@
+# Support/Billing Agent Demo
+
+This is the flagship Synapsor Runner demo.
+
+It uses a disposable Postgres support/billing app and shows the full loop:
+
+```text
+agent inspects scoped evidence
+-> agent creates a proposal
+-> source database is unchanged
+-> human approves outside MCP
+-> guarded writeback applies exactly one row
+-> replay shows evidence, diff, approval, receipt, and conflict behavior
+```
+
+## Run It
+
+From this folder:
+
+```bash
+make demo
+```
+
+Expected end state:
+
+```text
+Reference support/billing app smoke passed.
+```
+
+The model-facing tools are exactly:
+
+- `support.inspect_ticket`
+- `support.propose_plan_credit`
+- `billing.inspect_invoice`
+- `billing.propose_late_fee_waiver`
+
+The demo proves:
+
+- the model-facing tool list contains semantic capabilities such as
+  `billing.inspect_invoice` and `billing.propose_late_fee_waiver`;
+- the model does not receive `execute_sql`, approval tools, commit/apply tools,
+  database URLs, write credentials, arbitrary table names, arbitrary column
+  names, or tenant authority;
+- proposals do not mutate the source database;
+- approved writeback uses tenant, primary-key, allowed-column,
+  idempotency, and `updated_at` conflict guards;
+- replay contains the evidence and writeback receipt.
+
+## Compare The Unsafe Shortcut
+
+To see why the boundary matters:
+
+```bash
+make unsafe
+```
+
+That target prints the raw-SQL shape this demo avoids. It does not mutate the
+fixture; it shows the path an MCP client should not expose to the model:
+
+```text
+execute_sql("UPDATE invoices SET late_fee_cents = 0 ...")
+```
+
+Use `make demo` for the real proposal, approval, writeback, idempotent retry,
+stale-row conflict, and replay proof.
+
+## What This Wraps
+
+This folder is self-contained for readers and agents looking for the canonical
+support/billing demo. The smoke logic is shared with the reference fixture so
+the product-facing walkthrough and package tests exercise the same safety
+checks.
+
+Relevant files:
+
+- `db/schema.sql`
+- `db/seed.sql`
+- `synapsor.runner.json`
+- `scripts/run-demo.sh`
+- `app/README.md`
+
+## Stop And Clean Up
+
+The demo script cleans up its disposable Docker database automatically. If you
+interrupt it, run:
+
+```bash
+make clean
+```

package/examples/support-billing-agent/app/README.md

@@ -0,0 +1,13 @@
+# App Surface
+
+This folder marks the customer application boundary for the flagship demo.
+
+The model talks to Synapsor Runner MCP tools. It does not receive application
+write credentials or direct SQL authority. After approval, the trusted runner
+uses the reviewed `synapsor.runner.json` contract to apply the one-row
+writeback with tenant, primary-key, allowed-column, idempotency, and
+`updated_at` conflict guards.
+
+For richer app actions, such as inserting a credit ledger row and emitting an
+event, use the app-owned handler examples in `../app-owned-writeback/` and
+`../mcp-postgres-billing-app-handler/`.

package/examples/support-billing-agent/db/schema.sql

@@ -0,0 +1,91 @@
+CREATE TABLE IF NOT EXISTS public.tenants (
+  id text PRIMARY KEY,
+  name text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.customers (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  name text NOT NULL,
+  email text,
+  plan text NOT NULL,
+  plan_credit_cents integer NOT NULL DEFAULT 0,
+  credit_reason text,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.support_tickets (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  customer_id text NOT NULL REFERENCES public.customers(id),
+  subject text NOT NULL,
+  status text NOT NULL,
+  resolution_note text,
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.invoices (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  customer_id text NOT NULL REFERENCES public.customers(id),
+  status text NOT NULL,
+  balance_cents integer NOT NULL,
+  late_fee_cents integer NOT NULL,
+  waiver_reason text,
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.credits (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  customer_id text NOT NULL REFERENCES public.customers(id),
+  invoice_id text REFERENCES public.invoices(id),
+  amount_cents integer NOT NULL,
+  reason text NOT NULL,
+  status text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now(),
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.agent_actions (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  action_type text NOT NULL,
+  target_type text NOT NULL,
+  target_id text NOT NULL,
+  proposal_id text,
+  status text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE IF NOT EXISTS public.orders (
+  id text PRIMARY KEY,
+  tenant_id text NOT NULL REFERENCES public.tenants(id),
+  customer_id text NOT NULL REFERENCES public.customers(id),
+  status text NOT NULL,
+  status_change_reason text,
+  updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+DO $$
+BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'synapsor_reader') THEN
+    CREATE ROLE synapsor_reader LOGIN PASSWORD 'synapsor_reader_password';
+  END IF;
+  IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'synapsor_writer') THEN
+    CREATE ROLE synapsor_writer LOGIN PASSWORD 'synapsor_writer_password';
+  END IF;
+END
+$$;
+
+GRANT CONNECT ON DATABASE synapsor_support_billing_agent TO synapsor_reader, synapsor_writer;
+GRANT USAGE ON SCHEMA public TO synapsor_reader, synapsor_writer;
+GRANT CREATE ON SCHEMA public TO synapsor_writer;
+GRANT SELECT ON public.tenants, public.customers, public.support_tickets, public.invoices, public.credits, public.agent_actions, public.orders TO synapsor_reader, synapsor_writer;
+GRANT UPDATE (plan_credit_cents, credit_reason, updated_at) ON public.customers TO synapsor_writer;
+GRANT UPDATE (status, resolution_note, updated_at) ON public.support_tickets TO synapsor_writer;
+GRANT UPDATE (late_fee_cents, waiver_reason, updated_at) ON public.invoices TO synapsor_writer;
+GRANT UPDATE (status, status_change_reason, updated_at) ON public.orders TO synapsor_writer;