continuityos 0.7.0__tar.gz

continuityos-0.7.0/LICENSE

@@ -0,0 +1,177 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 ContinuityOS contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

continuityos-0.7.0/NOTICE

@@ -0,0 +1,5 @@
+ContinuityOS
+Copyright 2026 ContinuityOS contributors
+
+This product includes software developed by the ContinuityOS contributors.
+Licensed under the Apache License, Version 2.0.

continuityos-0.7.0/PKG-INFO

@@ -0,0 +1,288 @@
+Metadata-Version: 2.4
+Name: continuityos
+Version: 0.7.0
+Summary: Durable, hybrid (structural + semantic) memory for AI agents and humans. Local-first, zero external services.
+Author: ContinuityOS contributors
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://sovereign-arena-site.vercel.app/continuityos
+Project-URL: Source, https://github.com/bitmaster162/continuityos
+Keywords: memory,ai-agents,mcp,semantic-search,vector,rag,llm,continuity
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: sentence-transformers
+Requires-Dist: sentence-transformers>=2.2; extra == "sentence-transformers"
+Provides-Extra: fastembed
+Requires-Dist: fastembed>=0.3; extra == "fastembed"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-cov>=4; extra == "dev"
+Dynamic: license-file
+
+# ContinuityOS
+
+> ## 🛡️ ContinuityOS — AI Agent Governance Gateway
+>
+> **No dangerous tool runs unless ContinuityOS approves it.** A local-first, MCP-native
+> hard-boundary that AI coding agents (Claude Code, Cursor, Codex CLI) must pass through:
+> every risky shell/file/git action gets a preflight decision — `ALLOW · WARN · HOLD · DENY ·
+> REQUIRE_CONFIRMATION · DRY_RUN_ONLY` — with reasons, an append-only tamper-evident audit
+> ledger, and a rollback plan. Apache-2.0.
+>
+> ```bash
+> continuity run shell -- rm -rf /     # ⛔ BLOCKED — command was NOT executed
+> continuity run shell -- npm test     # ✓ ALLOW — runs
+> ```
+>
+> ContinuityBench v0: **100% decision accuracy, 9/9 dangerous actions stopped** (vs 0/9 with no
+> gateway). What makes it smarter than a static policy engine: it decides **with continuity
+> context** (your canon/rules/state), not just regex. See [BUILD_GATE_STATUS.md](BUILD_GATE_STATUS.md).
+>
+> The memory + continuity layers below are the **context engine** that powers those decisions.
+
+---
+
+
+**Durable memory + continuity layer for AI agents and humans.** Local-first, zero external services, Apache-2.0.
+
+Not just a vector store — ContinuityOS keeps the *thread* between sessions and between versions of you and the model: **memory** (hybrid recall) **+ continuity** (canon, frontiers, loops, checkpoints, anti-drift doctor, handoff) **+ a multi-agent council** (many agents + you on one memory, authority levels & roles) **+ a digital twin** (a behavioral model built from your own memory — the human↔AI co-evolution / dyad layer) **+ an operator control plane** (correct, redact, rollback, export).
+
+Your Claude / ChatGPT / agent forgets everything between sessions. ContinuityOS is a small local memory layer that stores what matters — who you are, your projects, your rules, decisions you've made — and gives it back when it's relevant. It recalls **both structurally** (folder-like namespaces + keyword search) **and semantically** (vector similarity), so the right memory surfaces whether you match the words or just the meaning.
+
+Nothing leaves your machine. One SQLite file. No cloud, no account, no telemetry.
+
+---
+
+## Why
+
+- **Agents forget.** Every new session starts cold. ContinuityOS persists context across sessions and tools.
+- **Hybrid recall.** Keyword-only memory misses paraphrases; pure-vector memory misses exact facts and structure. ContinuityOS blends both.
+- **Structure like folders.** Memories live in namespaces — `identity`, `projects`, `rules`, `facts`, `events`, `notes` (or your own) — so recall can be scoped and a human can browse it.
+- **For agents *and* humans.** Use it from your code, from the CLI, from an MCP-capable client (Claude Desktop / Claude Code), or over a tiny HTTP API.
+- **Local-first & private.** Core is **stdlib-only** — no required dependencies, no services. Drop-in to anything.
+
+---
+
+## Install
+
+```bash
+pip install continuityos          # core (stdlib-only)
+# optional, for production-grade embeddings:
+pip install "continuityos[embeddings]"
+```
+
+Requires Python 3.10+.
+
+---
+
+## Quick start
+
+### From the CLI
+
+```bash
+cos remember "Robert prefers Apache-2.0 licenses" -n rules -t license
+cos remember "ContinuityOS = hybrid memory: FTS + vectors" -n projects
+cos recall  "which license should I pick?"
+# 0.54 [rules] Robert prefers Apache-2.0 licenses  (semantic 0.22 + keyword)
+cos namespaces
+```
+
+### From Python
+
+```python
+from continuityos import Memory
+
+m = Memory("memory.db")
+m.remember("The grid lab K=0.04 cohort led at +$1405 / 3 days", namespace="facts", tags=["trading"])
+
+for hit in m.recall("best grid setup", k=3):
+    print(hit.score, hit.namespace, hit.text)
+
+# inject straight into an agent prompt:
+print(m.context("what do I know about grid trading?"))
+```
+
+### As an MCP server (Claude Desktop / Claude Code)
+
+ContinuityOS ships an MCP stdio server so an agent can `remember` and `recall` on its own. Add to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "continuityos": {
+      "command": "cos",
+      "args": ["--db", "~/.continuityos/memory.db", "serve"]
+    }
+  }
+}
+```
+
+Tools exposed: `remember`, `recall`, `context`, `forget`, `list_namespaces`, `checkpoint`, `handoff`, `doctor`, `set_frontier`, `predict`, `alignment`, `preflight_action` — **12 tools**.
+Now the agent pulls relevant memory automatically before answering — and writes new facts back as it learns it.
+
+**Recommended:** use the cross-platform bridge instead of `cos serve`:
+
+```json
+{
+  "mcpServers": {
+    "continuityos": {
+      "command": "python",
+      "args": ["/path/to/mcp_bridge.py"]
+    }
+  }
+}
+```
+
+See [docs/MCP_INTEGRATION.md](docs/MCP_INTEGRATION.md) for Hermes, Claude Desktop, and Cursor setup.
+
+### Over HTTP (optional)
+
+```bash
+cos api --port 8077
+curl -s "localhost:8077/recall?q=license&k=3"
+curl -s -XPOST localhost:8077/remember -d '{"text":"hello","namespace":"notes"}'
+```
+
+### Real semantic recall (recommended)
+
+The default embedder is offline & dependency-free. For real semantic quality (synonyms, paraphrases), switch in one line:
+
+```python
+from continuityos import Memory
+from continuityos.embedders import FastEmbedEmbedder   # pip install "continuityos[fast]"
+m = Memory("memory.db", embedder=FastEmbedEmbedder())  # bge-small, ONNX, no torch
+```
+
+Benchmark (see [BENCHMARKS.md](BENCHMARKS.md)): `recall@5` 0.50 → **1.00**, MRR 0.38 → 0.58. Real LoCoMo harness ready in `bench/locomo_bench.py`.
+
+### With Docker
+
+```bash
+docker compose up -d        # HTTP API on :8077, memory persisted in ./cos-data
+```
+
+---
+
+## More than memory — the continuity layer
+
+A chat is a terminal, not memory. ContinuityOS persists the operating state that keeps work coherent across sessions:
+
+- **Canon** — slow, non-negotiable truths (who you are, rules you don't break).
+- **Frontiers** — `1 trunk + 1 cash + 1 lab` focus discipline; classify every idea.
+- **Open loops** — what's still unfinished, bounded so it can't sprawl.
+- **Checkpoints** — every session ends with `delta + next irreversible action + proof`.
+- **Doctor** — an anti-drift check: is a cash frontier set? loops bounded? checkpoint fresh? proof attached?
+- **Handoff pack** — one block (canon + frontiers + loops + last checkpoint) to resume in a new session or hand to another agent.
+
+```bash
+cos frontier trunk continuityos
+cos frontier cash  inner-circle
+cos loop "ship v0.2 to GitHub"
+cos checkpoint --summary "built continuity layer" --next "update sites" --proof continuity.py
+cos doctor       # ✅ healthy 5/5  (or flags drift)
+cos handoff      # paste this into the next session
+```
+
+```python
+from continuityos import Continuity
+c = Continuity(db="memory.db")
+c.add_canon("Proof beats explanation. Closure beats branching.")
+c.set_frontier("cash", "inner-circle")
+c.checkpoint(summary="...", next_action="...", proof="path/to/artifact")
+print(c.doctor())     # anti-drift report
+print(c.handoff())    # resume-context block
+```
+
+Over MCP the agent gets `checkpoint`, `handoff`, `doctor`, `set_frontier` tools too — so it maintains its own continuity, not just its recall.
+
+---
+
+## How it works
+
+```
+            remember(text, namespace, tags)
+                        │
+                        ▼
+        ┌───────────────────────────────┐
+        │            Store               │   one local SQLite file
+        │  items  +  FTS5  +  vectors    │
+        └───────────────────────────────┘
+                        ▲
+          recall(query) │  HYBRID rank
+            ┌───────────┴───────────┐
+   structural / keyword       semantic / vector
+   (FTS5 + namespace)         (cosine over embeddings)
+            └───────────┬───────────┘
+                  blended score → top-k
+```
+
+- **Structural layer** — `namespace` (folder-like) + `tags` + FTS5 full-text index.
+- **Semantic layer** — each memory is embedded to an L2-normalized vector; recall ranks by cosine similarity.
+- **Hybrid score** — `semantic_weight · semantic + (1 − semantic_weight) · keyword` (tunable; default 0.6).
+- **Embeddings are pluggable** — the default `HashingEmbedder` is deterministic and fully offline (great for privacy and tests). For best semantic quality, pass any `str → list[float]` callable (e.g. a `sentence-transformers` model):
+
+  ```python
+  from sentence_transformers import SentenceTransformer
+  enc = SentenceTransformer("all-MiniLM-L6-v2")
+  m = Memory("memory.db", embedder=lambda t: enc.encode(t, normalize_embeddings=True).tolist())
+  ```
+
+---
+
+## Privacy
+
+ContinuityOS never sends your data anywhere. Memory is a single SQLite file on your disk. `.gitignore` is pre-configured to keep `*.db`, `data/`, and `takeout/` out of version control by construction.
+
+---
+
+## Standards & competitive position
+
+The 2026 consensus is that **guardrails belong at the gateway, not embedded in application code** — a control point that intercepts every tool invocation, scores its risk, and approves or blocks before execution. ContinuityOS is exactly that control point, and maps onto the frameworks enterprises are now audited against:
+
+- **OWASP LLM Top 10** — preflight classifies and gates the agentic risks directly: prompt-injection-driven destructive commands, tool poisoning (D3 schema/forbidden-pattern checks), excessive agency (SAP capability passports), and missing audit (append-only ledger).
+- **NIST AI RMF / EU AI Act (high-risk obligations, in force Aug 2026)** — the tamper-evident decision ledger + rollback plan provide the *record-level traceability* and *human-oversight* hooks these frameworks require. Every decision is logged with reasons, severity, and a restore command.
+- **MCP-native** — runs as an MCP server; the same preflight governs MCP tool calls, the layer competitors (Cisco AI Defense, Lasso) now target.
+
+**What no one else has.** The crowded 2026 field (Galileo Agent Control, Maxim Bifrost, Palo Alto Prisma AIRS, Lasso, Defend AI) enforces *generic* policy — regex, ML classifiers, org rules. ContinuityOS decides **with your continuity context**: the same engine that remembers *your* canon and non-negotiable rules uses them to judge each action (`_canon_check`). That makes it the only gateway whose verdicts are personalized to the operator, not just the org. Plus two things detection-only tools skip: an **instant local rollback module** (snapshot → `continuity rollback <id>`) and **sovereign-local execution** (zero data leaves the disk — no SaaS egress, which is itself the top enterprise blocker: only 14.4% of agents reached production with full security sign-off in 2026).
+
+Honest scope: rollback covers local files only; it cannot undo irreversible external side effects (network, prod, third-party APIs). The gateway raises the floor — it is not a guarantee.
+
+## Two-tier memory & cost-aware routing
+
+The strongest 2026 agents don't win on a bigger context window — they win on *how they handle the finiteness of context*. ContinuityOS implements the two-tier pattern Anthropic and OpenAI both converge on:
+
+- **Session memory** — the auto-compactible state of the current run (goal, live hypotheses, found IDs, tool outcomes, unresolved blockers). Carried forward instead of re-derived each turn.
+- **Long-term memory** — durable lessons, stable user preferences, recurring patterns, anti-patterns, domain facts. **One lesson per file; update the existing note, don't spawn duplicates** — the same discipline this repo's memory files follow.
+
+`context(query, k, max_tokens=…, compact=…)` packs the most relevant long-term memories until a token budget is hit, so recall stays cheap, and its output order is deterministic — which matters for **prompt-cache stability**.
+
+**Cache-friendly memory rules** (preserve the prompt-cache hash; cache miss = paying full price every turn):
+
+1. Never put volatile values (`datetime.now()`, random IDs, per-turn counters) in the system prompt or any cached prefix — they reset the cache every call. Put them in the body of the last user message.
+2. Keep tool definitions and the memory block in a **stable, sorted order** so the cached prefix is byte-identical across turns (`compact=True` + deterministic packing does this).
+3. The cache threshold on Opus-4.8 is ~1024 tokens — keep the cached prefix above it to actually benefit.
+4. To change instructions mid-run without busting the cache, inject a `role:"system"` message *into the history* rather than editing the cached system prompt.
+
+**Cost-aware routing.** `estimate_cost(text, model_id, output_tokens)` prices a context block against a built-in `MODEL_REGISTRY` (Fable 5, Mythos 5, Opus 4.8, Haiku 4.5, GPT-5.5, Gemini 3.1 Pro / 3.5 Flash, Grok 4.3, DeepSeek V4 Pro — mid-2026 pricing). Same block costs ~28× more on Fable 5 than DeepSeek V4 Pro, so callers can route *commodity → interactive → high-stakes* tiers instead of always paying frontier price for trivial work.
+
+## Status
+
+`v0.7.0` — **6 layers, 12 MCP tools, 18/18 tests, full audit passed.** Unified core, all tested (FastEmbed-accelerated recall, session rituals `boot/close/compress`, recall benchmark in `bench/`): **L1 Memory** (hybrid FTS+vector, WAL mode) · **L2 Continuity** (canon/frontiers/loops/checkpoints/doctor/handoff) · **L3 Council** (multi-agent, authority levels + roles) · **L4 Twin** (digital twin: profile/predict/alignment — now in CLI too) · **L5 Control Plane** (correct/redact/rollback/export) · **L6 Autopoiesis** (self-maintenance doctor). CLI (`cos` + `continuity`), MCP server (**12 tools**, cross-platform `mcp_bridge.py`), HTTP API, Docker. CI via GitHub Actions.
+
+**Audit fixes applied:** WAL crash resilience · FastEmbed default + auto-fallback · Git-backed DB with daily backup cron · Gate enforcement via Hermes shell hooks · CANONICAL_TRUTH.md (3-store hierarchy) · predict/alignment in CLI · docs/ + quickstart example.
+
+Roadmap: incremental vector index for large stores, optional reranking, import adapters (chat exports, notes), web memory browser.
+
+## License
+
+Apache-2.0. See [LICENSE](LICENSE).