clm-kernel 0.0.2__tar.gz → 0.0.3__tar.gz

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: clm-kernel
-Version: 0.0.2
+Version: 0.0.3
 Summary: Card Lifecycle Manager (CLM) Kernel — Sovereign Functional Agentic Operating System
 Author: GovTech Digital Identity & Autonomous Systems
 License: MIT

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/cross_cutting/handle_kind.py

@@ -32,10 +32,17 @@ HANDLE_GRAMMAR = re.compile(r"^urn:mcard:(?P<sector>[a-z_]+):(?P<kind>[a-z_]+)(?
 # Must equal the hub's registry/handle_taxonomy.yaml; the drift check enforces it.
 KIND_SECTORS: dict[str, tuple[str, ...]] = {
     # Content Memory (content_memory.db)
-    "mcard": ("content", "knowledge", "schema", "contract", "registry", "record", "projection", "derived", "lifecycle"),
+    "mcard": (
+        "content", "knowledge", "schema", "contract", "registry", "record", "projection",
+        "derived", "lifecycle",
+        # ORC-24: the nine archetypes (`clm/schema/archetypes/`) as kinds — an
+        # archetype is `<kind>_<sector>`, so the kind is derived, not hand-mapped.
+        "artifact", "commit", "design_decision", "feedback", "specification",
+        "sprint_status", "telemetry", "test_result",
+    ),
     "doc": ("vault", "document"),
     "pcard": ("program", "sprint"),
-    "vcard": ("seal", "execution"),
+    "vcard": ("seal", "execution", "contract"),
     # Agent Identities (agent_identities.db)
     "agent": ("root", "actor"),
     "node": ("did", "peer"),

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/cross_cutting/pcard.py

@@ -93,7 +93,10 @@ def serialize_pcard(
 
     pcard_hash = hash_string(pcard_yaml)
 
-    handle_name = f"pcard:{operation}:{pcard_hash}"
+    # ORC-24: the grammar names the KIND — `urn:mcard:pcard:program:<hash>`. This wrote
+    # `pcard:{operation}:{hash}`, the last legacy handle form in the kernel, and the reason the
+    # hub's declared consumption of `urn:mcard:pcard:*` had no tape to satisfy it.
+    handle_name = f"urn:mcard:pcard:program:{pcard_hash}"
     ctx.repo.save_card_and_handle(
         handle_name, pcard_hash, pcard_yaml, "execution_log",
         timestamp=timestamp, replace=False,

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/cross_cutting/telemetry.py

@@ -135,19 +135,20 @@ def jsonl_emit(event_type: str, data: dict[str, Any] | list[str], clm_root: str)
         _LAST_RUN_ID = run_id
 
         repo = _get_cached_repo(clm_root)
-        handle_name = f"run:{run_id}:events"
+        # ONE EVENT, ONE CARD — the SEQUENCE lives in `handle_history`, which is what a
+        # revision record is for (ORC-29). The handle NAMES the kind (INV-TAPE-03): one
+        # handle per (run, event type), so the number of events of a type is the length of
+        # that handle's history.
+        #
+        # THIS PREVIOUSLY ACCUMULATED. It read the whole log back, concatenated one line, and
+        # registered the WHOLE THING as a new card. `card` is content-addressed, so every
+        # distinct accumulation became a NEW ROW — N events, N cards, averaging N/2 lines,
+        # i.e. O(n²) bytes. The Rust emitter carried the identical defect; together they cost
+        # 114 GB for the 20.9 MB of events in the append-only file beside them.
+        handle_name = f"run:{run_id}:event:{event_type}"
+        new_hash = clm_hash_string(json_line)
         try:
-            current_content = repo.resolve_handle_content(handle_name, "execution_log")
-            _logger.debug(f"jsonl_emit: current_content len={len(current_content) if current_content else 0}")
-        except Exception as e:
-            _logger.error(f"jsonl_emit: resolve failed: {e}")
-            current_content = None
-
-        new_content = f"{current_content}\n{json_line}" if current_content else json_line
-
-        new_hash = clm_hash_string(new_content)
-        try:
-            repo.save_card_and_handle(handle_name, new_hash, new_content, "execution_log", replace=True)
+            repo.save_card_and_handle(handle_name, new_hash, json_line, "execution_log", replace=True)
         except Exception as e:
             _logger.error(f"jsonl_emit: DB registration failed: {e}")
 

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer0/algebra_equivalence.py

@@ -243,7 +243,7 @@ def assess_equivalence_py(clm_root: str, clm_file: str) -> tuple[int, str]:
     try:
         db.execute("content_memory", "INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?);", [vcard_hash, vcard_yaml, timestamp])
         handle_name = f"vcard:equivalence:{vcard_hash}"
-        db.execute("content_memory", "INSERT OR IGNORE INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?);", [handle_name, vcard_hash, timestamp, timestamp])
+        db.execute("content_memory", "INSERT OR IGNORE INTO handle_registry (handle, current_hash, updated_at) VALUES (?, ?, ?);", [handle_name, vcard_hash, timestamp])
     except Exception:
         pass
 

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer0/algebra_ingest.py

@@ -252,7 +252,7 @@ def directory_to_db_py(clm_root: str, spec_file: str) -> str:
             cursor.executescript(schema_content)
         except Exception:
             cursor.execute("CREATE TABLE IF NOT EXISTS card (hash TEXT PRIMARY KEY, content BLOB NOT NULL, g_time TEXT NOT NULL);")
-            cursor.execute("CREATE TABLE IF NOT EXISTS handle_registry (handle TEXT PRIMARY KEY, current_hash TEXT NOT NULL, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);")
+            cursor.execute("CREATE TABLE IF NOT EXISTS handle_registry (handle TEXT PRIMARY KEY, current_hash TEXT NOT NULL, updated_at TEXT NOT NULL);")
             cursor.execute("CREATE TABLE IF NOT EXISTS handle_history (handle TEXT NOT NULL, previous_hash TEXT NOT NULL, changed_at TEXT NOT NULL);")
         conn.commit()
 
@@ -281,7 +281,7 @@ def directory_to_db_py(clm_root: str, spec_file: str) -> str:
         handle = f"{storage_type}://{top_dir_name}/{rel_path}"
 
         cursor.execute("INSERT OR IGNORE INTO card (hash, content, g_time) VALUES (?, ?, ?);", [h, sqlite3.Binary(content_bytes), now])
-        cursor.execute("INSERT OR IGNORE INTO handle_registry (handle, current_hash, created_at, updated_at) VALUES (?, ?, ?, ?);", [handle, h, now, now])
+        cursor.execute("INSERT OR IGNORE INTO handle_registry (handle, current_hash, updated_at) VALUES (?, ?, ?);", [handle, h, now])
 
     conn.commit()
 

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer0/model/action.py

@@ -51,7 +51,7 @@ ActionRuntime = Literal[
 class ActionMetadata(BaseModel):
     """Metadata block identifying the Action and its algebraic role in CLM."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     type: Literal["action", "pcard_action"] = "action"
     name: str = Field(..., pattern=r"^[a-z0-9_\-]+$")
@@ -64,7 +64,7 @@ class ActionMetadata(BaseModel):
 class ActionInput(BaseModel):
     """Specification of an input MCard bound to the Action."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     name: str
     uri: str | None = None
@@ -76,7 +76,7 @@ class ActionInput(BaseModel):
 class ActionPrecondition(BaseModel):
     """Precondition invariant rule (V_pre Gate) verified before Action execution."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     invariant: str
     rule: str
@@ -87,7 +87,7 @@ class ActionPrecondition(BaseModel):
 class ActionOperation(BaseModel):
     """Algebraic operation definition specifying the Baldwin operator and parameters."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     operator: BaldwinOperator
     strategy: str | None = None
@@ -98,7 +98,7 @@ class ActionOperation(BaseModel):
 class ActionPostcondition(BaseModel):
     """Postcondition invariant rule (V_post Witness) verified before committing output."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     invariant: str
     rule: str
@@ -109,7 +109,7 @@ class ActionPostcondition(BaseModel):
 class ActionOutput(BaseModel):
     """Specification of an output MCard emitted by the Action."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     name: str
     handle: str | None = None
@@ -124,7 +124,7 @@ class ActionManifest(BaseModel):
     Hoare postconditions (V_post), and outputs.
     """
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     version: Literal["1.0", "1.0.0"] = "1.0"
     clm: ActionMetadata

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer0/model/workflow.py

@@ -33,7 +33,7 @@ class WorkflowValidationError(CLMError):
 class WorkflowMetadata(BaseModel):
     """Metadata block identifying the workflow and its role in CLM."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     type: Literal["workflow", "pocketflow_dag"] = "workflow"
     name: str = Field(..., pattern=r"^[a-z0-9_\-]+$")
@@ -44,7 +44,7 @@ class WorkflowMetadata(BaseModel):
 class WorkflowInput(BaseModel):
     """Specification of an input parameter to the workflow."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     name: str
     format: str | None = None
@@ -54,7 +54,7 @@ class WorkflowInput(BaseModel):
 class WorkflowStep(BaseModel):
     """A discrete Action step in the workflow DAG."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     id: str = Field(..., pattern=r"^[a-z0-9_\-]+$")
     action: str
@@ -82,7 +82,7 @@ class WorkflowStep(BaseModel):
 class WorkflowOutput(BaseModel):
     """Specification of an output produced by the workflow."""
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     name: str
     source: str
@@ -98,7 +98,7 @@ class WorkflowManifest(BaseModel):
     and Merkle causal lineage.
     """
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
+    model_config = ConfigDict(frozen=True, extra="ignore")
 
     version: Literal["1.0", "1.0.0"] = "1.0"
     clm: WorkflowMetadata

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer0/schema/ddl.py

@@ -35,15 +35,15 @@ CARD_TABLE_SPEC = TableSpec(
 
 HANDLE_REGISTRY_SPEC = TableSpec(
     name=TABLE_HANDLE_REGISTRY,
-    columns=("handle", "current_hash", "created_at", "updated_at"),
+    columns=("handle", "current_hash", "updated_at"),
     primary_key=("handle",),
     description="Semantic handle mapping mutable names to immutable CAS hashes (Sum/Appetition).",
 )
 
 HANDLE_HISTORY_SPEC = TableSpec(
     name=TABLE_HANDLE_HISTORY,
-    columns=("id", "handle", "previous_hash", "changed_at", "change_type"),
-    primary_key=("id",),
+    columns=("handle", "previous_hash", "changed_at"),
+    primary_key=(),
     description="Append-only audit trail witnessing all handle transitions (η-conversion).",
 )
 
@@ -60,7 +60,6 @@ SQL_CREATE_HANDLE_REGISTRY: Final[str] = """\
 CREATE TABLE IF NOT EXISTS handle_registry (
     handle TEXT PRIMARY KEY,
     current_hash TEXT NOT NULL,
-    created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL,
     FOREIGN KEY (current_hash) REFERENCES card(hash)
 );
@@ -69,11 +68,9 @@ CREATE INDEX IF NOT EXISTS idx_handle_current_hash ON handle_registry(current_ha
 
 SQL_CREATE_HANDLE_HISTORY: Final[str] = """\
 CREATE TABLE IF NOT EXISTS handle_history (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
     handle TEXT NOT NULL,
     previous_hash TEXT NOT NULL,
     changed_at TEXT NOT NULL,
-    change_type TEXT DEFAULT 'UPDATE',
     FOREIGN KEY (handle) REFERENCES handle_registry(handle),
     FOREIGN KEY (previous_hash) REFERENCES card(hash)
 );

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer1/petri.py

@@ -922,37 +922,43 @@ class ColoredPetriVM:
             else:
                 out_buf.append("  ✅ Temporal idempotency proven (zero state drift)")
 
-        events_handle = f"run:{run_id}:events"
-        _logger.debug(f"--- PETRI DEBUG: events_handle={events_handle}, clm_root={clm_root} ---")
-        try:
-            h_res = ctx.repo.get_all_handles("execution_log")
-            _logger.debug(f"--- PETRI DEBUG: handle registry={repr(h_res)} ---")
-        except Exception as e:
-            _logger.error(f"--- PETRI DEBUG: db query failed: {e} ---")
-
-        events_content = ""
-        try:
-            events_content = resolve_handle_content(clm_root, events_handle, "execution_log") or ""
-        except Exception as e:
-            _logger.info(f"[PETRI] ERROR resolving events: {e}")
-            _logger.error("Exception in Petri net execution", exc_info=True)
-
         assert_pass = 0
         assert_fail = 0
 
         if assertions:
             for key, expected in assertions.get("event_counts", {}).items():
+                # The count is the LENGTH OF THE HANDLE'S REVISION RECORD (`ORC-29`): the
+                # handle `run:<id>:event:<type>` carries one version per event. Nothing here
+                # reads a blob, because the emitter no longer writes one — counting lines in
+                # an accumulated snapshot is what made the emitter accumulate, and that is
+                # what cost 114 GB.
                 actual = 0
-                for line in events_content.splitlines():
-                    if not line.strip():
-                        continue
+                try:
+                    actual = len(
+                        ctx.repo.get_handle_versions(
+                            f"run:{run_id}:event:{key}", "execution_log"
+                        )
+                    )
+                except Exception:
+                    actual = 0
+                if actual == 0:
+                    # LEGACY: a run recorded before the emitter stopped accumulating holds
+                    # its events as one blob under `run:<id>:events`.
                     try:
-                        evt_data = json.loads(line)
-                        if evt_data.get("event") == key:
-                            actual += 1
+                        legacy = (
+                            resolve_handle_content(
+                                clm_root, f"run:{run_id}:events", "execution_log"
+                            )
+                            or ""
+                        )
+                        for line in legacy.splitlines():
+                            if (
+                                f"\"event\":\"{key}\"" in line
+                                or f"\"event\": \"{key}\"" in line
+                            ):
+                                actual += 1
                     except Exception:
-                        if f"\"event\":\"{key}\"" in line or f"\"event\": \"{key}\"" in line:
-                            actual += 1
+                        pass
                 if actual == expected:
                     out_buf.append(f"  ✅ {key}: {actual} (expected {expected})")
                     assert_pass += 1

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer1/test_runner.py

@@ -389,7 +389,7 @@ process:
     post_excl_history = int(res) if res else 0
     _assert("exclude creates handle_history entry for version tracking", post_excl_history > pre_excl_history)
 
-    prev_hash = db.execute("content_memory", "SELECT previous_hash FROM handle_history WHERE handle = 'test:baldwin_exclude' ORDER BY id DESC LIMIT 1;")
+    prev_hash = db.execute("content_memory", "SELECT previous_hash FROM handle_history WHERE handle = 'test:baldwin_exclude' ORDER BY rowid DESC LIMIT 1;")
     prev_hash = prev_hash.strip() if prev_hash else None
     if prev_hash:
         prev_content = db.execute("content_memory", f"SELECT content FROM card WHERE hash = '{prev_hash}';")

{clm_kernel-0.0.2 → clm_kernel-0.0.3}/kernel/clm_py_core/clm/layer2/engine/abstract_sql_engine.py

@@ -83,20 +83,81 @@ class AbstractSqlEngine(StorageEngine):
         return MCardFromData(content_bytes, hash_value, g_time)
 
     # =====================================================================
-    # Shared: get_all_cards, get_page delegate, clear
+    # Shared: _get_tombstoned_hashes, get_all_cards, get_page delegate, clear
     # =====================================================================
 
+    def _get_tombstoned_hashes(self) -> set[str]:
+        """Resolve tombstoned card hashes.
+
+        Follows INV-TAPE-04 (Lifecycle is External):
+        1. If the tape has no lifecycle sidecar file, returns set() (the common case; no-op).
+        2. If the sidecar exists, reads tombstoned hashes from it.
+        3. During migration transition, also checks if a legacy `card_tombstone` table
+           exists on the connection and includes any hashes recorded there.
+        """
+        tombstoned: set[str] = set()
+
+        # 1. Check legacy card_tombstone table if it exists on connection (safe transition)
+        try:
+            rows = self._query_rows("SELECT hash FROM card_tombstone")
+            for r in rows:
+                if r.get("hash"):
+                    tombstoned.add(str(r["hash"]))
+        except Exception:
+            pass
+
+        # 2. Check lifecycle sidecar tape if tape is file-backed
+        db_path = getattr(self.connection, "db_path", None)
+        if db_path and db_path != ":memory:":
+            try:
+                from pathlib import Path
+                p = Path(db_path)
+                candidates = [
+                    p.parent / "lifecycle" / f"{p.stem}.lifecycle.db",
+                    p.parent / f"{p.stem}.lifecycle.db",
+                ]
+                for sc_path in candidates:
+                    if sc_path.exists():
+                        import sqlite3
+                        conn = sqlite3.connect(sc_path)
+                        try:
+                            c_rows = conn.execute(
+                                "SELECT c.content FROM handle_registry r "
+                                "JOIN card c ON c.hash = r.current_hash "
+                                "WHERE r.handle LIKE 'urn:mcard:mcard:lifecycle:%'"
+                            ).fetchall()
+                            import json
+                            for (content,) in c_rows:
+                                try:
+                                    d = json.loads(content)
+                                    if d.get("kind") == "TOMBSTONE":
+                                        sh = d.get("subject_hash")
+                                        if sh:
+                                            tombstoned.add(str(sh))
+                                        handle_sub = d.get("subject_handle")
+                                        if handle_sub and not handle_sub.startswith("urn:"):
+                                            tombstoned.add(str(handle_sub))
+                                except Exception:
+                                    pass
+                        finally:
+                            conn.close()
+                        break
+            except Exception:
+                pass
+
+        return tombstoned
+
     def get_all_cards(self) -> Page:
         """Get all non-tombstoned cards in a single page."""
-        self._ensure_tombstone_table()
-        rows = self._query_rows(
-            """
-            SELECT c.content, c.hash, c.g_time
-            FROM card c
-            LEFT JOIN card_tombstone t ON c.hash = t.hash
-            WHERE t.hash IS NULL
-            """
-        )
+        tombstoned = self._get_tombstoned_hashes()
+        if not tombstoned:
+            rows = self._query_rows("SELECT content, hash, g_time FROM card")
+        else:
+            placeholders = ", ".join("?" for _ in tombstoned)
+            rows = self._query_rows(
+                f"SELECT content, hash, g_time FROM card WHERE hash NOT IN ({placeholders})",
+                tuple(tombstoned),
+            )
         items = [self._row_to_card(r["content"], r["hash"], r["g_time"]) for r in rows]
         return Page.create(
             items=items,
@@ -154,9 +215,9 @@ class AbstractSqlEngine(StorageEngine):
             raise ValueError(f"Handle '{validated}' already exists.")
 
         self._exec_sql(
-            "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) "
-            "VALUES (?, ?, ?, ?)",
-            (validated, hash_value, now, now),
+            "INSERT INTO handle_registry (handle, current_hash, updated_at) "
+            "VALUES (?, ?, ?)",
+            (validated, hash_value, now),
         )
         logger.info(f"Registered handle '{validated}' -> {hash_value[:8]}...")
         return True
@@ -223,7 +284,7 @@ class AbstractSqlEngine(StorageEngine):
         validated = validate_handle(handle)
         rows = self._query_rows(
             "SELECT previous_hash, changed_at FROM handle_history "
-            "WHERE handle = ? ORDER BY id DESC",
+            "WHERE handle = ? ORDER BY rowid DESC",
             (validated,),
         )
         return [
@@ -280,7 +341,7 @@ class AbstractSqlEngine(StorageEngine):
 
         # Check old exists
         old_rows = self._query_rows(
-            "SELECT handle, current_hash, created_at, updated_at "
+            "SELECT handle, current_hash, updated_at "
             "FROM handle_registry WHERE handle = ?",
             (old_validated,),
         )
@@ -300,12 +361,11 @@ class AbstractSqlEngine(StorageEngine):
         # cannot simply UPDATE either table first without violating the constraint.
         old_row = old_rows[0]
         self._exec_sql(
-            "INSERT INTO handle_registry (handle, current_hash, created_at, updated_at) "
-            "VALUES (?, ?, ?, ?)",
+            "INSERT INTO handle_registry (handle, current_hash, updated_at) "
+            "VALUES (?, ?, ?)",
             (
                 new_validated,
                 old_row["current_hash"],
-                old_row["created_at"],
                 old_row["updated_at"],
             ),
         )