champion-continuum 0.5.0__tar.gz

champion_continuum-0.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Champion Council / Continuum Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

champion_continuum-0.5.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: champion-continuum
+Version: 0.5.0
+Summary: Portable continuity and reacclimation memory primitive for agent runtimes.
+Author: Champion Council
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Yufok1/champion-continuum
+Project-URL: Source, https://github.com/Yufok1/champion-continuum
+Project-URL: Live Demo, https://huggingface.co/spaces/tostido/champion-continuum
+Project-URL: Repository, https://github.com/Yufok1/champion-continuum
+Keywords: ai,memory,continuity,agents,tool-less,relay,reacclimation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: httpx>=0.27.0
+Dynamic: license-file
+
+# Champion Continuum
+
+Champion Continuum is a small, local-first continuity primitive extracted from the active Champion Council server posture.
+
+It is not the full Champion Council backend. It is the portable memory and reacclimation layer that lets an agent:
+
+- store continuity notes as local records
+- search those records without a hosted service
+- scan local Codex session archives when available
+- emit a structured continuity packet
+- reconstitute a bundled Champion Council backend payload when the VM can run it
+
+The base memory and packet flow is local-first. MCP tool bridging adds runtime dependencies on `mcp` and `httpx`.
+
+## Quick Start
+
+```powershell
+pip install -e .
+continuum --root .continuum init
+continuum --root .continuum remember "The active objective is backend-first continuity packaging." --tag bootstrap
+continuum --root .continuum doctor
+continuum --root .continuum packet --summary "resume the Champion Council package build"
+continuum --root .continuum handoff --summary "browser agent audit"
+continuum --root .continuum receipt "quickstart smoke" --summary "Continuum initialized and packet emitted"
+```
+
+`--root` may appear before or after the subcommand. Set `CONTINUUM_ROOT` to pin one memory store across working directories.
+Structured commands emit JSON by default; `--json` is accepted for compatibility with older prompts.
+
+## Portable Contracts
+
+The bootstrap packet now carries a compact version of the Champion Council operating mechanics:
+
+- `query_thread`: the current subject/objective/seam and next reads
+- `output_state`: a bounded orienting surface over root status, archive status, memory hits, drift, and sources
+- `drift_classes`: `confirmed`, `partly_confirmed`, `mismatch`, `stale_state`, `gated`, `no_archive_match`
+- `failure_classes`: `truth`, `contract`, `transport`, `rendering`, `gating`, `stale_runtime_state`
+- `recovery_questions`: the six-question fallback loop for confused agents
+- `companion_packages`: optional detection for `cascade-lattice`, `quinesmith`, and `brotology-field-guide`
+- `receipt_protocol`: a simple local receipt rule for meaningful changes
+
+The package does not depend on those companion packages. It detects them when present and keeps working when absent.
+
+Print a system prompt for the model you are giving the bundle to:
+
+```powershell
+continuum system-prompt --profile portable
+continuum system-prompt --profile codex
+continuum system-prompt --profile tiny
+continuum system-prompt --profile no-tools
+```
+
+## Engine Payload
+
+The drop-in export folder includes a full Champion Council research-capsule payload zip beside this package. Use:
+
+```powershell
+continuum engine --payload ..\payloads\champion_council_research_capsule.zip --target ..\engine\champion-council --self-test
+```
+
+Add `--launch` only in an environment where the backend dependencies are installed or can be installed.
+
+## Design Rule
+
+Continuum follows the same rule as Champion Council:
+
+- archive continuity helps re-entry
+- live runtime truth outranks archive continuity
+- docs and memory are planning surfaces, not authority planes

champion_continuum-0.5.0/README.md

@@ -0,0 +1,69 @@
+# Champion Continuum
+
+Champion Continuum is a small, local-first continuity primitive extracted from the active Champion Council server posture.
+
+It is not the full Champion Council backend. It is the portable memory and reacclimation layer that lets an agent:
+
+- store continuity notes as local records
+- search those records without a hosted service
+- scan local Codex session archives when available
+- emit a structured continuity packet
+- reconstitute a bundled Champion Council backend payload when the VM can run it
+
+The base memory and packet flow is local-first. MCP tool bridging adds runtime dependencies on `mcp` and `httpx`.
+
+## Quick Start
+
+```powershell
+pip install -e .
+continuum --root .continuum init
+continuum --root .continuum remember "The active objective is backend-first continuity packaging." --tag bootstrap
+continuum --root .continuum doctor
+continuum --root .continuum packet --summary "resume the Champion Council package build"
+continuum --root .continuum handoff --summary "browser agent audit"
+continuum --root .continuum receipt "quickstart smoke" --summary "Continuum initialized and packet emitted"
+```
+
+`--root` may appear before or after the subcommand. Set `CONTINUUM_ROOT` to pin one memory store across working directories.
+Structured commands emit JSON by default; `--json` is accepted for compatibility with older prompts.
+
+## Portable Contracts
+
+The bootstrap packet now carries a compact version of the Champion Council operating mechanics:
+
+- `query_thread`: the current subject/objective/seam and next reads
+- `output_state`: a bounded orienting surface over root status, archive status, memory hits, drift, and sources
+- `drift_classes`: `confirmed`, `partly_confirmed`, `mismatch`, `stale_state`, `gated`, `no_archive_match`
+- `failure_classes`: `truth`, `contract`, `transport`, `rendering`, `gating`, `stale_runtime_state`
+- `recovery_questions`: the six-question fallback loop for confused agents
+- `companion_packages`: optional detection for `cascade-lattice`, `quinesmith`, and `brotology-field-guide`
+- `receipt_protocol`: a simple local receipt rule for meaningful changes
+
+The package does not depend on those companion packages. It detects them when present and keeps working when absent.
+
+Print a system prompt for the model you are giving the bundle to:
+
+```powershell
+continuum system-prompt --profile portable
+continuum system-prompt --profile codex
+continuum system-prompt --profile tiny
+continuum system-prompt --profile no-tools
+```
+
+## Engine Payload
+
+The drop-in export folder includes a full Champion Council research-capsule payload zip beside this package. Use:
+
+```powershell
+continuum engine --payload ..\payloads\champion_council_research_capsule.zip --target ..\engine\champion-council --self-test
+```
+
+Add `--launch` only in an environment where the backend dependencies are installed or can be installed.
+
+## Design Rule
+
+Continuum follows the same rule as Champion Council:
+
+- archive continuity helps re-entry
+- live runtime truth outranks archive continuity
+- docs and memory are planning surfaces, not authority planes

champion_continuum-0.5.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "champion-continuum"
+version = "0.5.0"
+description = "Portable continuity and reacclimation memory primitive for agent runtimes."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+  { name = "Champion Council" }
+]
+keywords = ["ai", "memory", "continuity", "agents", "tool-less", "relay", "reacclimation"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Libraries :: Python Modules"
+]
+dependencies = [
+    "mcp>=1.0.0",
+    "httpx>=0.27.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Yufok1/champion-continuum"
+Source = "https://github.com/Yufok1/champion-continuum"
+"Live Demo" = "https://huggingface.co/spaces/tostido/champion-continuum"
+Repository = "https://github.com/Yufok1/champion-continuum"
+
+[project.scripts]
+continuum = "champion_continuum.cli:main"
+champion-continuum = "champion_continuum.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

champion_continuum-0.5.0/setup.cfg

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

champion_continuum-0.5.0/src/champion_continuum/__init__.py

@@ -0,0 +1,20 @@
+"""Portable continuity primitive for agent runtimes."""
+
+from .core import Continuum
+from .store import ContinuumStore
+from .codex_archive import continuity_restore, continuity_status
+from .contracts import companion_package_status
+from .processor import parse_commands, process_text, render_results
+
+__all__ = [
+    "Continuum",
+    "ContinuumStore",
+    "companion_package_status",
+    "continuity_restore",
+    "continuity_status",
+    "parse_commands",
+    "process_text",
+    "render_results",
+]
+
+__version__ = "0.5.0"

champion_continuum-0.5.0/src/champion_continuum/cli.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+from . import __version__
+from .core import Continuum
+from .engine import engine_self_test, launch_engine, reconstitute_engine
+from .system_prompts import get_system_prompt, list_profiles
+
+
+def _print(payload: Any, as_json: bool = False) -> None:
+    if as_json or isinstance(payload, (dict, list)):
+        _emit(json.dumps(payload, indent=2, ensure_ascii=True))
+    else:
+        _emit(str(payload))
+
+
+def _emit(text: str) -> None:
+    try:
+        print(text)
+    except UnicodeEncodeError:
+        encoding = sys.stdout.encoding or "utf-8"
+        data = (text + "\n").encode(encoding, errors="backslashreplace")
+        if hasattr(sys.stdout, "buffer"):
+            sys.stdout.buffer.write(data)
+            sys.stdout.buffer.flush()
+        else:
+            print(data.decode(encoding, errors="replace"))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="continuum", description="Portable continuity memory primitive.")
+    default_root = os.environ.get("CONTINUUM_ROOT", ".continuum")
+    parser.add_argument("--root", default=default_root, help="Continuum data root (or set CONTINUUM_ROOT).")
+    parser.add_argument("--version", action="version", version=f"champion-continuum {__version__}")
+
+    # Shared parent so --root may also follow the subcommand. SUPPRESS keeps the
+    # attribute unset unless --root is passed here, so a value given before the
+    # subcommand is never clobbered by the subparser default.
+    root_after = argparse.ArgumentParser(add_help=False)
+    root_after.add_argument(
+        "--root", default=argparse.SUPPRESS, help="Continuum data root (may also precede the subcommand)."
+    )
+
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    def _cmd(name: str, **kwargs: Any) -> argparse.ArgumentParser:
+        return sub.add_parser(name, parents=[root_after], **kwargs)
+
+    _cmd("init", help="Initialize a Continuum store.")
+    _cmd("status", help="Show local Continuum status.")
+
+    doctor = _cmd("doctor", help="Inspect root attachment, contracts, and optional companion packages.")
+    doctor.add_argument("--cwd", default="")
+
+    remember = _cmd("remember", help="Store a continuity record.")
+    remember.add_argument("text")
+    remember.add_argument("--kind", default="note")
+    remember.add_argument("--tag", action="append", default=[])
+    remember.add_argument("--json", action="store_true")
+
+    ingest = _cmd("ingest-file", help="Store a text file as a continuity record.")
+    ingest.add_argument("path")
+    ingest.add_argument("--kind", default="document")
+    ingest.add_argument("--tag", action="append", default=[])
+    ingest.add_argument("--json", action="store_true")
+
+    search = _cmd("search", help="Search local continuity records.")
+    search.add_argument("query")
+    search.add_argument("--limit", type=int, default=8)
+    search.add_argument("--json", action="store_true")
+
+    restore = _cmd("restore", help="Restore continuity from Codex session archives if present.")
+    restore.add_argument("--summary", default="")
+    restore.add_argument("--cwd", default="")
+    restore.add_argument("--codex-home", default=None)
+    restore.add_argument("--limit", type=int, default=3)
+    restore.add_argument("--scan-limit", type=int, default=80)
+    restore.add_argument("--json", action="store_true")
+
+    packet = _cmd("packet", help="Emit a full bootstrap packet.")
+    packet.add_argument("--summary", default="")
+    packet.add_argument("--cwd", default="")
+    packet.add_argument("--codex-home", default=None)
+    packet.add_argument("--scan-limit", type=int, default=48)
+    packet.add_argument("--json", action="store_true")
+
+    receipt = _cmd("receipt", help="Write a structured receipt for a meaningful action.")
+    receipt.add_argument("action")
+    receipt.add_argument("--summary", default="")
+    receipt.add_argument("--status", default="ok")
+    receipt.add_argument("--tag", action="append", default=[])
+    receipt.add_argument("--json", action="store_true")
+
+    handoff = _cmd("handoff", help="Emit browser/no-tools handoff text plus the backing packet.")
+    handoff.add_argument("--summary", default="")
+    handoff.add_argument("--cwd", default="")
+    handoff.add_argument("--audience", default="browser", choices=["browser", "tiny", "codex", "portable"])
+    handoff.add_argument("--codex-home", default=None)
+    handoff.add_argument("--scan-limit", type=int, default=24)
+    handoff.add_argument("--json", action="store_true")
+
+    export = _cmd("export", help="Export local records to JSON.")
+    export.add_argument("--output", default="")
+
+    import_cmd = _cmd("import", help="Import records from a Continuum JSON export.")
+    import_cmd.add_argument("source")
+    import_cmd.add_argument("--json", action="store_true")
+
+    system = _cmd("system-prompt", help="Print a model-facing Continuum system prompt.")
+    system.add_argument("--profile", default="portable", choices=list_profiles())
+    system.add_argument("--json", action="store_true")
+
+    process = _cmd("process", help="Execute continuum commands a tool-less agent emitted in its text.")
+    process.add_argument("--input", default="", help="File holding the agent's text (default: read stdin).")
+    process.add_argument("--json", action="store_true")
+
+    engine = _cmd("engine", help="Reconstitute or launch a bundled Champion Council backend payload.")
+    engine.add_argument("--payload", required=True)
+    engine.add_argument("--target", default="engine/champion-council")
+    engine.add_argument("--overwrite", action="store_true")
+    engine.add_argument("--self-test", action="store_true")
+    engine.add_argument("--launch", action="store_true")
+    engine.add_argument("--web-port", type=int, default=7866)
+    engine.add_argument("--mcp-port", type=int, default=8766)
+    engine.add_argument("--json", action="store_true")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    root_path = Path(args.root).resolve()
+    continuum = Continuum(root_path)
+
+    try:
+        if args.command == "init":
+            _print(continuum.init(), True)
+        elif args.command == "status":
+            _print(continuum.status(), True)
+        elif args.command == "doctor":
+            _print(continuum.doctor(cwd=args.cwd), True)
+        elif args.command == "remember":
+            _print(continuum.remember(args.text, kind=args.kind, tags=args.tag), args.json)
+        elif args.command == "ingest-file":
+            _print(continuum.ingest_file(args.path, kind=args.kind, tags=args.tag), args.json)
+        elif args.command == "search":
+            _print(continuum.search(args.query, limit=args.limit), True)
+        elif args.command == "restore":
+            _print(
+                continuum.restore(
+                    summary=args.summary,
+                    cwd=args.cwd,
+                    codex_home=args.codex_home,
+                    limit=args.limit,
+                    scan_limit=args.scan_limit,
+                ),
+                True,
+            )
+        elif args.command == "packet":
+            _print(
+                continuum.packet(
+                    summary=args.summary,
+                    cwd=args.cwd,
+                    codex_home=args.codex_home,
+                    scan_limit=args.scan_limit,
+                ),
+                True,
+            )
+        elif args.command == "receipt":
+            _print(
+                continuum.receipt(
+                    action=args.action,
+                    summary=args.summary,
+                    status=args.status,
+                    tags=args.tag,
+                ),
+                True,
+            )
+        elif args.command == "handoff":
+            handoff = continuum.handoff(
+                summary=args.summary,
+                cwd=args.cwd,
+                audience=args.audience,
+                codex_home=args.codex_home,
+                scan_limit=args.scan_limit,
+            )
+            _print(handoff, True) if args.json else _emit(handoff["markdown"])
+        elif args.command == "export":
+            _print({"output": str(continuum.store.export_json(args.output or None))}, True)
+        elif args.command == "import":
+            _print(continuum.store.import_json(args.source), True)
+        elif args.command == "system-prompt":
+            prompt = get_system_prompt(args.profile)
+            _print({"profile": args.profile, "prompt": prompt}, True) if args.json else _emit(prompt)
+        elif args.command == "process":
+            from .processor import process_text
+
+            text = Path(args.input).read_text(encoding="utf-8", errors="replace") if args.input else sys.stdin.read()
+            result = process_text(text, root=root_path)
+            _print(result, True) if args.json else _emit(result["rendered"])
+        elif args.command == "engine":
+            if args.self_test:
+                result = engine_self_test(args.payload, args.target)
+            else:
+                result = reconstitute_engine(args.payload, args.target, overwrite=args.overwrite)
+            if args.launch:
+                proc = launch_engine(
+                    Path(result["runtime_shell"]),
+                    web_port=args.web_port,
+                    mcp_port=args.mcp_port,
+                )
+                result["launch"] = {"pid": proc.pid, "web_port": args.web_port, "mcp_port": args.mcp_port}
+            _print(result, True)
+        return 0
+    except Exception as exc:
+        _print(
+            {
+                "error": "runtime_exception",
+                "command": getattr(args, "command", ""),
+                "message": str(exc),
+                "failure_classes": ["truth", "contract", "transport", "rendering", "gating", "stale_runtime_state"],
+            },
+            True,
+        )
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())