nexo-brain 2.6.21 → 3.0.0

package/src/db/_protocol.py

@@ -0,0 +1,303 @@
+from __future__ import annotations
+"""NEXO DB — Protocol discipline runtime."""
+
+import json
+import secrets
+import time
+
+from db._core import get_db
+
+VALID_TASK_TYPES = {"answer", "analyze", "edit", "execute", "delegate"}
+VALID_OUTCOMES = {"open", "done", "partial", "blocked", "failed", "cancelled"}
+VALID_DEBT_STATUS = {"open", "forgiven", "resolved"}
+
+
+def _task_id() -> str:
+    return f"PT-{int(time.time())}-{secrets.randbelow(100000)}"
+
+
+def _as_json(value) -> str:
+    if isinstance(value, str):
+        return value
+    if value is None:
+        value = []
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _as_bool(value) -> int:
+    return 1 if bool(value) else 0
+
+
+def create_protocol_task(
+    session_id: str,
+    goal: str,
+    *,
+    task_type: str = "answer",
+    area: str = "",
+    project_hint: str = "",
+    context_hint: str = "",
+    files=None,
+    plan=None,
+    known_facts=None,
+    unknowns=None,
+    constraints=None,
+    evidence_refs=None,
+    verification_step: str = "",
+    cortex_mode: str = "",
+    cortex_check_id: str = "",
+    cortex_blocked_reason: str = "",
+    cortex_warnings=None,
+    cortex_rules=None,
+    opened_with_guard: bool = False,
+    opened_with_rules: bool = False,
+    guard_has_blocking: bool = False,
+    guard_summary: str = "",
+    must_verify: bool = False,
+    must_change_log: bool = False,
+    must_learning_if_corrected: bool = True,
+    must_write_diary_on_close: bool = False,
+    response_mode: str = "",
+    response_confidence: int = 0,
+    response_reasons=None,
+    response_high_stakes: bool = False,
+) -> dict:
+    conn = get_db()
+    task_id = _task_id()
+    clean_type = task_type if task_type in VALID_TASK_TYPES else "answer"
+    conn.execute(
+        """INSERT INTO protocol_tasks (
+               task_id, session_id, goal, task_type, area, project_hint, context_hint,
+               files, plan, known_facts, unknowns, constraints, evidence_refs, verification_step,
+               cortex_mode, cortex_check_id, cortex_blocked_reason, cortex_warnings, cortex_rules,
+               opened_with_guard, opened_with_rules, guard_has_blocking, guard_summary,
+               must_verify, must_change_log, must_learning_if_corrected, must_write_diary_on_close,
+               response_mode, response_confidence, response_reasons, response_high_stakes
+           ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+        (
+            task_id,
+            session_id.strip(),
+            goal.strip(),
+            clean_type,
+            area.strip(),
+            project_hint.strip(),
+            context_hint.strip(),
+            _as_json(files),
+            _as_json(plan),
+            _as_json(known_facts),
+            _as_json(unknowns),
+            _as_json(constraints),
+            _as_json(evidence_refs),
+            verification_step.strip(),
+            cortex_mode.strip(),
+            cortex_check_id.strip(),
+            cortex_blocked_reason.strip(),
+            _as_json(cortex_warnings),
+            _as_json(cortex_rules),
+            _as_bool(opened_with_guard),
+            _as_bool(opened_with_rules),
+            _as_bool(guard_has_blocking),
+            guard_summary[:4000],
+            _as_bool(must_verify),
+            _as_bool(must_change_log),
+            _as_bool(must_learning_if_corrected),
+            _as_bool(must_write_diary_on_close),
+            response_mode.strip(),
+            max(0, int(response_confidence or 0)),
+            _as_json(response_reasons),
+            _as_bool(response_high_stakes),
+        ),
+    )
+    conn.commit()
+    return get_protocol_task(task_id)
+
+
+def get_protocol_task(task_id: str) -> dict | None:
+    conn = get_db()
+    row = conn.execute("SELECT * FROM protocol_tasks WHERE task_id = ?", (task_id,)).fetchone()
+    return dict(row) if row else None
+
+
+def close_protocol_task(
+    task_id: str,
+    *,
+    outcome: str,
+    evidence: str = "",
+    files_changed=None,
+    correction_happened: bool = False,
+    change_log_id: int | None = None,
+    learning_id: int | None = None,
+    followup_id: str = "",
+    outcome_notes: str = "",
+) -> dict:
+    conn = get_db()
+    clean_outcome = outcome if outcome in VALID_OUTCOMES else "failed"
+    conn.execute(
+        """UPDATE protocol_tasks
+           SET status = ?,
+               close_evidence = ?,
+               files_changed = ?,
+               correction_happened = ?,
+               change_log_id = ?,
+               learning_id = ?,
+               followup_id = ?,
+               outcome_notes = ?,
+               closed_at = datetime('now')
+           WHERE task_id = ?""",
+        (
+            clean_outcome,
+            evidence[:4000],
+            _as_json(files_changed),
+            _as_bool(correction_happened),
+            change_log_id,
+            learning_id,
+            followup_id[:120],
+            outcome_notes[:4000],
+            task_id,
+        ),
+    )
+    conn.commit()
+    return get_protocol_task(task_id) or {}
+
+
+def create_protocol_debt(
+    session_id: str,
+    debt_type: str,
+    *,
+    severity: str = "warn",
+    task_id: str = "",
+    evidence: str = "",
+) -> dict:
+    conn = get_db()
+    cursor = conn.execute(
+        """INSERT INTO protocol_debt (session_id, task_id, debt_type, severity, evidence)
+           VALUES (?, ?, ?, ?, ?)""",
+        (
+            session_id.strip(),
+            task_id.strip(),
+            debt_type.strip(),
+            severity if severity in {"info", "warn", "error"} else "warn",
+            evidence[:4000],
+        ),
+    )
+    conn.commit()
+    row = conn.execute("SELECT * FROM protocol_debt WHERE id = ?", (cursor.lastrowid,)).fetchone()
+    return dict(row)
+
+
+def resolve_protocol_debts(
+    *,
+    session_id: str = "",
+    task_id: str = "",
+    debt_types: list[str] | None = None,
+    resolution: str = "",
+) -> int:
+    conn = get_db()
+    clauses = ["status = 'open'"]
+    params: list[str] = []
+    if session_id:
+        clauses.append("session_id = ?")
+        params.append(session_id.strip())
+    if task_id:
+        clauses.append("task_id = ?")
+        params.append(task_id.strip())
+    if debt_types:
+        placeholders = ",".join("?" * len(debt_types))
+        clauses.append(f"debt_type IN ({placeholders})")
+        params.extend([item.strip() for item in debt_types if item.strip()])
+    where = " AND ".join(clauses)
+    cursor = conn.execute(
+        f"""UPDATE protocol_debt
+            SET status = 'resolved',
+                resolution = ?,
+                resolved_at = datetime('now')
+            WHERE {where}""",
+        [resolution[:4000]] + params,
+    )
+    conn.commit()
+    return cursor.rowcount
+
+
+def list_protocol_debts(*, status: str = "open", task_id: str = "", limit: int = 50) -> list[dict]:
+    conn = get_db()
+    clauses = []
+    params: list[object] = []
+    if status in VALID_DEBT_STATUS:
+        clauses.append("status = ?")
+        params.append(status)
+    if task_id:
+        clauses.append("task_id = ?")
+        params.append(task_id.strip())
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    rows = conn.execute(
+        f"SELECT * FROM protocol_debt {where} ORDER BY created_at DESC LIMIT ?",
+        params + [max(1, int(limit))],
+    ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def protocol_compliance_summary(days: int = 7) -> dict:
+    conn = get_db()
+    window = f"-{max(1, int(days))} days"
+    tasks = conn.execute(
+        """SELECT * FROM protocol_tasks
+           WHERE opened_at >= datetime('now', ?)
+           ORDER BY opened_at DESC""",
+        (window,),
+    ).fetchall()
+    open_debts = conn.execute(
+        """SELECT severity, debt_type, COUNT(*) AS total
+           FROM protocol_debt
+           WHERE status = 'open' AND created_at >= datetime('now', ?)
+           GROUP BY severity, debt_type
+           ORDER BY total DESC, debt_type ASC""",
+        (window,),
+    ).fetchall()
+
+    closed_tasks = [dict(row) for row in tasks if row["status"] != "open"]
+    verify_required = [row for row in closed_tasks if row["must_verify"] and row["status"] == "done"]
+    verify_ok = [row for row in verify_required if (row.get("close_evidence") or "").strip()]
+    change_required = [row for row in closed_tasks if row["must_change_log"]]
+    change_ok = [row for row in change_required if row["change_log_id"]]
+    learning_required = [row for row in closed_tasks if row["correction_happened"]]
+    learning_ok = [row for row in learning_required if row["learning_id"]]
+    action_tasks = [row for row in tasks if row["task_type"] in ("edit", "execute", "delegate")]
+    cortex_ok = [row for row in action_tasks if row["cortex_mode"] == "act"]
+
+    score_parts = []
+    if verify_required:
+        score_parts.append((len(verify_ok) / len(verify_required)) * 100)
+    if change_required:
+        score_parts.append((len(change_ok) / len(change_required)) * 100)
+    if learning_required:
+        score_parts.append((len(learning_ok) / len(learning_required)) * 100)
+    if action_tasks:
+        score_parts.append((len(cortex_ok) / len(action_tasks)) * 100)
+
+    base_score = (sum(score_parts) / len(score_parts)) if score_parts else (100.0 if tasks else 0.0)
+    warn_debt = sum(row["total"] for row in open_debts if row["severity"] == "warn")
+    error_debt = sum(row["total"] for row in open_debts if row["severity"] == "error")
+    debt_penalty = min(60, (warn_debt * 5) + (error_debt * 20))
+    overall = max(0.0, round(base_score - debt_penalty, 1))
+
+    return {
+        "days": max(1, int(days)),
+        "tasks_total": len(tasks),
+        "tasks_closed": len(closed_tasks),
+        "verify_required": len(verify_required),
+        "verify_ok": len(verify_ok),
+        "verify_pct": round((len(verify_ok) / len(verify_required)) * 100, 1) if verify_required else None,
+        "change_required": len(change_required),
+        "change_ok": len(change_ok),
+        "change_pct": round((len(change_ok) / len(change_required)) * 100, 1) if change_required else None,
+        "learning_required": len(learning_required),
+        "learning_ok": len(learning_ok),
+        "learning_pct": round((len(learning_ok) / len(learning_required)) * 100, 1) if learning_required else None,
+        "action_tasks": len(action_tasks),
+        "cortex_ok": len(cortex_ok),
+        "cortex_pct": round((len(cortex_ok) / len(action_tasks)) * 100, 1) if action_tasks else None,
+        "open_debt_total": warn_debt + error_debt,
+        "open_warn_debt": warn_debt,
+        "open_error_debt": error_debt,
+        "open_debt_breakdown": [dict(row) for row in open_debts],
+        "overall_compliance_pct": overall,
+    }

package/src/db/_schema.py

@@ -433,6 +433,247 @@ def _m20_personal_scripts_registry(conn):
     _migrate_add_index(conn, "idx_personal_script_schedules_enabled", "personal_script_schedules", "enabled")
 
 
+def _m22_protocol_discipline_tables(conn):
+    """Protocol discipline runtime: persistent task contracts + debt tracking."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS protocol_tasks (
+            task_id TEXT PRIMARY KEY,
+            session_id TEXT NOT NULL,
+            goal TEXT NOT NULL,
+            task_type TEXT NOT NULL DEFAULT 'answer',
+            area TEXT DEFAULT '',
+            project_hint TEXT DEFAULT '',
+            context_hint TEXT DEFAULT '',
+            files TEXT DEFAULT '[]',
+            plan TEXT DEFAULT '[]',
+            known_facts TEXT DEFAULT '[]',
+            unknowns TEXT DEFAULT '[]',
+            constraints TEXT DEFAULT '[]',
+            evidence_refs TEXT DEFAULT '[]',
+            verification_step TEXT DEFAULT '',
+            cortex_mode TEXT DEFAULT '',
+            cortex_check_id TEXT DEFAULT '',
+            cortex_blocked_reason TEXT DEFAULT '',
+            cortex_warnings TEXT DEFAULT '[]',
+            cortex_rules TEXT DEFAULT '[]',
+            opened_with_guard INTEGER NOT NULL DEFAULT 0,
+            opened_with_rules INTEGER NOT NULL DEFAULT 0,
+            guard_has_blocking INTEGER NOT NULL DEFAULT 0,
+            guard_summary TEXT DEFAULT '',
+            must_verify INTEGER NOT NULL DEFAULT 0,
+            must_change_log INTEGER NOT NULL DEFAULT 0,
+            must_learning_if_corrected INTEGER NOT NULL DEFAULT 1,
+            must_write_diary_on_close INTEGER NOT NULL DEFAULT 0,
+            status TEXT NOT NULL DEFAULT 'open',
+            close_evidence TEXT DEFAULT '',
+            files_changed TEXT DEFAULT '[]',
+            correction_happened INTEGER NOT NULL DEFAULT 0,
+            change_log_id INTEGER,
+            learning_id INTEGER,
+            followup_id TEXT DEFAULT '',
+            outcome_notes TEXT DEFAULT '',
+            opened_at TEXT DEFAULT (datetime('now')),
+            closed_at TEXT DEFAULT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS protocol_debt (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT DEFAULT '',
+            task_id TEXT DEFAULT '',
+            debt_type TEXT NOT NULL,
+            severity TEXT NOT NULL DEFAULT 'warn',
+            status TEXT NOT NULL DEFAULT 'open',
+            evidence TEXT DEFAULT '',
+            resolution TEXT DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now')),
+            resolved_at TEXT DEFAULT NULL
+        )
+    """)
+    _migrate_add_index(conn, "idx_protocol_tasks_session", "protocol_tasks", "session_id")
+    _migrate_add_index(conn, "idx_protocol_tasks_status", "protocol_tasks", "status")
+    _migrate_add_index(conn, "idx_protocol_tasks_opened", "protocol_tasks", "opened_at")
+    _migrate_add_index(conn, "idx_protocol_debt_session", "protocol_debt", "session_id")
+    _migrate_add_index(conn, "idx_protocol_debt_task", "protocol_debt", "task_id")
+    _migrate_add_index(conn, "idx_protocol_debt_status", "protocol_debt", "status")
+    _migrate_add_index(conn, "idx_protocol_debt_created", "protocol_debt", "created_at")
+
+
+def _m23_learning_superseded_lifecycle(conn):
+    """Track canonical learning replacement instead of leaving rule drift implicit."""
+    _migrate_add_column(conn, "learnings", "supersedes_id", "INTEGER")
+    _migrate_add_index(conn, "idx_learnings_supersedes", "learnings", "supersedes_id")
+
+
+def _m24_durable_workflow_runtime(conn):
+    """Durable workflow execution runtime for long multi-step tasks."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS workflow_runs (
+            run_id TEXT PRIMARY KEY,
+            session_id TEXT DEFAULT '',
+            protocol_task_id TEXT DEFAULT '',
+            goal TEXT NOT NULL,
+            workflow_kind TEXT DEFAULT 'general',
+            status TEXT NOT NULL DEFAULT 'open',
+            priority TEXT NOT NULL DEFAULT 'normal',
+            idempotency_key TEXT DEFAULT '',
+            shared_state TEXT DEFAULT '{}',
+            next_action TEXT DEFAULT '',
+            current_step_key TEXT DEFAULT '',
+            last_checkpoint_label TEXT DEFAULT '',
+            owner TEXT DEFAULT '',
+            opened_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            closed_at TEXT DEFAULT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS workflow_steps (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            run_id TEXT NOT NULL,
+            step_key TEXT NOT NULL,
+            title TEXT NOT NULL DEFAULT '',
+            step_index INTEGER NOT NULL DEFAULT 999,
+            status TEXT NOT NULL DEFAULT 'pending',
+            attempt_count INTEGER NOT NULL DEFAULT 0,
+            max_retries INTEGER NOT NULL DEFAULT 0,
+            retry_policy TEXT DEFAULT '',
+            retry_after TEXT DEFAULT '',
+            human_gate INTEGER NOT NULL DEFAULT 0,
+            requires_approval INTEGER NOT NULL DEFAULT 0,
+            compensation TEXT DEFAULT '',
+            last_summary TEXT DEFAULT '',
+            last_evidence TEXT DEFAULT '',
+            last_state_patch TEXT DEFAULT '{}',
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            started_at TEXT DEFAULT NULL,
+            completed_at TEXT DEFAULT NULL,
+            UNIQUE(run_id, step_key)
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS workflow_checkpoints (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            run_id TEXT NOT NULL,
+            step_key TEXT DEFAULT '',
+            checkpoint_label TEXT NOT NULL DEFAULT 'checkpoint',
+            run_status TEXT DEFAULT '',
+            step_status TEXT DEFAULT '',
+            summary TEXT DEFAULT '',
+            shared_state TEXT DEFAULT '{}',
+            state_patch TEXT DEFAULT '{}',
+            evidence TEXT DEFAULT '',
+            next_action TEXT DEFAULT '',
+            retry_after TEXT DEFAULT '',
+            requires_approval INTEGER NOT NULL DEFAULT 0,
+            compensation_note TEXT DEFAULT '',
+            attempt INTEGER NOT NULL DEFAULT 0,
+            actor TEXT DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    _migrate_add_index(conn, "idx_workflow_runs_session", "workflow_runs", "session_id")
+    _migrate_add_index(conn, "idx_workflow_runs_status", "workflow_runs", "status")
+    _migrate_add_index(conn, "idx_workflow_runs_updated", "workflow_runs", "updated_at")
+    _migrate_add_index(conn, "idx_workflow_runs_protocol_task", "workflow_runs", "protocol_task_id")
+    _migrate_add_index(conn, "idx_workflow_runs_idempotency", "workflow_runs", "idempotency_key")
+    _migrate_add_index(conn, "idx_workflow_steps_run", "workflow_steps", "run_id")
+    _migrate_add_index(conn, "idx_workflow_steps_status", "workflow_steps", "status")
+    _migrate_add_index(conn, "idx_workflow_checkpoints_run", "workflow_checkpoints", "run_id")
+    _migrate_add_index(conn, "idx_workflow_checkpoints_created", "workflow_checkpoints", "created_at")
+
+
+def _m25_workflow_goal_stack(conn):
+    """Durable goal stack linked to workflows."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS workflow_goals (
+            goal_id TEXT PRIMARY KEY,
+            session_id TEXT DEFAULT '',
+            title TEXT NOT NULL,
+            objective TEXT DEFAULT '',
+            parent_goal_id TEXT DEFAULT '',
+            status TEXT NOT NULL DEFAULT 'active',
+            priority TEXT NOT NULL DEFAULT 'normal',
+            owner TEXT DEFAULT '',
+            next_action TEXT DEFAULT '',
+            success_signal TEXT DEFAULT '',
+            blocker_reason TEXT DEFAULT '',
+            shared_state TEXT DEFAULT '{}',
+            opened_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now')),
+            closed_at TEXT DEFAULT NULL
+        )
+    """)
+    _migrate_add_column(conn, "workflow_runs", "goal_id", "TEXT DEFAULT ''")
+    _migrate_add_index(conn, "idx_workflow_goals_status", "workflow_goals", "status")
+    _migrate_add_index(conn, "idx_workflow_goals_parent", "workflow_goals", "parent_goal_id")
+    _migrate_add_index(conn, "idx_workflow_goals_updated", "workflow_goals", "updated_at")
+    _migrate_add_index(conn, "idx_workflow_goals_session", "workflow_goals", "session_id")
+    _migrate_add_index(conn, "idx_workflow_runs_goal", "workflow_runs", "goal_id")
+
+
+def _m26_protocol_answer_confidence(conn):
+    """Persist answer/analyze response mode so discipline survives the prompt."""
+    _migrate_add_column(conn, "protocol_tasks", "response_mode", "TEXT DEFAULT ''")
+    _migrate_add_column(conn, "protocol_tasks", "response_confidence", "INTEGER DEFAULT 0")
+    _migrate_add_column(conn, "protocol_tasks", "response_reasons", "TEXT DEFAULT '[]'")
+    _migrate_add_column(conn, "protocol_tasks", "response_high_stakes", "INTEGER DEFAULT 0")
+
+
+def _m27_state_watchers(conn):
+    """Persistent state watchers for drift, health, and expiry tracking."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS state_watchers (
+            watcher_id TEXT PRIMARY KEY,
+            watcher_type TEXT NOT NULL,
+            title TEXT NOT NULL,
+            target TEXT DEFAULT '',
+            severity TEXT NOT NULL DEFAULT 'warn',
+            status TEXT NOT NULL DEFAULT 'active',
+            config TEXT DEFAULT '{}',
+            last_health TEXT NOT NULL DEFAULT 'unknown',
+            last_result TEXT DEFAULT '{}',
+            last_checked_at TEXT DEFAULT '',
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    _migrate_add_index(conn, "idx_state_watchers_type", "state_watchers", "watcher_type")
+    _migrate_add_index(conn, "idx_state_watchers_status", "state_watchers", "status")
+    _migrate_add_index(conn, "idx_state_watchers_health", "state_watchers", "last_health")
+
+
+def _m28_automation_runs(conn):
+    """Persist automation-backend telemetry for parity, degraded-mode audits, and cost metrics."""
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS automation_runs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            backend TEXT NOT NULL,
+            task_profile TEXT DEFAULT 'default',
+            model TEXT DEFAULT '',
+            reasoning_effort TEXT DEFAULT '',
+            cwd TEXT DEFAULT '',
+            output_format TEXT DEFAULT 'text',
+            prompt_chars INTEGER DEFAULT 0,
+            returncode INTEGER DEFAULT 0,
+            duration_ms INTEGER DEFAULT 0,
+            input_tokens INTEGER DEFAULT 0,
+            cached_input_tokens INTEGER DEFAULT 0,
+            output_tokens INTEGER DEFAULT 0,
+            total_cost_usd REAL,
+            telemetry_source TEXT DEFAULT '',
+            cost_source TEXT DEFAULT '',
+            status TEXT DEFAULT 'ok',
+            metadata TEXT DEFAULT '{}',
+            created_at TEXT DEFAULT (datetime('now'))
+        )
+    """)
+    _migrate_add_index(conn, "idx_automation_runs_backend", "automation_runs", "backend")
+    _migrate_add_index(conn, "idx_automation_runs_created", "automation_runs", "created_at")
+    _migrate_add_index(conn, "idx_automation_runs_status", "automation_runs", "status")
+
+
 MIGRATIONS = [
     (1, "learnings_columns", _m1_learnings_columns),
     (2, "followups_reasoning", _m2_followups_reasoning),
@@ -455,6 +696,13 @@ MIGRATIONS = [
     (19, "skills_v2", _m19_skills_v2),
     (20, "personal_scripts_registry", _m20_personal_scripts_registry),
     (21, "external_session_fields", _m21_external_session_fields),
+    (22, "protocol_discipline_tables", _m22_protocol_discipline_tables),
+    (23, "learning_superseded_lifecycle", _m23_learning_superseded_lifecycle),
+    (24, "durable_workflow_runtime", _m24_durable_workflow_runtime),
+    (25, "workflow_goal_stack", _m25_workflow_goal_stack),
+    (26, "protocol_answer_confidence", _m26_protocol_answer_confidence),
+    (27, "state_watchers", _m27_state_watchers),
+    (28, "automation_runs", _m28_automation_runs),
 ]