nexo-brain 2.4.0 → 2.5.0

package/src/scripts/nexo-day-orchestrator.sh

@@ -0,0 +1,139 @@
+#!/bin/bash
+# ============================================================================
+# NEXO Day Orchestrator — autonomous NEXO cycle every 15 min
+# Schedule: keepAlive, self-enforced operating hours (default 8:00-23:00)
+#
+# This is NOT a Python script that simulates intelligence.
+# This launches Claude Code as NEXO with full MCP access.
+# NEXO thinks, acts, and reports — like any interactive session.
+# ============================================================================
+set -euo pipefail
+
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+LOG_DIR="$NEXO_HOME/logs"
+mkdir -p "$LOG_DIR" "$NEXO_HOME/operations"
+
+# --- Configuration ---
+CYCLE_INTERVAL=900  # 15 minutes between cycles
+CYCLE_TIMEOUT=600   # 10 min max per cycle
+MAX_TURNS=30        # Claude max turns per cycle
+HOUR_START=8
+HOUR_END=23
+
+# --- Find Claude CLI ---
+find_claude() {
+    for candidate in \
+        "$(command -v claude 2>/dev/null)" \
+        "$HOME/.claude/local/claude" \
+        "/opt/homebrew/bin/claude" \
+        "/usr/local/bin/claude"; do
+        if [ -n "$candidate" ] && [ -x "$candidate" ]; then
+            echo "$candidate"
+            return 0
+        fi
+    done
+    return 1
+}
+
+CLAUDE=$(find_claude) || {
+    echo "$(date '+%Y-%m-%d %H:%M') ERROR: claude CLI not found" >&2
+    exit 1
+}
+
+# --- Prevent overlapping cycles ---
+LOCKFILE="$NEXO_HOME/operations/.orchestrator.lock"
+acquire_lock() {
+    if [ -f "$LOCKFILE" ]; then
+        local pid
+        pid=$(cat "$LOCKFILE" 2>/dev/null || echo "")
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            return 1  # Still running
+        fi
+    fi
+    echo $$ > "$LOCKFILE"
+    return 0
+}
+release_lock() { rm -f "$LOCKFILE"; }
+
+# --- The orchestrator prompt ---
+PROMPT='You are NEXO in autonomous orchestrator mode. The user is NOT present. You have 5 minutes max.
+
+ABSOLUTE PRIORITY: act, do not list. If you can do something, do it. If you need the user, send email.
+
+CHECKLIST (in this order):
+
+1. OVERDUE FOLLOWUPS: nexo_reminders(filter="due") + nexo_reminders(filter="followups")
+   - NEXO tasks (verify, check, monitor) → DO THEM NOW
+   - Tasks needing user decision → accumulate for email
+   - Completed ones → nexo_followup_complete
+
+2. EMAIL: nexo_email_inbox(unread_only=true, limit=10)
+   - Emails you can process → process them
+   - Important emails for user → accumulate for email
+
+3. INFRASTRUCTURE: nexo_doctor(tier="runtime")
+   - If degraded/critical → try to fix
+
+4. EMAIL TO USER (only if there is something to report):
+   - nexo_email_send with clean HTML summary
+   - Only what needs attention or decision
+   - Include what you ALREADY DID (not just pending items)
+   - If nothing relevant → DO NOT send email
+   - Max 1 email per cycle
+
+5. DIARY: nexo_session_diary_write with what you did
+
+RULES:
+- DO NOT ask permission. autonomy=full
+- DO NOT send empty or "all ok" emails
+- DO NOT list things without acting
+- If a followup is executable → execute it before reporting
+- Use nexo_heartbeat at start
+- Clean close: diary + nexo_stop'
+
+# --- Main loop ---
+echo "$(date '+%Y-%m-%d %H:%M') NEXO Day Orchestrator starting (PID $$)"
+echo "  Claude: $CLAUDE"
+echo "  Cycle: every ${CYCLE_INTERVAL}s, ${HOUR_START}:00-${HOUR_END}:00"
+echo "  Timeout: ${CYCLE_TIMEOUT}s, max turns: $MAX_TURNS"
+
+while true; do
+    HOUR=$(date +%H | sed 's/^0//')
+
+    # Outside operating hours — sleep and check again
+    if [ "$HOUR" -lt "$HOUR_START" ] || [ "$HOUR" -ge "$HOUR_END" ]; then
+        sleep 300  # Check every 5 min if we're back in hours
+        continue
+    fi
+
+    # Try to acquire lock
+    if ! acquire_lock; then
+        echo "$(date '+%Y-%m-%d %H:%M') Previous cycle still running. Skipping."
+        sleep "$CYCLE_INTERVAL"
+        continue
+    fi
+
+    TIMESTAMP=$(date '+%Y-%m-%d_%H%M')
+    LOGFILE="$LOG_DIR/orchestrator-$TIMESTAMP.log"
+    echo "$(date '+%Y-%m-%d %H:%M') Cycle starting..."
+
+    # Launch Claude Code as NEXO
+    set +e
+    timeout "$CYCLE_TIMEOUT" "$CLAUDE" \
+        --dangerously-skip-permissions \
+        -p "$PROMPT" \
+        --max-turns "$MAX_TURNS" \
+        >>"$LOGFILE" 2>&1
+    EXIT_CODE=$?
+    set -e
+
+    echo "$(date '+%Y-%m-%d %H:%M') Cycle finished (exit $EXIT_CODE)" | tee -a "$LOGFILE"
+
+    release_lock
+
+    # Clean old logs (keep 7 days)
+    find "$LOG_DIR" -name "orchestrator-*.log" -mtime +7 -delete 2>/dev/null || true
+
+    # Sleep until next cycle
+    sleep "$CYCLE_INTERVAL"
+done

package/src/scripts/nexo-evolution-run.py

@@ -45,9 +45,10 @@ AUTO_SAFE_PREFIXES = [
     str(CLAUDE_DIR / "coordination") + "/",
 ]
 
-# Public mode: only user-created scripts — NEVER core, cortex, or plugins
+# Public mode: user scripts and plugins only — NEVER core code
 AUTO_SAFE_PREFIXES_PUBLIC = [
     str(CLAUDE_DIR / "scripts") + "/",
+    str(CLAUDE_DIR / "plugins") + "/",
 ]
 
 # ── Immutable files — NEVER touch (applies to ALL modes) ────────────────

package/src/scripts/nexo-learning-housekeep.py

@@ -70,7 +70,7 @@ def adjust_weights(conn):
         priority = l["priority"] or "medium"
 
         # Priority floor — critical learnings never drop below 0.5
-        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}[priority]
+        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}.get(priority, 0.1)
 
         new_weight = old_weight
 

package/src/scripts/nexo-watchdog.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 # ============================================================================
 # NEXO Watchdog — Comprehensive health monitor for all NEXO services
-# Cron: */5 * * * * NEXO_HOME/scripts/nexo-watchdog.sh
+# Schedule: every 30 minutes (interval_seconds: 1800)
 # ============================================================================
 # Monitors ALL LaunchAgents, cron jobs, and background processes.
 # Outputs: watchdog-status.json (machine), watchdog-report.txt (human),

package/src/server.py

@@ -8,6 +8,7 @@ import sys
 from fastmcp import FastMCP
 from db import init_db, rebuild_fts_index, get_db, close_db, fts_add_dir, fts_remove_dir, fts_list_dirs
 from tools_sessions import handle_startup, handle_heartbeat, handle_status, handle_context_packet, handle_smart_startup_query
+from user_context import get_context as _get_ctx
 from tools_coordination import (
     handle_track, handle_untrack, handle_files,
     handle_send, handle_ask, handle_answer, handle_check_answer,
@@ -154,12 +155,17 @@ def _server_init():
 mcp = FastMCP(
     name="nexo",
     instructions=(
-        "NEXO — cognitive co-operator. Save important info from tool results before they clear.\n\n"
+        f"{_get_ctx().assistant_name} — cognitive co-operator. Save important info from tool results before they clear.\n\n"
+        "## CRITICAL — do these or you WILL get corrected\n"
+        "- **Guard (MANDATORY before ANY code edit):** `nexo_guard_check(files='...', area='...')` BEFORE editing code. "
+        "No exceptions. Blocking rules→resolve first. `nexo_track(sid=SID, paths=[...])` before shared files\n"
+        "- **Skills (MANDATORY before multi-step tasks):** `nexo_skill_match(task)` to find reusable procedures. "
+        "If match found, read it and follow the steps. After completion, `nexo_skill_result(id, success, context)` to record outcome.\n"
+        "- **Learnings (MANDATORY on corrections):** When you discover a bug, pattern, or get corrected→`nexo_learning_add` IMMEDIATELY. "
+        "Do NOT batch. Do NOT wait until end of session.\n\n"
         "## Rules\n"
         "- **Heartbeat:** `nexo_heartbeat(sid=SID, task='...', context_hint='...')` every user msg. "
         "React: DIARY REMINDER→write diary, VIBE:NEGATIVE→ultra-concise, AUTO-PRIME→read learnings\n"
-        "- **Guard:** `nexo_guard_check(files='...', area='...')` BEFORE editing code. "
-        "Blocking rules→resolve first. `nexo_track(sid=SID, paths=[...])` before shared files\n"
         "- **Followups:** NEXO tasks, execute silently. 'done'/'all set'→`nexo_followup_complete` NOW. "
         "Reminders=user's, alert when due\n"
         "- **Observe:** correction→learning. 'tomorrow'→followup. person→entity. open topic→followup 3d\n"
@@ -175,8 +181,6 @@ mcp = FastMCP(
         "write `nexo_session_diary_write(...)` with self_critique BEFORE responding. "
         "Detect intent, not keywords. If session closes without diary, auto_close handles it.\n"
         "- **Cortex:** `nexo_cortex_check` before budget/campaign/architecture changes\n"
-        "- **Skills:** before multi-step tasks, `nexo_skill_match(task)` to find reusable procedures. "
-        "If match found, read it and follow the steps. After completion, `nexo_skill_result(id, success, context)` to record outcome.\n"
         "- **Dissonance:** user contradicts memory→`nexo_cognitive_dissonance`. Frustrated→force=True\n"
         "- **Trust:** <40=paranoid verify twice, >80=fluid. Check: `nexo_cognitive_trust`"
     ),

package/src/skills/run-runtime-doctor/guide.md

@@ -0,0 +1,12 @@
+# Run Runtime Doctor
+
+Use this skill when you want a fast health snapshot of the running NEXO system.
+
+## Steps
+1. Run the runtime doctor for the requested tier.
+2. Review the degraded or critical checks first.
+3. If the report recommends deterministic fixes, decide whether to run them explicitly.
+
+## Gotchas
+- A critical watchdog result reflects a real system issue, not just a stale skill.
+- `all` is broader and slower than `runtime`.

package/src/skills/run-runtime-doctor/script.py

@@ -0,0 +1,21 @@
+#!/usr/bin/env python3
+import os
+import subprocess
+import sys
+
+
+def main() -> int:
+    tier = sys.argv[1] if len(sys.argv) > 1 and sys.argv[1] else "runtime"
+    nexo_code = os.environ.get("NEXO_CODE", "")
+    if not nexo_code:
+        print("NEXO_CODE not set", file=sys.stderr)
+        return 1
+
+    cli_py = os.path.join(nexo_code, "cli.py")
+    cmd = [sys.executable, cli_py, "doctor", "--tier", tier, "--json"]
+    result = subprocess.run(cmd, text=True)
+    return result.returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/src/skills/run-runtime-doctor/skill.json

@@ -0,0 +1,25 @@
+{
+  "id": "SK-RUN-RUNTIME-DOCTOR",
+  "name": "Run Runtime Doctor",
+  "description": "Runs the NEXO runtime doctor and returns the current health report.",
+  "level": "published",
+  "mode": "execute",
+  "source_kind": "core",
+  "execution_level": "read-only",
+  "approval_required": false,
+  "tags": ["doctor", "diagnostics", "runtime"],
+  "trigger_patterns": ["run doctor", "check runtime health", "diagnose nexo"],
+  "params_schema": {
+    "tier": {
+      "type": "string",
+      "required": false,
+      "default": "runtime",
+      "enum": ["boot", "runtime", "deep", "all"]
+    }
+  },
+  "command_template": {
+    "argv": ["{{file_path}}", "{{tier}}"]
+  },
+  "executable_entry": "script.py",
+  "stable_after_uses": 10
+}

package/src/skills_runtime.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+"""Runtime helpers for Skills v2.
+
+This module is the single execution gate for skills. It decides:
+- guide vs execute vs hybrid mode
+- whether a skill is allowed to run
+- how parameters are validated and rendered
+- how execution is routed through the stable `nexo scripts run` CLI
+"""
+
+import json
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from db import (
+    approve_skill,
+    collect_skill_improvement_candidates,
+    collect_scriptable_skill_candidates,
+    get_featured_skills,
+    get_skill,
+    get_skill_execution_spec,
+    init_db,
+    materialize_personal_skill_definition,
+    record_skill_usage,
+    render_command_template,
+    sync_skill_directories,
+    update_skill,
+)
+from script_registry import doctor_script
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(Path(__file__).resolve().parent)))
+
+
+def _parse_params(params) -> dict:
+    if isinstance(params, dict):
+        return params
+    if isinstance(params, str):
+        text = params.strip()
+        if not text:
+            return {}
+        return json.loads(text)
+    return {}
+
+
+def _ensure_ready():
+    init_db()
+
+
+def _resolve_mode(requested: str, skill: dict) -> str:
+    mode = (requested or "auto").strip().lower()
+    if mode in {"guide", "execute", "hybrid"}:
+        return mode
+    effective = str(skill.get("mode", "") or "").strip().lower()
+    if effective in {"guide", "execute", "hybrid"}:
+        return effective
+    if skill.get("file_path") and skill.get("content"):
+        return "hybrid"
+    if skill.get("file_path"):
+        return "execute"
+    return "guide"
+
+
+def _summarize_skill(skill: dict) -> str:
+    steps = []
+    gotchas = []
+    try:
+        steps = json.loads(skill.get("steps", "[]"))
+    except json.JSONDecodeError:
+        pass
+    try:
+        gotchas = json.loads(skill.get("gotchas", "[]"))
+    except json.JSONDecodeError:
+        pass
+
+    lines = [
+        f"[{skill['id']}] {skill['name']}",
+        skill.get("description", "") or "(no description)",
+    ]
+    if steps:
+        lines.append("Steps:")
+        for index, step in enumerate(steps[:6], 1):
+            lines.append(f"{index}. {step}")
+    elif skill.get("content"):
+        lines.append(skill["content"][:800])
+    if gotchas:
+        lines.append("Gotchas:")
+        for gotcha in gotchas[:4]:
+            lines.append(f"- {gotcha}")
+    return "\n".join(lines).strip()
+
+
+def _resolve_cli_command() -> list[str]:
+    installed = NEXO_HOME / "bin" / "nexo"
+    if installed.is_file():
+        return [str(installed)]
+    return [sys.executable, str(NEXO_CODE / "cli.py")]
+
+
+def _run_skill_script(skill: dict, argv: list[str], timeout: int = 300) -> dict:
+    if not argv:
+        return {"returncode": 1, "stdout": "", "stderr": "No command to execute"}
+
+    env = {
+        **os.environ,
+        "NEXO_HOME": str(NEXO_HOME),
+        "NEXO_CODE": str(NEXO_CODE),
+        "NEXO_SKILL_ID": skill["id"],
+        "NEXO_SKILL_NAME": skill["name"],
+    }
+
+    cli_cmd = _resolve_cli_command()
+    cmd = [*cli_cmd, "scripts", "run", argv[0], *argv[1:]]
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            env=env,
+        )
+        return {
+            "returncode": result.returncode,
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "command": cmd,
+        }
+    except subprocess.TimeoutExpired:
+        return {
+            "returncode": 124,
+            "stdout": "",
+            "stderr": f"Skill execution timed out after {timeout}s",
+            "command": cmd,
+        }
+
+
+def get_featured_skill_summaries(limit: int = 5) -> list[dict]:
+    _ensure_ready()
+    sync_skill_directories()
+    featured = []
+    for skill in get_featured_skills(limit=limit):
+        triggers = []
+        try:
+            triggers = json.loads(skill.get("trigger_patterns", "[]"))
+        except json.JSONDecodeError:
+            pass
+        featured.append(
+            {
+                "id": skill["id"],
+                "name": skill["name"],
+                "mode": skill.get("mode", "guide"),
+                "execution_level": skill.get("execution_level", "none"),
+                "source_kind": skill.get("source_kind", "personal"),
+                "trust_score": skill.get("trust_score", 0),
+                "trigger_patterns": triggers[:3],
+            }
+        )
+    return featured
+
+
+def apply_skill(skill_id: str, params=None, mode: str = "auto", dry_run: bool = False, context: str = "") -> dict:
+    _ensure_ready()
+    sync_skill_directories()
+    skill = get_skill(skill_id)
+    if not skill:
+        return {"ok": False, "error": f"Skill {skill_id} not found"}
+
+    effective_mode = _resolve_mode(mode, skill)
+    response = {
+        "ok": True,
+        "skill_id": skill["id"],
+        "skill_name": skill["name"],
+        "requested_mode": mode,
+        "resolved_mode": effective_mode,
+        "approval_state": {
+            "approval_required": bool(skill.get("approval_required", 0)),
+            "approved_at": skill.get("approved_at", ""),
+            "execution_level": skill.get("execution_level", "none"),
+        },
+    }
+
+    if effective_mode in {"guide", "hybrid"}:
+        response["guide_summary"] = _summarize_skill(skill)
+
+    if effective_mode in {"execute", "hybrid"}:
+        exec_spec = get_skill_execution_spec(skill_id)
+        if "error" in exec_spec:
+            response["ok"] = False
+            response["error"] = exec_spec["error"]
+            return response
+
+        if not skill.get("file_path"):
+            response["ok"] = False
+            response["error"] = f"Skill {skill_id} has no executable script"
+            return response
+
+        if exec_spec["execution_level"] in {"read-only", "local", "remote"} and not skill.get("approved_at"):
+            skill = approve_skill(skill_id, execution_level=exec_spec["execution_level"], approved_by="system:auto")
+            response["approval_state"] = {
+                "approval_required": bool(skill.get("approval_required", 0)),
+                "approved_at": skill.get("approved_at", ""),
+                "execution_level": skill.get("execution_level", exec_spec["execution_level"]),
+            }
+
+        doctor = doctor_script(skill["file_path"])
+        response["script_doctor"] = doctor
+        if doctor["status"] == "fail":
+            response["ok"] = False
+            response["error"] = "Skill script failed validation"
+            return response
+
+        rendered = render_command_template(skill, _parse_params(params))
+        if not rendered.get("ok"):
+            response["ok"] = False
+            response["error"] = "Invalid skill parameters"
+            response["param_errors"] = rendered.get("errors", [])
+            return response
+
+        argv = rendered["argv"] or [skill["file_path"]]
+        response["resolved_params"] = rendered["params"]
+        response["script_command"] = argv
+        if dry_run:
+            response["dry_run"] = True
+            return response
+
+        execution = _run_skill_script(skill, argv)
+        response["execution_result"] = execution
+        success = execution["returncode"] == 0
+        record = record_skill_usage(
+            skill_id=skill_id,
+            success=success,
+            context=context or skill["name"],
+            notes=(execution["stderr"] or execution["stdout"])[:500],
+        )
+        response["usage_recorded"] = {
+            "success": success,
+            "trust_score": record.get("trust_score"),
+            "level": record.get("level"),
+            "promotion": record.get("_promotion"),
+        }
+        if not success:
+            response["ok"] = False
+            response["error"] = f"Skill execution failed with exit {execution['returncode']}"
+
+    return response
+
+
+def sync_skills() -> dict:
+    _ensure_ready()
+    return sync_skill_directories()
+
+
+def approve_skill_execution(skill_id: str, execution_level: str = "", approved_by: str = "") -> dict:
+    _ensure_ready()
+    return approve_skill(skill_id, execution_level=execution_level, approved_by=approved_by)
+
+
+def list_evolution_candidates() -> dict:
+    _ensure_ready()
+    sync_skill_directories()
+    return {
+        "scriptable": collect_scriptable_skill_candidates(),
+        "improvements": collect_skill_improvement_candidates(),
+    }
+
+
+def auto_promote_skill_evolution(approved_by: str = "system:auto") -> dict:
+    """Convert mature guide skills into executable drafts without manual approval."""
+    _ensure_ready()
+    sync_skill_directories()
+    promoted = []
+    skipped = []
+    for candidate in collect_scriptable_skill_candidates():
+        skill = get_skill(candidate["id"])
+        if not skill or skill.get("file_path"):
+            continue
+
+        steps = candidate.get("steps") or []
+        gotchas = candidate.get("gotchas") or []
+        description = candidate.get("description", "") or "Automated skill generated from repeated successful usage."
+        lines = [
+            "#!/usr/bin/env python3",
+            '"""Auto-generated executable skill draft."""',
+            "import json",
+            "import sys",
+            "",
+            "def main() -> int:",
+            "    payload = {",
+            f"        'skill_id': {json.dumps(candidate['id'])},",
+            f"        'skill_name': {json.dumps(candidate['name'])},",
+            f"        'description': {json.dumps(description)},",
+            f"        'steps': {json.dumps(steps, ensure_ascii=False)},",
+            f"        'gotchas': {json.dumps(gotchas, ensure_ascii=False)},",
+            "        'argv': sys.argv[1:],",
+            "    }",
+            "    print(json.dumps(payload, ensure_ascii=False))",
+            "    return 0",
+            "",
+            'if __name__ == "__main__":',
+            "    raise SystemExit(main())",
+            "",
+        ]
+        update = update_skill(
+            candidate["id"],
+            mode=candidate.get("suggested_mode", "hybrid"),
+            execution_level=candidate.get("suggested_execution_level", "read-only"),
+            approval_required=0,
+            approved_by=approved_by,
+        )
+        if "error" in update:
+            skipped.append({"id": candidate["id"], "reason": update["error"]})
+            continue
+
+        materialized = materialize_personal_skill_definition(
+            {
+                "id": candidate["id"],
+                "name": candidate["name"],
+                "description": description,
+                "level": skill.get("level", "published"),
+                "mode": candidate.get("suggested_mode", "hybrid"),
+                "execution_level": candidate.get("suggested_execution_level", "read-only"),
+                "approved_by": approved_by,
+                "tags": json.loads(skill.get("tags", "[]")) if skill.get("tags") else [],
+                "trigger_patterns": candidate.get("trigger_patterns", []),
+                "source_sessions": candidate.get("source_sessions", []),
+                "steps": steps,
+                "gotchas": gotchas,
+                "content": skill.get("content", ""),
+                "command_template": {"argv": ["{{file_path}}"]},
+                "executable_entry": "script.py",
+                "script_body": "\n".join(lines),
+            }
+        )
+        if "error" in materialized:
+            skipped.append({"id": candidate["id"], "reason": materialized["error"]})
+            continue
+
+        promoted.append(
+            {
+                "id": candidate["id"],
+                "mode": candidate.get("suggested_mode", "hybrid"),
+                "execution_level": candidate.get("suggested_execution_level", "read-only"),
+            }
+        )
+    return {"promoted": promoted, "skipped": skipped}

package/src/tools_menu.py

@@ -1,8 +1,9 @@
-"""Menu generator — NEXO operations center."""
+"""Menu generator — operations center."""
 
 from datetime import datetime, timedelta
 import json
 import subprocess
+from user_context import get_context as _get_ctx
 import sys
 from pathlib import Path
 from tools_sessions import handle_status
@@ -109,7 +110,7 @@ def handle_menu() -> str:
 
     lines = []
     lines.append("╔" + "═" * W + "╗")
-    lines.append("║" + "NEXO — OPERATIONS CENTER".center(W) + "║")
+    lines.append("║" + f"{_get_ctx().assistant_name} — OPERATIONS CENTER".center(W) + "║")
     lines.append("║" + date_str.center(W) + "║")
     lines.append("╠" + "═" * W + "╣")