continuum-mcp-server 0.1.1__tar.gz

continuum_mcp_server-0.1.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: continuum-mcp-server
+Version: 0.1.1
+Summary: MCP server exposing Continuum decision tools
+License: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: continuum-sdk>=0.1.1
+Requires-Dist: mcp>=1.0

continuum_mcp_server-0.1.1/README.md

@@ -0,0 +1,22 @@
+# Continuum MCP Server
+
+MCP server exposing Continuum decision tools: inspect, resolve, enforce, commit, supersede.
+
+## Install
+
+```bash
+pip install continuum-mcp-server
+pip install "mcp>=1.0"
+```
+
+## Run
+
+```bash
+continuum-mcp serve
+```
+
+Point at a repo-local store:
+
+```bash
+CONTINUUM_STORE="/path/to/.continuum" continuum-mcp serve
+```

continuum_mcp_server-0.1.1/examples/smoke_test.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Manual MCP smoke test.
+
+This script starts the Continuum MCP server over stdio, calls a few tools,
+and verifies the repo-local store is consistent with the local SDK.
+
+Prereqs:
+  pip install continuum-mcp-server continuum-sdk "mcp>=1.0"
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+
+
+async def _run() -> int:
+    try:
+        from mcp import ClientSession, StdioServerParameters
+        from mcp.client.stdio import stdio_client
+    except Exception as exc:  # pragma: no cover
+        print("ERROR: Missing MCP client deps. Install with: pip install 'mcp>=1.0'")
+        print(f"Details: {exc}")
+        return 1
+
+    from continuum.client import ContinuumClient
+
+    with tempfile.TemporaryDirectory() as td:
+        store_dir = os.path.join(td, ".continuum")
+
+        server_params = StdioServerParameters(
+            command="python3",
+            args=["-m", "continuum_mcp.server", "serve"],
+            env={**os.environ, "CONTINUUM_STORE": store_dir},
+        )
+
+        async with stdio_client(server_params) as (read_stream, write_stream):
+            async with ClientSession(read_stream, write_stream) as session:
+                await session.initialize()
+
+                scope = "repo:smoke"
+
+                commit_res = await session.call_tool(
+                    "continuum_commit",
+                    {
+                        "title": "Reject full rewrites",
+                        "scope": scope,
+                        "decision_type": "rejection",
+                        "options": [
+                            {"title": "Incremental refactor", "selected": True},
+                            {
+                                "title": "Full rewrite",
+                                "selected": False,
+                                "rejected_reason": "Too risky",
+                            },
+                        ],
+                        "rationale": "Prefer incremental refactors.",
+                        "activate": True,
+                    },
+                )
+                print("commit:", commit_res)
+
+                inspect_res = await session.call_tool(
+                    "continuum_inspect",
+                    {"scope": scope},
+                )
+                print("inspect(scope):", inspect_res)
+
+                resolve_res = await session.call_tool(
+                    "continuum_resolve",
+                    {
+                        "prompt": "Reject full rewrites",
+                        "scope": scope,
+                    },
+                )
+                print("resolve:", resolve_res)
+
+                # Verify local SDK sees the same store.
+                client = ContinuumClient(storage_dir=store_dir)
+                binding = client.inspect(scope)
+                assert any(d["title"] == "Reject full rewrites" for d in binding)
+
+        print("SMOKE TEST PASSED")
+        return 0
+
+
+def main() -> None:
+    raise SystemExit(asyncio.run(_run()))
+
+
+if __name__ == "__main__":
+    main()
+

continuum_mcp_server-0.1.1/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68.0", "setuptools-scm>=8.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "continuum-mcp-server"
+version = "0.1.1"
+description = "MCP server exposing Continuum decision tools"
+requires-python = ">=3.10"
+license = {text = "Apache-2.0"}
+dependencies = [
+    "continuum-sdk>=0.1.1",
+    "mcp>=1.0",
+]
+
+[project.scripts]
+continuum-mcp = "continuum_mcp.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

continuum_mcp_server-0.1.1/setup.cfg

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

continuum_mcp_server-0.1.1/src/continuum_mcp/server.py

@@ -0,0 +1,389 @@
+"""Continuum MCP Server.
+
+Exposes Continuum decision operations as MCP tools:
+  - inspect: binding set by scope OR a decision by ID
+  - resolve: ambiguity gate against prior decisions
+  - enforce: enforcement verdict for a proposed action
+  - commit: persist a new decision (optionally activate)
+  - supersede: replace an existing decision with a new active one
+"""
+
+from __future__ import annotations
+
+import os
+import json
+import sys
+from typing import Any
+
+# SDK
+from continuum.client import ContinuumClient
+from continuum.exceptions import ContinuumError
+
+# ---------------------------------------------------------------------------
+# MCP SDK imports — gracefully degrade if not installed
+# ---------------------------------------------------------------------------
+try:
+    from mcp.server import Server
+    from mcp.types import Tool, TextContent
+
+    _HAS_MCP = True
+except ImportError:
+    _HAS_MCP = False
+
+# ---------------------------------------------------------------------------
+# Tool definitions
+# ---------------------------------------------------------------------------
+
+TOOLS: list[dict[str, Any]] = [
+    {
+        "name": "continuum_inspect",
+        "description": (
+            "Inspect Continuum decisions. Provide either `decision_id` to fetch a single decision, "
+            "or `scope` to fetch the active binding set for that scope."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "decision_id": {
+                    "type": "string",
+                    "description": "The unique decision identifier.",
+                },
+                "scope": {
+                    "type": "string",
+                    "description": "Scope to inspect (returns active binding set).",
+                },
+            },
+            "anyOf": [{"required": ["decision_id"]}, {"required": ["scope"]}],
+        },
+    },
+    {
+        "name": "continuum_resolve",
+        "description": (
+            "Check whether a prior decision already covers the given prompt and scope. "
+            "Returns resolved context or a needs_clarification signal."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "prompt": {
+                    "type": "string",
+                    "description": "The agent prompt to resolve against prior decisions.",
+                },
+                "scope": {
+                    "type": "string",
+                    "description": "Hierarchical scope identifier (e.g. repo:acme/backend).",
+                },
+                "candidates": {
+                    "type": "array",
+                    "description": "Optional candidate options (id, title) for disambiguation.",
+                    "items": {"type": "object"},
+                },
+            },
+            "required": ["prompt", "scope"],
+        },
+    },
+    {
+        "name": "continuum_enforce",
+        "description": (
+            "Evaluate enforcement rules for a proposed action in a scope. "
+            "Returns a verdict: allow, confirm, or block (deterministic)."
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "scope": {
+                    "type": "string",
+                    "description": "Scope to evaluate enforcement within.",
+                },
+                "action": {
+                    "type": "object",
+                    "description": "Proposed action (type, description, metadata).",
+                },
+            },
+            "required": ["scope", "action"],
+        },
+    },
+    {
+        "name": "continuum_commit",
+        "description": "Persist a new decision with title, scope, options, and rationale.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "title": {
+                    "type": "string",
+                    "description": "Short title describing the decision.",
+                },
+                "scope": {
+                    "type": "string",
+                    "description": "Hierarchical scope identifier.",
+                },
+                "decision_type": {
+                    "type": "string",
+                    "description": "Type of decision (e.g. rejection, selection).",
+                },
+                "options": {
+                    "type": "array",
+                    "description": "List of options considered.",
+                    "items": {"type": "object"},
+                },
+                "rationale": {
+                    "type": "string",
+                    "description": "Why this decision was made.",
+                },
+                "stakeholders": {
+                    "type": "array",
+                    "description": "Optional list of stakeholders.",
+                    "items": {"type": "string"},
+                },
+                "metadata": {
+                    "type": "object",
+                    "description": "Optional decision metadata.",
+                },
+                "override_policy": {
+                    "type": "string",
+                    "description": "Override policy: invalid_by_default | warn | allow",
+                },
+                "precedence": {
+                    "type": "integer",
+                    "description": "Optional precedence for conflict resolution.",
+                },
+                "supersedes": {
+                    "type": "string",
+                    "description": "Optional decision id this decision supersedes.",
+                },
+                "activate": {
+                    "type": "boolean",
+                    "description": "If true, transition the decision to active immediately.",
+                    "default": False,
+                },
+            },
+            "required": ["title", "scope", "decision_type", "rationale"],
+        },
+    },
+    {
+        "name": "continuum_supersede",
+        "description": "Supersede an existing decision by committing a replacement and activating it.",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "old_id": {
+                    "type": "string",
+                    "description": "ID of the decision being replaced.",
+                },
+                "new_title": {
+                    "type": "string",
+                    "description": "Title for the replacement decision.",
+                },
+                "rationale": {
+                    "type": "string",
+                    "description": "Rationale for the replacement decision.",
+                },
+                "options": {
+                    "type": "array",
+                    "description": "Optional list of options considered.",
+                    "items": {"type": "object"},
+                },
+                "stakeholders": {
+                    "type": "array",
+                    "description": "Optional list of stakeholders.",
+                    "items": {"type": "string"},
+                },
+                "metadata": {
+                    "type": "object",
+                    "description": "Optional decision metadata.",
+                },
+                "override_policy": {
+                    "type": "string",
+                    "description": "Override policy: invalid_by_default | warn | allow",
+                },
+                "precedence": {
+                    "type": "integer",
+                    "description": "Optional precedence for conflict resolution.",
+                },
+            },
+            "required": ["old_id", "new_title"],
+        },
+    },
+]
+
+# ---------------------------------------------------------------------------
+# Tool handlers
+# ---------------------------------------------------------------------------
+
+
+def _client() -> ContinuumClient:
+    storage_dir = os.environ.get("CONTINUUM_STORE")
+    return ContinuumClient(storage_dir=storage_dir) if storage_dir else ContinuumClient()
+
+
+def _ok(payload: Any) -> str:
+    return json.dumps({"status": "ok", "result": payload}, default=str)
+
+
+def _err(message: str) -> str:
+    return json.dumps({"status": "error", "error": message})
+
+
+def _handle_inspect(arguments: dict[str, Any]) -> str:
+    """Inspect by decision_id (single record) OR by scope (binding set)."""
+    try:
+        client = _client()
+        if "decision_id" in arguments and arguments["decision_id"]:
+            dec = client.get(str(arguments["decision_id"]))
+            return _ok(dec.model_dump(mode="json"))
+        if "scope" in arguments and arguments["scope"]:
+            binding = client.inspect(str(arguments["scope"]))
+            return _ok(binding)
+        return _err("Provide either 'decision_id' or 'scope'.")
+    except ContinuumError as exc:
+        return _err(str(exc))
+
+
+def _handle_resolve(arguments: dict[str, Any]) -> str:
+    """Resolve a prompt against prior decisions."""
+    try:
+        client = _client()
+        prompt = str(arguments.get("prompt", ""))
+        scope = str(arguments.get("scope", ""))
+        candidates = arguments.get("candidates")
+        result = client.resolve(query=prompt, scope=scope, candidates=candidates)
+        return _ok(result)
+    except ContinuumError as exc:
+        return _err(str(exc))
+
+
+def _handle_enforce(arguments: dict[str, Any]) -> str:
+    """Enforce rules for a proposed action within a scope."""
+    try:
+        client = _client()
+        scope = str(arguments.get("scope", ""))
+        action = arguments.get("action") or {}
+        result = client.enforce(action=action, scope=scope)
+        return _ok(result)
+    except ContinuumError as exc:
+        return _err(str(exc))
+
+
+def _handle_commit(arguments: dict[str, Any]) -> str:
+    """Commit a new decision."""
+    try:
+        client = _client()
+        dec = client.commit(
+            title=str(arguments["title"]),
+            scope=str(arguments["scope"]),
+            decision_type=str(arguments["decision_type"]),
+            options=arguments.get("options"),
+            rationale=arguments.get("rationale"),
+            stakeholders=arguments.get("stakeholders"),
+            metadata=arguments.get("metadata"),
+            override_policy=arguments.get("override_policy"),
+            precedence=arguments.get("precedence"),
+            supersedes=arguments.get("supersedes"),
+        )
+        if arguments.get("activate"):
+            dec = client.update_status(dec.id, "active")
+        return _ok(dec.model_dump(mode="json"))
+    except (KeyError, TypeError) as exc:
+        return _err(f"Invalid arguments: {exc}")
+    except ContinuumError as exc:
+        return _err(str(exc))
+
+
+def _handle_supersede(arguments: dict[str, Any]) -> str:
+    """Supersede an existing decision."""
+    try:
+        client = _client()
+        dec = client.supersede(
+            old_id=str(arguments["old_id"]),
+            new_title=str(arguments["new_title"]),
+            rationale=arguments.get("rationale"),
+            options=arguments.get("options"),
+            stakeholders=arguments.get("stakeholders"),
+            metadata=arguments.get("metadata"),
+            override_policy=arguments.get("override_policy"),
+            precedence=arguments.get("precedence"),
+        )
+        return _ok(dec.model_dump(mode="json"))
+    except (KeyError, TypeError) as exc:
+        return _err(f"Invalid arguments: {exc}")
+    except ContinuumError as exc:
+        return _err(str(exc))
+
+
+_HANDLERS: dict[str, Any] = {
+    "continuum_inspect": _handle_inspect,
+    "continuum_resolve": _handle_resolve,
+    "continuum_enforce": _handle_enforce,
+    "continuum_commit": _handle_commit,
+    "continuum_supersede": _handle_supersede,
+}
+
+# ---------------------------------------------------------------------------
+# Server setup
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    """Entry point for the `continuum-mcp` console script.
+
+    Usage:
+        continuum-mcp serve
+
+    Environment:
+        CONTINUUM_STORE=/path/to/.continuum
+    """
+    # Minimal CLI wrapper (avoid extra deps).
+    cmd = sys.argv[1] if len(sys.argv) > 1 else "serve"
+    if cmd in ("-h", "--help", "help"):
+        print(
+            "Continuum MCP Server\n\n"
+            "Usage:\n"
+            "  continuum-mcp serve\n\n"
+            "Environment:\n"
+            "  CONTINUUM_STORE   Path to repo-local .continuum directory\n",
+            file=sys.stdout,
+        )
+        return
+    if cmd != "serve":
+        print(f"Unknown command: {cmd}\nRun: continuum-mcp --help", file=sys.stderr)
+        sys.exit(2)
+
+    serve()
+
+
+def serve() -> None:
+    """Start the Continuum MCP server (stdio transport)."""
+    if not _HAS_MCP:
+        print(
+            "ERROR: The 'mcp' package is not installed. "
+            "Install it with: pip install 'mcp>=1.0'",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    server = Server("continuum-mcp")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [Tool(**t) for t in TOOLS]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
+        handler = _HANDLERS.get(name)
+        if handler is None:
+            return [TextContent(type="text", text=f"Unknown tool: {name}")]
+        result = handler(arguments)
+        return [TextContent(type="text", text=result)]
+
+    import asyncio
+    from mcp.server.stdio import stdio_server
+
+    async def _run() -> None:
+        async with stdio_server() as (read_stream, write_stream):
+            await server.run(read_stream, write_stream)
+
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    main()

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: continuum-mcp-server
+Version: 0.1.1
+Summary: MCP server exposing Continuum decision tools
+License: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: continuum-sdk>=0.1.1
+Requires-Dist: mcp>=1.0

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+examples/smoke_test.py
+src/continuum_mcp/__init__.py
+src/continuum_mcp/server.py
+src/continuum_mcp_server.egg-info/PKG-INFO
+src/continuum_mcp_server.egg-info/SOURCES.txt
+src/continuum_mcp_server.egg-info/dependency_links.txt
+src/continuum_mcp_server.egg-info/entry_points.txt
+src/continuum_mcp_server.egg-info/requires.txt
+src/continuum_mcp_server.egg-info/top_level.txt
+tests/test_mcp_e2e.py

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+continuum-mcp = continuum_mcp.server:main

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/requires.txt

@@ -0,0 +1,2 @@
+continuum-sdk>=0.1.1
+mcp>=1.0

continuum_mcp_server-0.1.1/src/continuum_mcp_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+continuum_mcp

continuum_mcp_server-0.1.1/tests/test_mcp_e2e.py

@@ -0,0 +1,305 @@
+"""End-to-end tests for the Continuum MCP server.
+
+These tests exercise the MCP tool handlers directly (no stdio transport)
+against a temporary store directory, covering the full lifecycle:
+  commit -> inspect -> resolve -> enforce -> supersede
+"""
+
+from __future__ import annotations
+
+import json
+import os
+
+import pytest
+
+# Import handlers directly for fast, reliable testing without MCP transport.
+from continuum_mcp.server import (
+    _handle_commit,
+    _handle_enforce,
+    _handle_inspect,
+    _handle_resolve,
+    _handle_supersede,
+)
+
+
+@pytest.fixture(autouse=True)
+def _use_temp_store(tmp_path, monkeypatch):
+    """Point the MCP server at a temp store."""
+    store = str(tmp_path / ".continuum")
+    monkeypatch.setenv("CONTINUUM_STORE", store)
+
+
+def _parse(result: str) -> dict:
+    """Parse a handler JSON response."""
+    data = json.loads(result)
+    assert data["status"] == "ok", f"Handler error: {data.get('error')}"
+    return data["result"]
+
+
+def _parse_err(result: str) -> str:
+    """Parse a handler error response."""
+    data = json.loads(result)
+    assert data["status"] == "error"
+    return data["error"]
+
+
+# ------------------------------------------------------------------
+# commit
+# ------------------------------------------------------------------
+
+
+class TestCommit:
+    def test_basic_commit(self):
+        result = _parse(_handle_commit({
+            "title": "Test decision",
+            "scope": "repo:test",
+            "decision_type": "rejection",
+            "rationale": "For testing.",
+        }))
+        assert result["title"] == "Test decision"
+        assert result["id"].startswith("dec_")
+        assert result["status"] == "draft"
+
+    def test_commit_with_activate(self):
+        result = _parse(_handle_commit({
+            "title": "Active decision",
+            "scope": "repo:test",
+            "decision_type": "preference",
+            "rationale": "Immediately active.",
+            "activate": True,
+        }))
+        assert result["status"] == "active"
+
+    def test_commit_with_options(self):
+        result = _parse(_handle_commit({
+            "title": "With options",
+            "scope": "repo:test",
+            "decision_type": "rejection",
+            "rationale": "Testing options.",
+            "options": [
+                {"title": "A", "selected": True},
+                {"title": "B", "selected": False, "rejected_reason": "Not chosen"},
+            ],
+        }))
+        assert len(result["options_considered"]) == 2
+
+    def test_commit_with_full_params(self):
+        result = _parse(_handle_commit({
+            "title": "Full params",
+            "scope": "repo:test",
+            "decision_type": "interpretation",
+            "rationale": "Testing all params.",
+            "stakeholders": ["alice", "bob"],
+            "metadata": {"team": "platform"},
+            "override_policy": "warn",
+            "precedence": 10,
+        }))
+        assert result["stakeholders"] == ["alice", "bob"]
+        assert result["metadata"]["team"] == "platform"
+
+    def test_commit_missing_required(self):
+        raw = _handle_commit({"title": "Missing scope"})
+        data = json.loads(raw)
+        assert data["status"] == "error"
+
+
+# ------------------------------------------------------------------
+# inspect
+# ------------------------------------------------------------------
+
+
+class TestInspect:
+    def test_inspect_by_id(self):
+        dec = _parse(_handle_commit({
+            "title": "Inspectable",
+            "scope": "repo:test",
+            "decision_type": "rejection",
+            "rationale": "For inspect test.",
+        }))
+        result = _parse(_handle_inspect({"decision_id": dec["id"]}))
+        assert result["id"] == dec["id"]
+
+    def test_inspect_by_scope(self):
+        _parse(_handle_commit({
+            "title": "Scope inspect",
+            "scope": "repo:inspect-scope",
+            "decision_type": "rejection",
+            "rationale": "For scope test.",
+            "activate": True,
+        }))
+        result = _parse(_handle_inspect({"scope": "repo:inspect-scope"}))
+        assert isinstance(result, list)
+        assert len(result) >= 1
+
+    def test_inspect_no_args(self):
+        err = _parse_err(_handle_inspect({}))
+        assert "Provide either" in err
+
+    def test_inspect_nonexistent_id(self):
+        err = _parse_err(_handle_inspect({"decision_id": "dec_nonexistent"}))
+        assert "not found" in err.lower()
+
+
+# ------------------------------------------------------------------
+# resolve
+# ------------------------------------------------------------------
+
+
+class TestResolve:
+    def test_resolve_no_decisions(self):
+        result = _parse(_handle_resolve({
+            "prompt": "something new",
+            "scope": "repo:test",
+        }))
+        assert "status" in result
+
+    def test_resolve_with_matching_decision(self):
+        _parse(_handle_commit({
+            "title": "Reject full rewrites",
+            "scope": "repo:resolve-test",
+            "decision_type": "rejection",
+            "rationale": "Too risky.",
+            "activate": True,
+        }))
+        result = _parse(_handle_resolve({
+            "prompt": "Reject full rewrites",
+            "scope": "repo:resolve-test",
+        }))
+        assert result["status"] == "resolved"
+
+    def test_resolve_with_candidates(self):
+        result = _parse(_handle_resolve({
+            "prompt": "Pick approach",
+            "scope": "repo:test",
+            "candidates": [
+                {"id": "a", "title": "Approach A"},
+                {"id": "b", "title": "Approach B"},
+            ],
+        }))
+        assert "status" in result
+
+
+# ------------------------------------------------------------------
+# enforce
+# ------------------------------------------------------------------
+
+
+class TestEnforce:
+    def test_enforce_no_decisions(self):
+        result = _parse(_handle_enforce({
+            "scope": "repo:test",
+            "action": {"type": "code_change", "description": "minor fix"},
+        }))
+        assert "verdict" in result
+
+    def test_enforce_with_rejection(self):
+        _parse(_handle_commit({
+            "title": "Reject full rewrites",
+            "scope": "repo:enforce-test",
+            "decision_type": "rejection",
+            "rationale": "Too risky.",
+            "options": [
+                {"title": "Incremental refactor", "selected": True},
+                {"title": "Full rewrite", "selected": False, "rejected_reason": "Too risky"},
+            ],
+            "activate": True,
+        }))
+        result = _parse(_handle_enforce({
+            "scope": "repo:enforce-test",
+            "action": {"type": "code_change", "description": "Do a full rewrite of auth"},
+        }))
+        assert "verdict" in result
+
+
+# ------------------------------------------------------------------
+# supersede
+# ------------------------------------------------------------------
+
+
+class TestSupersede:
+    def test_supersede_lifecycle(self):
+        # Commit and activate
+        dec = _parse(_handle_commit({
+            "title": "V1 decision",
+            "scope": "repo:supersede-test",
+            "decision_type": "rejection",
+            "rationale": "Original.",
+            "activate": True,
+        }))
+        assert dec["status"] == "active"
+
+        # Supersede
+        new_dec = _parse(_handle_supersede({
+            "old_id": dec["id"],
+            "new_title": "V2 decision",
+            "rationale": "Updated approach.",
+        }))
+        assert new_dec["title"] == "V2 decision"
+        assert new_dec["status"] == "active"
+
+        # Verify old is superseded
+        old = _parse(_handle_inspect({"decision_id": dec["id"]}))
+        assert old["status"] == "superseded"
+
+    def test_supersede_nonexistent(self):
+        err = _parse_err(_handle_supersede({
+            "old_id": "dec_nonexistent",
+            "new_title": "Won't work",
+        }))
+        assert "not found" in err.lower()
+
+
+# ------------------------------------------------------------------
+# Full lifecycle (integration)
+# ------------------------------------------------------------------
+
+
+class TestFullLifecycle:
+    def test_commit_inspect_resolve_enforce_supersede(self):
+        scope = "repo:lifecycle"
+
+        # 1. Commit
+        dec = _parse(_handle_commit({
+            "title": "Reject full rewrites",
+            "scope": scope,
+            "decision_type": "rejection",
+            "rationale": "Too risky.",
+            "options": [
+                {"title": "Incremental refactor", "selected": True},
+                {"title": "Full rewrite", "selected": False, "rejected_reason": "Too risky"},
+            ],
+            "activate": True,
+        }))
+        dec_id = dec["id"]
+
+        # 2. Inspect by scope
+        binding = _parse(_handle_inspect({"scope": scope}))
+        assert any(d["id"] == dec_id for d in binding)
+
+        # 3. Resolve
+        resolved = _parse(_handle_resolve({
+            "prompt": "Reject full rewrites",
+            "scope": scope,
+        }))
+        assert resolved["status"] == "resolved"
+
+        # 4. Enforce
+        enforcement = _parse(_handle_enforce({
+            "scope": scope,
+            "action": {"type": "code_change", "description": "full rewrite"},
+        }))
+        assert "verdict" in enforcement
+
+        # 5. Supersede
+        new_dec = _parse(_handle_supersede({
+            "old_id": dec_id,
+            "new_title": "V2: Allow rewrites for tests only",
+            "rationale": "Relaxed policy for test modules.",
+        }))
+        assert new_dec["status"] == "active"
+
+        # 6. Verify final state
+        final_binding = _parse(_handle_inspect({"scope": scope}))
+        active_ids = [d["id"] for d in final_binding]
+        assert new_dec["id"] in active_ids
+        assert dec_id not in active_ids  # Old decision should be superseded