nexo-brain 7.1.8 → 7.2.0

package/src/checkpoint_policy.py

@@ -0,0 +1,302 @@
+"""Durable checkpoint policy for long-running multi-step work.
+
+This module turns task/workflow milestones into a small persistent state file
+and periodically flushes that state into ``session_checkpoints`` so compaction
+and phase switches recover a richer next-step snapshot than the heartbeat-only
+goal stub.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+STATE_PATH = NEXO_HOME / "runtime" / "data" / "durable_checkpoint_state.json"
+DEFAULT_MILESTONE_INTERVAL = 3
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _ensure_dir() -> None:
+    STATE_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _load_all() -> dict[str, dict[str, Any]]:
+    try:
+        raw = json.loads(STATE_PATH.read_text())
+    except FileNotFoundError:
+        return {}
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return raw if isinstance(raw, dict) else {}
+
+
+def _save_all(payload: dict[str, dict[str, Any]]) -> None:
+    _ensure_dir()
+    STATE_PATH.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+def _blank_session_state(session_id: str) -> dict[str, Any]:
+    return {
+        "session_id": session_id,
+        "milestone_count": 0,
+        "updated_at": _now_iso(),
+        "last_reason": "",
+        "task": "",
+        "task_status": "active",
+        "active_files": [],
+        "current_goal": "",
+        "decisions_summary": "",
+        "blockers": "",
+        "reasoning_thread": "",
+        "next_step": "",
+        "last_flushed_at": "",
+        "last_flush_reason": "",
+    }
+
+
+def _coalesce_text(new_value: str, old_value: str = "") -> str:
+    clean = str(new_value or "").strip()
+    return clean or str(old_value or "").strip()
+
+
+def _normalize_active_files(active_files: Any) -> list[str]:
+    if active_files is None:
+        return []
+    if isinstance(active_files, str):
+        stripped = active_files.strip()
+        if not stripped:
+            return []
+        if stripped.startswith("["):
+            try:
+                parsed = json.loads(stripped)
+            except json.JSONDecodeError:
+                parsed = [part.strip() for part in stripped.split(",") if part.strip()]
+        else:
+            parsed = [part.strip() for part in stripped.split(",") if part.strip()]
+    elif isinstance(active_files, (list, tuple, set)):
+        parsed = list(active_files)
+    else:
+        parsed = [str(active_files).strip()]
+
+    seen: list[str] = []
+    for item in parsed:
+        clean = str(item or "").strip()
+        if clean and clean not in seen:
+            seen.append(clean)
+    return seen
+
+
+def _session_state(all_state: dict[str, dict[str, Any]], session_id: str) -> dict[str, Any]:
+    existing = all_state.get(session_id)
+    if not isinstance(existing, dict):
+        return _blank_session_state(session_id)
+    base = _blank_session_state(session_id)
+    base.update(existing)
+    base["session_id"] = session_id
+    base["active_files"] = _normalize_active_files(base.get("active_files"))
+    try:
+        base["milestone_count"] = max(0, int(base.get("milestone_count", 0)))
+    except (TypeError, ValueError):
+        base["milestone_count"] = 0
+    return base
+
+
+def _extract_active_files_from_payload(payload: dict[str, Any] | None) -> list[str]:
+    if not isinstance(payload, dict):
+        return []
+    for key in ("active_files", "files", "tracked_files"):
+        files = _normalize_active_files(payload.get(key))
+        if files:
+            return files
+    return []
+
+
+def _flush_state(
+    all_state: dict[str, dict[str, Any]],
+    session_id: str,
+    state: dict[str, Any],
+    *,
+    reason: str,
+) -> dict[str, Any]:
+    from db import save_checkpoint
+
+    decisions_summary = _coalesce_text(state.get("decisions_summary", ""))
+    if reason:
+        reason_note = f"checkpoint_reason={reason}"
+        decisions_summary = f"{decisions_summary} | {reason_note}".strip(" |")
+
+    active_files = _normalize_active_files(state.get("active_files"))
+    save_result = save_checkpoint(
+        sid=session_id,
+        task=_coalesce_text(state.get("task", ""), state.get("current_goal", "")),
+        task_status=_coalesce_text(state.get("task_status", ""), "active"),
+        active_files=json.dumps(active_files, ensure_ascii=False),
+        current_goal=_coalesce_text(state.get("current_goal", ""), state.get("task", "")),
+        decisions_summary=decisions_summary,
+        errors_found=_coalesce_text(state.get("blockers", "")),
+        reasoning_thread=_coalesce_text(state.get("reasoning_thread", "")),
+        next_step=_coalesce_text(state.get("next_step", "")),
+    )
+
+    state["active_files"] = active_files
+    state["milestone_count"] = 0
+    state["last_flushed_at"] = _now_iso()
+    state["last_flush_reason"] = reason
+    state["updated_at"] = _now_iso()
+    all_state[session_id] = state
+    _save_all(all_state)
+    return {
+        "ok": True,
+        "checkpoint_written": True,
+        "session_id": session_id,
+        "milestone_count": 0,
+        "last_flush_reason": reason,
+        "compaction_count": save_result.get("compaction_count", 0),
+    }
+
+
+def record_milestone(
+    session_id: str,
+    *,
+    reason: str,
+    task: str = "",
+    task_status: str = "active",
+    active_files: Any = None,
+    current_goal: str = "",
+    decisions_summary: str = "",
+    blockers: str = "",
+    reasoning_thread: str = "",
+    next_step: str = "",
+    interval: int = DEFAULT_MILESTONE_INTERVAL,
+    force_flush: bool = False,
+) -> dict[str, Any]:
+    clean_sid = str(session_id or "").strip()
+    if not clean_sid:
+        return {"ok": False, "error": "session_id is required"}
+
+    all_state = _load_all()
+    state = _session_state(all_state, clean_sid)
+
+    state["last_reason"] = str(reason or "").strip()
+    state["updated_at"] = _now_iso()
+    state["task"] = _coalesce_text(task, state.get("task", ""))
+    state["task_status"] = _coalesce_text(task_status, state.get("task_status", "active"))
+    state["current_goal"] = _coalesce_text(current_goal, state.get("current_goal", ""))
+    state["decisions_summary"] = _coalesce_text(decisions_summary, state.get("decisions_summary", ""))
+    state["blockers"] = _coalesce_text(blockers, state.get("blockers", ""))
+    state["reasoning_thread"] = _coalesce_text(reasoning_thread, state.get("reasoning_thread", ""))
+    state["next_step"] = _coalesce_text(next_step, state.get("next_step", ""))
+
+    files = _normalize_active_files(active_files)
+    if files:
+        state["active_files"] = files
+
+    state["milestone_count"] = max(0, int(state.get("milestone_count", 0))) + 1
+    all_state[clean_sid] = state
+
+    flush_every = max(1, int(interval or DEFAULT_MILESTONE_INTERVAL))
+    if force_flush or state["milestone_count"] >= flush_every:
+        return _flush_state(all_state, clean_sid, state, reason=str(reason or "").strip())
+
+    _save_all(all_state)
+    return {
+        "ok": True,
+        "checkpoint_written": False,
+        "session_id": clean_sid,
+        "milestone_count": state["milestone_count"],
+        "flush_interval": flush_every,
+        "pending_reason": state["last_reason"],
+    }
+
+
+def force_runtime_checkpoint(session_id: str, *, reason: str = "pre-compact") -> dict[str, Any]:
+    clean_sid = str(session_id or "").strip()
+    if not clean_sid:
+        return {"ok": False, "error": "session_id is required"}
+
+    from db import get_db, read_checkpoint
+
+    all_state = _load_all()
+    state = _session_state(all_state, clean_sid)
+    conn = get_db()
+
+    session_row = conn.execute(
+        "SELECT task FROM sessions WHERE sid = ? LIMIT 1",
+        (clean_sid,),
+    ).fetchone()
+    existing_checkpoint = read_checkpoint(clean_sid) or {}
+    workflow_row = conn.execute(
+        """SELECT goal, status, current_step_key, next_action, shared_state
+           FROM workflow_runs
+           WHERE session_id = ?
+           ORDER BY updated_at DESC LIMIT 1""",
+        (clean_sid,),
+    ).fetchone()
+
+    workflow_state: dict[str, Any] = {}
+    if workflow_row and workflow_row["shared_state"]:
+        try:
+            parsed = json.loads(workflow_row["shared_state"])
+            if isinstance(parsed, dict):
+                workflow_state = parsed
+        except json.JSONDecodeError:
+            workflow_state = {}
+
+    workflow_blocker = ""
+    if workflow_row and workflow_row["status"] in {"blocked", "waiting_approval"}:
+        workflow_blocker = (
+            f"Workflow {workflow_row['status']} at "
+            f"{workflow_row['current_step_key'] or 'current-step'}"
+        )
+
+    merged_files = (
+        _normalize_active_files(state.get("active_files"))
+        or _extract_active_files_from_payload(workflow_state)
+        or _normalize_active_files(existing_checkpoint.get("active_files"))
+    )
+
+    state["task"] = _coalesce_text(
+        state.get("task", ""),
+        (session_row["task"] if session_row else "") or existing_checkpoint.get("task", ""),
+    )
+    state["current_goal"] = _coalesce_text(
+        state.get("current_goal", ""),
+        (workflow_row["goal"] if workflow_row else "") or existing_checkpoint.get("current_goal", "") or state.get("task", ""),
+    )
+    state["decisions_summary"] = _coalesce_text(
+        state.get("decisions_summary", ""),
+        existing_checkpoint.get("decisions_summary", "") or f"Forced durable checkpoint before {reason}.",
+    )
+    current_blockers = _coalesce_text(
+        state.get("blockers", ""),
+        existing_checkpoint.get("errors_found", ""),
+    )
+    if workflow_blocker:
+        if workflow_blocker not in current_blockers:
+            current_blockers = f"{workflow_blocker} | {current_blockers}".strip(" |")
+    state["blockers"] = current_blockers
+    state["reasoning_thread"] = _coalesce_text(
+        state.get("reasoning_thread", ""),
+        existing_checkpoint.get("reasoning_thread", "") or f"Auto-flushed by checkpoint_policy ({reason}).",
+    )
+    state["next_step"] = _coalesce_text(
+        state.get("next_step", ""),
+        (workflow_row["next_action"] if workflow_row else "") or existing_checkpoint.get("next_step", ""),
+    )
+    state["task_status"] = _coalesce_text(
+        state.get("task_status", ""),
+        (workflow_row["status"] if workflow_row else "") or existing_checkpoint.get("task_status", "") or "active",
+    )
+    state["active_files"] = merged_files
+    state["updated_at"] = _now_iso()
+    state["last_reason"] = reason
+    all_state[clean_sid] = state
+    return _flush_state(all_state, clean_sid, state, reason=reason)

package/src/cli.py

@@ -1168,6 +1168,199 @@ def _recover(args):
     return _recover_cli_main(argv)
 
 
+def _rollback_f06(args):
+    """Revert the F0.6 layout migration using ``~/.nexo-pre-f06-snapshot``.
+
+    Safe two-stage swap: the current ``~/.nexo`` tree is renamed to a dated
+    backup (``~/.nexo-rollback-backup-YYYYMMDDHHMMSS``) BEFORE the snapshot is
+    restored in its place, so the operation never destroys state if it is
+    interrupted mid-way. LaunchAgents are booted out before the swap and
+    reloaded after (skip via ``--keep-agents-running``).
+    """
+    import json as _json
+    import shutil as _shutil
+    import subprocess as _subprocess
+    from datetime import datetime as _datetime
+    from pathlib import Path as _Path
+
+    nexo_home = _Path(os.environ.get("NEXO_HOME", str(_Path.home() / ".nexo")))
+    snapshot = _Path(str(nexo_home) + "-pre-f06-snapshot")
+    now_stamp = _datetime.now().strftime("%Y%m%d%H%M%S")
+    dry_run = bool(getattr(args, "dry_run", False))
+    emit_json = bool(getattr(args, "json", False))
+    assume_yes = bool(getattr(args, "yes", False))
+    keep_agents = bool(getattr(args, "keep_agents_running", False))
+
+    report: dict[str, object] = {
+        "nexo_home": str(nexo_home),
+        "snapshot": str(snapshot),
+        "snapshot_exists": snapshot.exists(),
+        "snapshot_is_dir": snapshot.is_dir() if snapshot.exists() else False,
+        "dry_run": dry_run,
+        "steps": [],
+        "status": "planned",
+    }
+
+    if not snapshot.exists() or not snapshot.is_dir():
+        report["status"] = "error_no_snapshot"
+        report["error"] = f"Pre-F0.6 snapshot not found at {snapshot}"
+        if emit_json:
+            print(_json.dumps(report, indent=2))
+        else:
+            print(f"ERROR: no pre-F0.6 snapshot at {snapshot}", file=sys.stderr)
+            print("       Rollback is only available immediately after a migration.", file=sys.stderr)
+        return 1
+
+    if nexo_home.exists():
+        backup_target = _Path(str(nexo_home) + f"-rollback-backup-{now_stamp}")
+        # Avoid collision if the operator retries in the same second.
+        collision_suffix = 0
+        while backup_target.exists():
+            collision_suffix += 1
+            backup_target = _Path(str(nexo_home) + f"-rollback-backup-{now_stamp}-{collision_suffix}")
+    else:
+        backup_target = None
+
+    agents_to_restart: list[_Path] = []
+    if not keep_agents:
+        agents_dir = _Path.home() / "Library" / "LaunchAgents"
+        if agents_dir.is_dir():
+            agents_to_restart = sorted(agents_dir.glob("com.nexo.*.plist"))
+
+    plan_steps: list[dict] = []
+    if agents_to_restart:
+        plan_steps.append({
+            "step": "bootout_launchagents",
+            "count": len(agents_to_restart),
+            "samples": [p.name for p in agents_to_restart[:5]],
+        })
+    if backup_target is not None:
+        plan_steps.append({
+            "step": "move_current_nexo_home_to_backup",
+            "from": str(nexo_home),
+            "to": str(backup_target),
+        })
+    plan_steps.append({
+        "step": "move_snapshot_to_nexo_home",
+        "from": str(snapshot),
+        "to": str(nexo_home),
+    })
+    if agents_to_restart:
+        plan_steps.append({
+            "step": "reload_launchagents",
+            "count": len(agents_to_restart),
+        })
+    report["steps"] = plan_steps
+
+    if dry_run:
+        report["status"] = "dry_run"
+        if emit_json:
+            print(_json.dumps(report, indent=2))
+        else:
+            print(f"nexo rollback f06 (DRY-RUN)")
+            print(f"  NEXO_HOME: {nexo_home}")
+            print(f"  snapshot:  {snapshot}")
+            if backup_target is not None:
+                print(f"  backup → {backup_target}")
+            if agents_to_restart:
+                print(f"  LaunchAgents to restart: {len(agents_to_restart)}")
+            print("  (no filesystem or launchctl changes were made)")
+        return 0
+
+    if not assume_yes:
+        if not (sys.stdin.isatty() and sys.stdout.isatty()):
+            print("ERROR: interactive confirmation required. Pass --yes to proceed non-interactively.", file=sys.stderr)
+            return 1
+        print("This will replace the current NEXO_HOME with the pre-F0.6 snapshot.")
+        print(f"  Current ~/.nexo → {backup_target if backup_target else '(nothing to back up, current missing)'}")
+        print(f"  Restored from snapshot → {nexo_home}")
+        if agents_to_restart:
+            print(f"  LaunchAgents affected: {len(agents_to_restart)}")
+        answer = input("Type 'ROLLBACK' to proceed: ").strip()
+        if answer != "ROLLBACK":
+            print("Aborted — exact token not typed.")
+            return 1
+
+    def _run_launchctl(cmd: list[str]) -> tuple[int, str]:
+        try:
+            proc = _subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+            return proc.returncode, (proc.stderr or "").strip()
+        except _subprocess.TimeoutExpired as exc:
+            return 124, f"timeout: {exc}"
+        except FileNotFoundError:
+            return 127, "launchctl not found"
+        except Exception as exc:  # noqa: BLE001  — launchctl errors are varied
+            return 1, str(exc)
+
+    executed: list[dict] = []
+
+    if agents_to_restart and not keep_agents:
+        for plist in agents_to_restart:
+            rc, err = _run_launchctl(["launchctl", "unload", str(plist)])
+            executed.append({"op": "unload", "plist": str(plist), "rc": rc, "err": err})
+
+    if backup_target is not None:
+        try:
+            nexo_home.rename(backup_target)
+            executed.append({"op": "rename_home", "to": str(backup_target), "rc": 0})
+        except OSError as exc:
+            executed.append({"op": "rename_home", "to": str(backup_target), "rc": 1, "err": str(exc)})
+            report["status"] = "error_rename_home"
+            report["executed"] = executed
+            if emit_json:
+                print(_json.dumps(report, indent=2))
+            else:
+                print(f"ERROR: failed to move {nexo_home} → {backup_target}: {exc}", file=sys.stderr)
+                print("       No changes to snapshot. Current NEXO_HOME is intact.", file=sys.stderr)
+            return 1
+
+    try:
+        snapshot.rename(nexo_home)
+        executed.append({"op": "rename_snapshot", "to": str(nexo_home), "rc": 0})
+    except OSError as exc:
+        executed.append({"op": "rename_snapshot", "to": str(nexo_home), "rc": 1, "err": str(exc)})
+        # Best-effort rollback of the backup rename so the user isn't left without NEXO_HOME.
+        if backup_target is not None and backup_target.exists() and not nexo_home.exists():
+            try:
+                backup_target.rename(nexo_home)
+                executed.append({"op": "rollback_rename_home", "rc": 0})
+            except OSError as rexc:
+                executed.append({"op": "rollback_rename_home", "rc": 1, "err": str(rexc)})
+        report["status"] = "error_rename_snapshot"
+        report["executed"] = executed
+        if emit_json:
+            print(_json.dumps(report, indent=2))
+        else:
+            print(f"ERROR: failed to move snapshot → NEXO_HOME: {exc}", file=sys.stderr)
+        return 1
+
+    if agents_to_restart and not keep_agents:
+        for plist in agents_to_restart:
+            if not plist.exists():
+                # The snapshot may not have the same plist set; skip silently.
+                executed.append({"op": "load_skip_missing", "plist": str(plist), "rc": 0})
+                continue
+            rc, err = _run_launchctl(["launchctl", "load", str(plist)])
+            executed.append({"op": "load", "plist": str(plist), "rc": rc, "err": err})
+
+    report["status"] = "done"
+    report["executed"] = executed
+    if backup_target is not None:
+        report["backup_target"] = str(backup_target)
+
+    if emit_json:
+        print(_json.dumps(report, indent=2))
+    else:
+        print("nexo rollback f06: done")
+        print(f"  restored:  {nexo_home}")
+        if backup_target is not None:
+            print(f"  prior home saved at: {backup_target}")
+            print(f"    review and rm -rf {backup_target}  when you are sure.")
+        if agents_to_restart:
+            print(f"  LaunchAgents reloaded: {len(agents_to_restart)}")
+    return 0
+
+
 def _update(args):
     """Update the installed runtime.
 
@@ -2699,6 +2892,37 @@ def main():
                                 help="Skip the interactive confirmation prompt")
     recover_parser.add_argument("--json", action="store_true", help="JSON output")
 
+    # -- rollback --
+    rollback_parser = sub.add_parser(
+        "rollback",
+        help="Reverse a structural migration using a pre-change snapshot",
+    )
+    rollback_sub = rollback_parser.add_subparsers(dest="rollback_command")
+    rollback_f06_p = rollback_sub.add_parser(
+        "f06",
+        help="Revert the F0.6 layout migration using ~/.nexo-pre-f06-snapshot",
+    )
+    rollback_f06_p.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would happen, do not mutate filesystem or LaunchAgents.",
+    )
+    rollback_f06_p.add_argument(
+        "--yes",
+        action="store_true",
+        help="Skip the interactive confirmation prompt.",
+    )
+    rollback_f06_p.add_argument(
+        "--json",
+        action="store_true",
+        help="Emit machine-readable JSON instead of text output.",
+    )
+    rollback_f06_p.add_argument(
+        "--keep-agents-running",
+        action="store_true",
+        help="Do not bootout / reload LaunchAgents. Advanced use; leaves stale services.",
+    )
+
     # -- clients --
     clients_parser = sub.add_parser("clients", help="Shared client config management")
     clients_sub = clients_parser.add_subparsers(dest="clients_command")
@@ -2998,6 +3222,11 @@ def main():
         return _update(args)
     elif args.command == "recover":
         return _recover(args)
+    elif args.command == "rollback":
+        if args.rollback_command == "f06":
+            return _rollback_f06(args)
+        rollback_parser.print_help()
+        return 0
     elif args.command == "clients":
         if args.clients_command == "sync":
             return _clients_sync(args)

package/src/core_schedule_controls.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import platform
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -209,6 +210,51 @@ def _save_core_schedule_overrides(overrides: dict[str, dict[str, Any]]) -> Path:
     return path
 
 
+def _audit_log_path() -> Path:
+    home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+    # Prefer the F0.6 runtime/logs location with a legacy fallback so audit
+    # entries remain contiguous across installs that have not yet migrated.
+    new = home / "runtime" / "logs" / "core-schedule-overrides.log"
+    legacy = home / "logs" / "core-schedule-overrides.log"
+    if new.parent.is_dir() or not legacy.parent.is_dir():
+        return new
+    return legacy
+
+
+def _append_override_audit(
+    *,
+    name: str,
+    action: str,
+    previous: dict[str, Any],
+    current: dict[str, Any],
+    warning: str,
+    actor: str,
+) -> None:
+    """Append a single-line JSON audit record for a schedule override change.
+
+    Writes to ``~/.nexo/runtime/logs/core-schedule-overrides.log`` (or the
+    legacy location on pre-F0.6 installs). Best-effort only: a failed log
+    write never blocks the override itself.
+    """
+    try:
+        log_path = _audit_log_path()
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        record = {
+            "ts": datetime.now(timezone.utc).isoformat(timespec="seconds").replace("+00:00", "Z"),
+            "name": name,
+            "action": action,
+            "previous": previous,
+            "current": current,
+            "warning": warning or "",
+            "actor": actor or "cli",
+        }
+        with log_path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+    except Exception:
+        # Audit logging is best-effort — never fail the operator action.
+        pass
+
+
 def _apply_calendar_override(base_cron: dict[str, Any], start_hour: str) -> dict[str, Any]:
     parsed = _parse_daily_at(start_hour)
     schedule = base_cron.get("schedule")
@@ -417,6 +463,7 @@ def set_core_schedule(
     interval_seconds: int | None = None,
     daily_at: str | None = None,
     clear: bool = False,
+    actor: str = "cli",
 ) -> dict[str, Any]:
     clean_name = _normalize_name(name)
     if clean_name in _TOGGLEABLE_AUTOMATIONS:
@@ -437,6 +484,7 @@ def set_core_schedule(
         }
 
     overrides = load_core_schedule_overrides()
+    previous_snapshot = dict(overrides.get(clean_name) or {})
     changed = False
     warning = ""
     if clear:
@@ -482,6 +530,24 @@ def set_core_schedule(
         }
 
     config_path = _save_core_schedule_overrides(overrides)
+
+    if changed:
+        current_snapshot = dict(overrides.get(clean_name) or {})
+        if clear:
+            audit_action = "clear"
+        elif not previous_snapshot:
+            audit_action = "set"
+        else:
+            audit_action = "update"
+        _append_override_audit(
+            name=clean_name,
+            action=audit_action,
+            previous=previous_snapshot,
+            current=current_snapshot,
+            warning=warning,
+            actor=actor,
+        )
+
     sync_result = _sync_core_crons_runtime()
     refreshed = get_core_schedule_status(clean_name)
     refreshed.update({