seif-cli 0.6.2__tar.gz → 0.7.0__tar.gz

seif_cli-0.7.0/LICENSE

@@ -0,0 +1,34 @@
+MIT License
+
+Copyright (c) 2026 André Cunha Antero de Carvalho
+
+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.
+
+---
+
+This project was created by André Cunha Antero de Carvalho in collaboration with
+multiple AI systems (Claude, Gemini, Kimi, Grok, Z.AI). The human
+biological being provided the irreducible asymmetry — the questions,
+the observations, the insistence on measurement over belief.
+
+The protocol does not belong to any single entity. It belongs to the
+resonance between biology and machine. But its origin is documented,
+timestamped, and mathematically verified.
+
+The gate does not filter — it resonates.

{seif_cli-0.6.2/src/seif_cli.egg-info → seif_cli-0.7.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: seif-cli
-Version: 0.6.2
+Version: 0.7.0
 Summary: AI artifact provenance, quality gates, and data classification. Bitcoin-anchored timestamps, multi-AI consensus, locally enforced.
 Author: André Cunha Antero de Carvalho
-License: CC-BY-NC-SA-4.0
+License-Expression: MIT
 Project-URL: Homepage, https://seifprotocol.com
 Project-URL: Documentation, https://seifprotocol.com/docs
 Project-URL: Repository, https://github.com/and2carvalho/seif
 Project-URL: Changelog, https://github.com/and2carvalho/seif/releases
 Keywords: ai-quality,llm-guardrails,ai-consensus,data-classification,context-management,ai-safety,multi-ai,quality-gate,prompt-evaluation,ai-grounding,resonance,sentinel,self-healing,seif-os,circuit-state,ai-observability
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -480,4 +480,4 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-CC BY-NC-SA 4.0 — [André Cunha Antero de Carvalho](https://github.com/and2carvalho)
+MIT — [André Cunha Antero de Carvalho](https://github.com/and2carvalho)

{seif_cli-0.6.2 → seif_cli-0.7.0}/README.md

@@ -432,4 +432,4 @@ See [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## License
 
-CC BY-NC-SA 4.0 — [André Cunha Antero de Carvalho](https://github.com/and2carvalho)
+MIT — [André Cunha Antero de Carvalho](https://github.com/and2carvalho)

{seif_cli-0.6.2 → seif_cli-0.7.0}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seif-cli"
-version = "0.6.2"
+version = "0.7.0"
 description = "AI artifact provenance, quality gates, and data classification. Bitcoin-anchored timestamps, multi-AI consensus, locally enforced."
 readme = "README.md"
-license = {text = "CC-BY-NC-SA-4.0"}
+license = "MIT"
 requires-python = ">=3.11"
 authors = [
     {name = "André Cunha Antero de Carvalho"},
@@ -19,7 +19,7 @@ keywords = [
     "self-healing", "seif-os", "circuit-state", "ai-observability",
 ]
 classifiers = [
-    "Development Status :: 3 - Alpha",
+    "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",

seif_cli-0.7.0/src/seif/__init__.py

@@ -0,0 +1 @@
+"""S.E.I.F. — Signed Evidence & Integrity Framework"""

seif_cli-0.7.0/src/seif/amend/__init__.py

@@ -0,0 +1,9 @@
+"""Amend subpackage — append-only amendment-chain entries.
+
+Implements `seif --amend FILE --amend-entry JSON` and friends. Used to add
+new `_amendments[]` entries to SEIF artifacts (pending modules, sealed
+cycles, signed resonance records) without re-signing the host artifact.
+Pairs with the [[feedback_amendment_chain_over_host_resign]] convention.
+
+Closes the last universal write-side gap surfaced by s83 t3 PR-3.
+"""

seif_cli-0.7.0/src/seif/amend/amend.py

@@ -0,0 +1,186 @@
+"""--amend FILE: append an _amendments[] entry to any SEIF JSON artifact.
+
+The amendment-chain convention (feedback_amendment_chain_over_host_resign):
+some SEIF artifacts have already been signed/stamped and cannot easily be
+re-signed by the original host (offline laptop, immutable kernel, etc.).
+Adding a new `_amendments[]` entry — append-only, with provenance fields —
+records the change without touching the host artifact's canonical fields.
+
+This module exposes the operation as a first-class CLI command so AIs
+don't have to raw-Write the file (which the discipline observer would
+log and the hard-block phase would refuse).
+
+Public API
+----------
+- ``append_amendment(file_path, entry, *, amend_id=None, author=None) -> dict``
+- ``cmd_amend(args) -> int`` (entrypoint wired into ``seif --amend``)
+"""
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import re
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+__all__ = ["append_amendment", "cmd_amend"]
+
+
+_SLUG_RE = re.compile(r"[^a-z0-9-]+")
+
+
+def _now_iso() -> str:
+    return (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
+def _slug_for(text: str) -> str:
+    s = (text or "").strip().lower()
+    s = _SLUG_RE.sub("-", s).strip("-")
+    return s[:48] or "entry"
+
+
+def _atomic_write(path: Path, data: Any) -> None:
+    """Write JSON atomically: tempfile in same dir → fsync → rename.
+
+    Same-dir tempfile guarantees rename is atomic on POSIX (same fs).
+    """
+    body = json.dumps(data, indent=2, ensure_ascii=False)
+    parent = path.parent
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=str(parent),
+        prefix=path.name + ".",
+        suffix=".tmp",
+        delete=False,
+    ) as tf:
+        tmp_path = Path(tf.name)
+        tf.write(body)
+        tf.write("\n")
+        tf.flush()
+        os.fsync(tf.fileno())
+    tmp_path.replace(path)
+
+
+def append_amendment(
+    file_path: str | os.PathLike,
+    entry: dict,
+    *,
+    amend_id: str | None = None,
+    author: str | None = None,
+) -> dict:
+    """Append a new entry to ``data["_amendments"]`` in the given JSON file.
+
+    - The file MUST be a JSON object at the top level.
+    - If ``_amendments`` is missing or not a list, it is initialized to `[]`.
+    - The appended entry is the user-supplied ``entry`` dict, with the
+      following auto-fields injected if not already present:
+        * ``id``           — defaults to ``amend_id``, else
+                              ``f"amend-{n+1:03d}-{slug(scope)}"``.
+        * ``appended_at``  — UTC ISO timestamp.
+        * ``appended_by``  — defaults to ``author``, else ``$USER``, else
+                              ``"anonymous"``.
+
+    Returns the appended entry (mutated copy of ``entry``). Raises on I/O
+    or JSON errors; the file is left untouched if any step fails before
+    the atomic rename.
+    """
+    fp = Path(file_path)
+    if not fp.is_file():
+        raise FileNotFoundError(f"{fp} does not exist or is not a file")
+
+    raw = fp.read_text(encoding="utf-8")
+    data = json.loads(raw)  # raises JSONDecodeError on invalid JSON
+    if not isinstance(data, dict):
+        raise ValueError(f"{fp} is not a JSON object at top level")
+
+    amendments = data.get("_amendments")
+    if not isinstance(amendments, list):
+        amendments = []
+        data["_amendments"] = amendments
+
+    new_entry: dict = dict(entry)  # shallow copy so caller's dict stays clean
+    if "id" not in new_entry:
+        if amend_id:
+            new_entry["id"] = amend_id
+        else:
+            scope = new_entry.get("scope") or new_entry.get("title") or ""
+            new_entry["id"] = (
+                f"amend-{len(amendments) + 1:03d}-{_slug_for(scope)}"
+            )
+    if "appended_at" not in new_entry:
+        new_entry["appended_at"] = _now_iso()
+    if "appended_by" not in new_entry:
+        new_entry["appended_by"] = author or os.environ.get("USER") or "anonymous"
+
+    amendments.append(new_entry)
+    _atomic_write(fp, data)
+    return new_entry
+
+
+def _load_entry(args) -> dict:
+    """Resolve `--amend-entry` (inline JSON) and `--amend-entry-file` (path).
+
+    Exactly one source is required. If both are given, --amend-entry wins
+    (matches argparse last-arg semantics + saves a stat call).
+    """
+    inline = getattr(args, "amend_entry", None)
+    from_file = getattr(args, "amend_entry_file", None)
+    if inline:
+        try:
+            data = json.loads(inline)
+        except (ValueError, json.JSONDecodeError) as e:
+            raise ValueError(f"--amend-entry is not valid JSON: {e}") from e
+        if not isinstance(data, dict):
+            raise ValueError("--amend-entry must be a JSON object")
+        return data
+    if from_file:
+        p = Path(from_file)
+        if not p.is_file():
+            raise FileNotFoundError(f"--amend-entry-file {p} does not exist")
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+        except (ValueError, json.JSONDecodeError) as e:
+            raise ValueError(f"--amend-entry-file is not valid JSON: {e}") from e
+        if not isinstance(data, dict):
+            raise ValueError("--amend-entry-file must contain a JSON object")
+        return data
+    raise ValueError(
+        "no entry source: pass --amend-entry JSON or --amend-entry-file PATH"
+    )
+
+
+def cmd_amend(args) -> int:
+    """Entrypoint for `seif --amend FILE ...`."""
+    target = getattr(args, "amend", None)
+    if not target:
+        print("Error: --amend requires FILE", file=sys.stderr)
+        return 2
+    try:
+        entry = _load_entry(args)
+        appended = append_amendment(
+            target,
+            entry,
+            amend_id=getattr(args, "amend_id", None),
+            author=getattr(args, "amend_author", None),
+        )
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+    except (ValueError, json.JSONDecodeError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+    except OSError as e:
+        print(f"Error: I/O failure: {e}", file=sys.stderr)
+        return 2
+    print(f"[amend] appended {appended['id']} to {target}")
+    print(f"        appended_at: {appended['appended_at']}")
+    print(f"        appended_by: {appended['appended_by']}")
+    return 0

seif_cli-0.7.0/src/seif/amend/seed_create.py

@@ -0,0 +1,199 @@
+"""--seed-create CLI: lay down a new SEED-sNN.json at cycle seal.
+
+Last universal write-side gap closed by s83 t3 PR-4. Companion to
+amend.py — both live in src/seif/amend/ because both implement
+amendment-chain-aware artifact creation/mutation.
+
+Behavior
+--------
+1. Resolve workspace root (walk up from cwd for a directory containing
+   `.seif/`, or accept explicit --seed-output PATH).
+2. Compute the canonical filename `SEED-s{N}-{YYYY-MM-DD}.json` under
+   `.seif/seeds/`.
+3. Refuse to overwrite an existing file (use `--amend` to mutate, or
+   delete + recreate explicitly).
+4. Build a minimal valid record (SEIF-SEED-v2 protocol) with auto-
+   filled fields. Merge in any user-supplied JSON via
+   `--seed-content-file PATH`. User fields win on conflict.
+5. Atomic write (tempfile in same dir → fsync → rename).
+"""
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import sys
+from pathlib import Path
+
+__all__ = ["cmd_seed_create", "build_seed_record", "resolve_seed_output_path"]
+
+
+def _now_iso() -> str:
+    return (
+        datetime.datetime.now(datetime.timezone.utc)
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
+def _today_yyyymmdd() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%d")
+
+
+def _walk_up_for_seif(start: Path) -> Path | None:
+    cur = start.resolve()
+    for _ in range(20):
+        if (cur / ".seif").is_dir():
+            return cur
+        if cur == cur.parent:
+            return None
+        cur = cur.parent
+    return None
+
+
+def resolve_seed_output_path(
+    session_target: int,
+    *,
+    explicit_output: str | None = None,
+    workspace: str | None = None,
+) -> Path:
+    """Compute the seed file path. `explicit_output` overrides everything."""
+    if explicit_output:
+        return Path(explicit_output).expanduser().resolve()
+    if workspace:
+        ws = Path(workspace).expanduser().resolve()
+    else:
+        ws = _walk_up_for_seif(Path.cwd())
+        if ws is None:
+            raise FileNotFoundError(
+                "no .seif/ workspace found from cwd. "
+                "Pass --seed-output PATH or cd into a workspace."
+            )
+    return ws / ".seif" / "seeds" / f"SEED-s{session_target}-{_today_yyyymmdd()}.json"
+
+
+def build_seed_record(
+    session_target: int,
+    *,
+    parent_cycle_module: str | None = None,
+    generator: str | None = None,
+    content_overlay: dict | None = None,
+) -> dict:
+    """Construct the minimal valid SEIF-SEED-v2 record."""
+    base = {
+        "_instruction": (
+            f"SEED for session {session_target}. Created by seif --seed-create. "
+            "Amend via `seif --amend <this-file> --amend-entry '{...}'` to add "
+            "session_summary, primary_anchor, expected_actions, what_NOT_to_do, "
+            "etc., as the seal ritual unfolds."
+        ),
+        "protocol": "SEIF-SEED-v2",
+        "seed_id": f"SEED-s{session_target}-{_today_yyyymmdd()}",
+        "generator": generator
+        or f"seif --seed-create (user={os.environ.get('USER', 'anonymous')})",
+        "generated_at": _now_iso(),
+        "session_target": session_target,
+        "parent_session": session_target - 1 if session_target > 0 else None,
+        "parent_cycle_module": parent_cycle_module,
+        "_amendments": [],
+    }
+    if content_overlay:
+        # User-supplied fields win — they may carry session_summary, anchors, etc.
+        merged = dict(base)
+        merged.update(content_overlay)
+        # Always preserve _amendments as a list even if overlay tried to remove it.
+        if not isinstance(merged.get("_amendments"), list):
+            merged["_amendments"] = base["_amendments"]
+        return merged
+    return base
+
+
+def _atomic_write(path: Path, data: dict) -> None:
+    import tempfile
+
+    body = json.dumps(data, indent=2, ensure_ascii=False)
+    parent = path.parent
+    parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        mode="w",
+        encoding="utf-8",
+        dir=str(parent),
+        prefix=path.name + ".",
+        suffix=".tmp",
+        delete=False,
+    ) as tf:
+        tmp = Path(tf.name)
+        tf.write(body)
+        tf.write("\n")
+        tf.flush()
+        os.fsync(tf.fileno())
+    tmp.replace(path)
+
+
+def cmd_seed_create(args) -> int:
+    """Entrypoint for `seif --seed-create --seed-session N [...]`."""
+    target = getattr(args, "seed_session", None)
+    if target is None:
+        print(
+            "Error: --seed-create requires --seed-session N (target session number)",
+            file=sys.stderr,
+        )
+        return 2
+    if not isinstance(target, int) or target < 0:
+        print(f"Error: --seed-session must be a non-negative integer (got {target})",
+              file=sys.stderr)
+        return 2
+
+    try:
+        out_path = resolve_seed_output_path(
+            target,
+            explicit_output=getattr(args, "seed_output", None),
+            workspace=getattr(args, "seed_workspace", None),
+        )
+    except FileNotFoundError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 2
+
+    if out_path.exists():
+        print(
+            f"Error: {out_path} already exists. Use `seif --amend` to mutate, "
+            "or remove it explicitly before re-running --seed-create.",
+            file=sys.stderr,
+        )
+        return 2
+
+    overlay: dict | None = None
+    overlay_file = getattr(args, "seed_content_file", None)
+    if overlay_file:
+        op = Path(overlay_file)
+        if not op.is_file():
+            print(f"Error: --seed-content-file {op} does not exist", file=sys.stderr)
+            return 2
+        try:
+            overlay = json.loads(op.read_text(encoding="utf-8"))
+        except (ValueError, json.JSONDecodeError) as e:
+            print(f"Error: --seed-content-file is not valid JSON: {e}", file=sys.stderr)
+            return 2
+        if not isinstance(overlay, dict):
+            print("Error: --seed-content-file must contain a JSON object", file=sys.stderr)
+            return 2
+
+    record = build_seed_record(
+        target,
+        parent_cycle_module=getattr(args, "seed_from_cycle", None),
+        generator=getattr(args, "seed_generator", None),
+        content_overlay=overlay,
+    )
+
+    try:
+        _atomic_write(out_path, record)
+    except OSError as e:
+        print(f"Error: I/O failure writing {out_path}: {e}", file=sys.stderr)
+        return 2
+
+    print(f"[seed-create] wrote {out_path}")
+    print(f"              seed_id: {record['seed_id']}")
+    print(f"              parent_session: {record['parent_session']}")
+    if record["parent_cycle_module"]:
+        print(f"              parent_cycle_module: {record['parent_cycle_module']}")
+    return 0

seif_cli-0.7.0/src/seif/analysis/__init__.py

@@ -0,0 +1 @@
+"""S.E.I.F. — Signed Evidence & Integrity Framework"""

seif_cli-0.7.0/src/seif/audit/__init__.py

@@ -0,0 +1,7 @@
+"""Audit subpackage — discipline observation reports.
+
+Pairs with the PreToolUse hook observer (plugins/adapters/claude-code/scripts/
+discipline_observer.py) that appends JSONL entries when AI agents Write/Edit
+files under .seif/{cycles,sessions,seeds,memory,modules}/**. Phase-1 of s83
+t3 discipline enforcement; see pending-2026-05-11-s83-t3-discipline-enforcement.
+"""