pantheon-opencode 1.5.2 → 1.6.0-beta.10

package/.pantheon/code-mode/README.md

@@ -10,10 +10,12 @@ Orchestration scripts executed via the `pantheon-code-mode` MCP server
 | `checkpoint_session.py` | Python | Full checkpoint management: init, save, status, resume, list, health, archive, cleanup |
 | `checkpoint-session.sh` | Bash | Shell wrapper for `checkpoint_session.py` |
 | `compress-inline.py` | Python | Inline context compression — score, compress, stats, batch modes |
-| `session-end-save.py` | Python | Session-end Vector DB backup scaffold |
-| `session-end-save.sh` | Bash | Shell wrapper for `session-end-save.py` |
 | `example-sync.sh` | Bash | Minimal demo script for testing `execute_code_script` |
 
+Session persistence is handled by the persistence MCP server. The code-mode
+payload contains orchestration, checkpoint, compression, and evaluation
+helpers only; it does not export or back up a database.
+
 ## checkpoint_session.py Commands
 
 | Command | Description |

package/.pantheon/code-mode/checkpoint_session.py

@@ -23,8 +23,8 @@ from __future__ import annotations
 
 import hashlib
 import json
-import sys
 import shutil
+import sys
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
 
@@ -236,79 +236,100 @@ def cmd_list(slug: str) -> None:
         print(f"  [{n}] phase={phase} turns={turns} @ {ts}")
 
 
-def cmd_health(slug: str) -> None:
-    """Validate session consistency."""
-    sdir = get_slug_dir(slug)
-    issues = []
-
-    if not sdir.exists():
-        print(f"❌ Session not found: {slug}")
-        return
-
-    session: dict = {}
-    hb: dict = {}
-
-    # Check session.json
-    session_file = sdir / "session.json"
-    if not session_file.exists():
-        issues.append("Missing session.json")
-    else:
-        try:
-            session = _read_json(session_file)
-            required = ["task_id", "status", "start_time", "last_activity"]
-            for field in required:
-                if field not in session:
-                    issues.append(f"session.json missing field: {field}")
-        except (json.JSONDecodeError, ValueError):
-            issues.append("session.json is corrupted (invalid JSON)")
-
-    # Check heartbeat.json
-    hb_file = sdir / "heartbeat.json"
-    if not hb_file.exists():
-        issues.append("Missing heartbeat.json")
-    else:
+def _validate_session_file(path: Path) -> tuple[dict, list[str]]:
+    """Read session metadata and return any consistency issues."""
+    if not path.exists():
+        return {}, ["Missing session.json"]
+    try:
+        session = _read_json(path)
+    except (json.JSONDecodeError, ValueError):
+        return {}, ["session.json is corrupted (invalid JSON)"]
+    required = ["task_id", "status", "start_time", "last_activity"]
+    issues = [
+        f"session.json missing field: {field}"
+        for field in required
+        if field not in session
+    ]
+    return session, issues
+
+
+def _validate_heartbeat_file(path: Path) -> list[str]:
+    """Read heartbeat metadata and return any consistency issues."""
+    if not path.exists():
+        return ["Missing heartbeat.json"]
+    try:
+        heartbeat = _read_json(path)
+    except (json.JSONDecodeError, ValueError):
+        return ["heartbeat.json is corrupted (invalid JSON)"]
+    if heartbeat.get("status") == "stalled":
+        return ["Session is marked as STALLED"]
+    return []
+
+
+def _validate_checkpoints(sdir: Path) -> tuple[list[tuple[int, Path]], list[str]]:
+    """Validate checkpoint contents and sequential numbering."""
+    checkpoints = get_checkpoints(sdir)
+    issues: list[str] = []
+    for number, path in checkpoints:
         try:
-            hb = _read_json(hb_file)
-            if hb.get("status") == "stalled":
-                issues.append("Session is marked as STALLED")
+            checkpoint = _read_json(path)
+            if checkpoint.get("version", 1) > SCHEMA_VERSION:
+                issues.append(f"checkpoint-{number}.json has newer schema version")
+            if "slug" not in checkpoint or "timestamp" not in checkpoint:
+                issues.append(f"checkpoint-{number}.json missing required fields")
         except (json.JSONDecodeError, ValueError):
-            issues.append("heartbeat.json is corrupted (invalid JSON)")
+            issues.append(f"checkpoint-{number}.json is corrupted")
 
-    # Check checkpoint integrity
-    checkpoints = get_checkpoints(sdir)
     if checkpoints:
-        for n, path in checkpoints:
-            try:
-                cp = _read_json(path)
-                if cp.get("version", 1) > SCHEMA_VERSION:
-                    issues.append(f"checkpoint-{n}.json has newer schema version")
-                if "slug" not in cp or "timestamp" not in cp:
-                    issues.append(f"checkpoint-{n}.json missing required fields")
-            except (json.JSONDecodeError, ValueError):
-                issues.append(f"checkpoint-{n}.json is corrupted")
-
-        # Check sequential numbering
-        numbers = [n for n, _ in checkpoints]
+        numbers = [number for number, _ in checkpoints]
         expected = list(range(numbers[0], numbers[-1] + 1))
         if numbers != expected:
             missing = set(expected) - set(numbers)
             issues.append(f"Missing checkpoints: {sorted(missing)}")
+    return checkpoints, issues
+
+
+def _stale_activity_issue(
+    session_file: Path, heartbeat_file: Path, session: dict
+) -> list[str]:
+    """Return a stale-activity issue when both metadata files are present."""
+    if not session_file.exists() or not heartbeat_file.exists() or not session:
+        return []
+    try:
+        last_action = session.get("last_activity", "")
+        if last_action:
+            last_time = datetime.fromisoformat(last_action)
+            if datetime.now(UTC) - last_time > STALE_THRESHOLD:
+                return [
+                    f"No activity for > {STALE_THRESHOLD.total_seconds() / 3600:.0f}h "
+                    "(stale)"
+                ]
+    except (ValueError, TypeError):
+        return ["Could not parse last_activity timestamp"]
+    return []
+
+
+def cmd_health(slug: str) -> None:
+    """Validate session consistency."""
+    sdir = get_slug_dir(slug)
+    if not sdir.exists():
+        print(f"❌ Session not found: {slug}")
+        return
+
+    session_file = sdir / "session.json"
+    heartbeat_file = sdir / "heartbeat.json"
+    session, issues = _validate_session_file(session_file)
+    issues.extend(_validate_heartbeat_file(heartbeat_file))
+    checkpoints, checkpoint_issues = _validate_checkpoints(sdir)
+    issues.extend(checkpoint_issues)
+    issues.extend(_stale_activity_issue(session_file, heartbeat_file, session))
 
-    # Check for stale activity
-    if session_file.exists() and hb_file.exists() and session:
-        try:
-            last_action = session.get("last_activity", "")
-            if last_action:
-                last_time = datetime.fromisoformat(last_action)
-                if datetime.now(UTC) - last_time > STALE_THRESHOLD:
-                    issues.append(f"No activity for > {STALE_THRESHOLD.total_seconds() / 3600:.0f}h (stale)")
-        except (ValueError, TypeError):
-            issues.append("Could not parse last_activity timestamp")
-
-    # Report
     if not issues:
         print(f"✅ Session '{slug}' is healthy")
-        print(f"   Checkpoints: {len(checkpoints)}, Status: {session.get('status', 'unknown')}")
+        print(
+            f"   Checkpoints: {len(checkpoints)}, "
+            f"Status: {session.get('status', 'unknown')}"
+        )
     else:
         print(f"⚠️  Session '{slug}' has {len(issues)} issue(s):")
         for issue in issues:
@@ -324,7 +345,10 @@ def cmd_archive(slug: str) -> None:
 
     archive_dir = ARCHIVEDIR / slug
     if archive_dir.exists():
-        print(f"Session '{slug}' already exists in archive. Remove it first or use a different slug.")
+        print(
+            f"Session '{slug}' already exists in archive. Remove it first "
+            "or use a different slug."
+        )
         return
 
     archive_dir.parent.mkdir(parents=True, exist_ok=True)
@@ -332,6 +356,53 @@ def cmd_archive(slug: str) -> None:
     print(f"📦 Session '{slug}' archived to .pantheon/deepwork/archive/{slug}/")
 
 
+def _cleanup_stale_session(item: Path, now: datetime, dry_run: bool) -> None:
+    """Report a stale heartbeat for one session, if it can be read."""
+    heartbeat_file = item / "heartbeat.json"
+    if not heartbeat_file.exists():
+        return
+    try:
+        heartbeat = _read_json(heartbeat_file)
+        last_action = heartbeat.get("last_action", "")
+        if last_action and now - datetime.fromisoformat(last_action) > STALE_THRESHOLD:
+            if dry_run:
+                print(
+                    f"  [dry-run] Would flag stale session: {item.name}/ "
+                    f"(last action: {last_action})"
+                )
+            else:
+                print(f"  ⏸️  Session '{item.name}' stale since {last_action}")
+    except (ValueError, json.JSONDecodeError):
+        pass
+
+
+def _cleanup_temp_files(item: Path, dry_run: bool) -> int:
+    """Remove temporary files from one session and return the count."""
+    removed_files = 0
+    for tmp_file in item.glob("*.tmp"):
+        if dry_run:
+            print(f"  [dry-run] Would remove temp file: {tmp_file.name}")
+        else:
+            tmp_file.unlink()
+            removed_files += 1
+            print(f"  Removed temp file: {item.name}/{tmp_file.name}")
+    return removed_files
+
+
+def _cleanup_item(item: Path, now: datetime, dry_run: bool) -> tuple[int, int]:
+    """Clean one session directory and return (directories, files) removed."""
+    session_file = item / "session.json"
+    if not session_file.exists():
+        if dry_run:
+            print(f"  [dry-run] Would remove orphan directory: {item.name}/")
+            return 0, 0
+        shutil.rmtree(item)
+        print(f"  Removed orphan directory: {item.name}/")
+        return 1, 0
+    _cleanup_stale_session(item, now, dry_run)
+    return 0, _cleanup_temp_files(item, dry_run)
+
+
 def cmd_cleanup(dry_run: bool = False) -> None:
     """Clean orphaned sessions and temp files.
 
@@ -347,47 +418,12 @@ def cmd_cleanup(dry_run: bool = False) -> None:
     now = datetime.now(UTC)
     removed_dirs = 0
     removed_files = 0
-
     for item in sorted(DEEPDIR.iterdir()):
         if not item.is_dir() or item.name == "archive" or item.name.startswith("."):
             continue
-
-        session_file = item / "session.json"
-        hb_file = item / "heartbeat.json"
-
-        # Check if it's an orphan (no session.json)
-        if not session_file.exists():
-            if dry_run:
-                print(f"  [dry-run] Would remove orphan directory: {item.name}/")
-            else:
-                shutil.rmtree(item)
-                removed_dirs += 1
-                print(f"  Removed orphan directory: {item.name}/")
-            continue
-
-        # Check for stale sessions
-        if hb_file.exists():
-            try:
-                hb = _read_json(hb_file)
-                last_action = hb.get("last_action", "")
-                if last_action:
-                    last_time = datetime.fromisoformat(last_action)
-                    if now - last_time > STALE_THRESHOLD:
-                        if dry_run:
-                            print(f"  [dry-run] Would flag stale session: {item.name}/ (last action: {last_action})")
-                        else:
-                            print(f"  ⏸️  Session '{item.name}' stale since {last_action}")
-            except (ValueError, json.JSONDecodeError):
-                pass
-
-        # Clean temp files
-        for tmp_file in item.glob("*.tmp"):
-            if dry_run:
-                print(f"  [dry-run] Would remove temp file: {tmp_file.name}")
-            else:
-                tmp_file.unlink()
-                removed_files += 1
-                print(f"  Removed temp file: {item.name}/{tmp_file.name}")
+        dirs, files = _cleanup_item(item, now, dry_run)
+        removed_dirs += dirs
+        removed_files += files
 
     if not dry_run:
         total = removed_dirs + removed_files

package/.pantheon/code-mode/compress-inline.py

@@ -164,6 +164,62 @@ BLOCKER_KEYWORDS: list[re.Pattern] = [
     re.compile(r"depend", re.IGNORECASE),
     re.compile(r"dependency", re.IGNORECASE),
 ]
+FILE_NOVELTY_HIGH = 10
+FILE_NOVELTY_MEDIUM = 5
+PRIORITY_CRITICAL = 0.75
+PRIORITY_HIGH = 0.50
+PRIORITY_MEDIUM = 0.25
+SUMMARY_MAX_CHARS = 80
+
+
+def _keyword_scores(
+    text: str,
+) -> tuple[list[float], list[float], list[float], list[str]]:
+    """Return impact, risk, novelty, and matching keyword scores."""
+    impact_scores: list[float] = []
+    risk_scores: list[float] = []
+    novelty_scores: list[float] = []
+    keywords_found: list[str] = []
+    for name, pattern, impact, risk, novelty in KEYWORD_MAP:
+        if pattern.search(text):
+            impact_scores.append(impact)
+            risk_scores.append(risk)
+            novelty_scores.append(novelty)
+            keywords_found.append(name)
+    return impact_scores, risk_scores, novelty_scores, keywords_found
+
+
+def _blocker_score(text: str, blocker_hint: bool) -> float:
+    """Return the blocker score detected in text or supplied explicitly."""
+    blockers = 0.0
+    for pattern in BLOCKER_KEYWORDS:
+        if pattern.search(text):
+            # unblocked/unblocks = positive blocker resolution
+            blockers = max(
+                blockers, 0.8 if re.search(r"unblock", text, re.IGNORECASE) else 0.5
+            )
+    if blocker_hint:
+        blockers = max(blockers, 0.8)
+    return blockers
+
+
+def _downstream_score(from_agent: str | None, to_agent: str | None) -> float:
+    """Return downstream relevance for an agent pair."""
+    if not from_agent or not to_agent:
+        return 0.5
+    key = (from_agent.lower().strip(), to_agent.lower().strip())
+    return AGENT_PAIR_TABLE.get(key, 0.5)
+
+
+def _priority_band(score: float) -> str:
+    """Map a score to the documented priority band."""
+    if score >= PRIORITY_CRITICAL:
+        return "CRITICAL"
+    if score >= PRIORITY_HIGH:
+        return "HIGH"
+    if score >= PRIORITY_MEDIUM:
+        return "MEDIUM"
+    return "LOW"
 
 
 def compute_score(
@@ -178,45 +234,20 @@ def compute_score(
     Returns dict with:
         score, band, impact, risk, novelty, blockers, downstream, keywords_found
     """
-    impact_scores: list[float] = []
-    risk_scores: list[float] = []
-    novelty_scores: list[float] = []
-    keywords_found: list[str] = []
-
-    for name, pattern, imp, rsk, nov in KEYWORD_MAP:
-        if pattern.search(text):
-            impact_scores.append(imp)
-            risk_scores.append(rsk)
-            novelty_scores.append(nov)
-            keywords_found.append(name)
+    impact_scores, risk_scores, novelty_scores, keywords_found = _keyword_scores(text)
 
     impact = max(impact_scores) if impact_scores else 0.0
     risk = max(risk_scores) if risk_scores else 0.0
     novelty = max(novelty_scores) if novelty_scores else 0.0
 
     # Novelty bonus for file count (overrides keyword score)
-    if files_changed >= 10:
+    if files_changed >= FILE_NOVELTY_HIGH:
         novelty = max(novelty, 1.0)
-    elif files_changed >= 5:
+    elif files_changed >= FILE_NOVELTY_MEDIUM:
         novelty = max(novelty, 0.8)
 
-    # Blockers dimension — detect in text or use explicit hint
-    blockers: float = 0.0
-    for bp in BLOCKER_KEYWORDS:
-        if bp.search(text):
-            # unblocked/unblocks = positive blocker resolution
-            if re.search(r"unblock", text, re.IGNORECASE):
-                blockers = max(blockers, 0.8)
-            else:
-                blockers = max(blockers, 0.5)
-    if blocker_hint:
-        blockers = max(blockers, 0.8)
-
-    # Downstream relevance
-    downstream: float = 0.5  # default when agent pair unknown
-    if from_agent and to_agent:
-        key = (from_agent.lower().strip(), to_agent.lower().strip())
-        downstream = AGENT_PAIR_TABLE.get(key, 0.5)
+    blockers = _blocker_score(text, blocker_hint)
+    downstream = _downstream_score(from_agent, to_agent)
 
     score = (
         impact * WEIGHTS["impact"]
@@ -226,19 +257,9 @@ def compute_score(
         + downstream * WEIGHTS["downstream"]
     )
 
-    # Priority band (from SKILL.md line 125-131)
-    if score >= 0.75:
-        band = "CRITICAL"
-    elif score >= 0.50:
-        band = "HIGH"
-    elif score >= 0.25:
-        band = "MEDIUM"
-    else:
-        band = "LOW"
-
     return {
         "score": round(score, 2),
-        "band": band,
+        "band": _priority_band(score),
         "impact": impact,
         "risk": risk,
         "novelty": novelty,
@@ -285,14 +306,17 @@ def compress(
     )
 
     # Summary = first meaningful line of scrubbed text, ≤80 chars
-    lines = [l.strip() for l in scrubbed.splitlines() if l.strip()]
+    lines = [line.strip() for line in scrubbed.splitlines() if line.strip()]
     summary: str = ""
     if lines:
-        summary = lines[0][:80]
-        if len(lines[0]) > 80:
+        summary = lines[0][:SUMMARY_MAX_CHARS]
+        if len(lines[0]) > SUMMARY_MAX_CHARS:
             summary += "…"
 
-    output_parts = [f"- What changed: {summary}", f"- Priority: {result['band']} (score: {result['score']:.2f})"]
+    output_parts = [
+        f"- What changed: {summary}",
+        f"- Priority: {result['band']} (score: {result['score']:.2f})",
+    ]
     if files:
         output_parts.append(f"- Files: {files}")
 
@@ -311,14 +335,14 @@ def process_batch(
 ) -> str:
     """Read multiple files, scrub + score + compress each."""
     parts: list[str] = []
-    for fpath in file_paths:
-        fpath = fpath.strip()
+    for raw_path in file_paths:
+        fpath = raw_path.strip()
         if not fpath:
             continue
         try:
             with open(fpath, encoding="utf-8") as fh:
                 content = fh.read()
-        except (OSError, IOError) as exc:
+        except OSError as exc:
             parts.append(f"- {fpath}: ERROR — {exc}")
             continue
 
@@ -331,11 +355,11 @@ def process_batch(
         )
 
         # Summary: first meaningful line
-        content_lines = [l.strip() for l in scrubbed.splitlines() if l.strip()]
+        content_lines = [line.strip() for line in scrubbed.splitlines() if line.strip()]
         summary = "(empty)"
         if content_lines:
-            summary = content_lines[0][:80]
-            if len(content_lines[0]) > 80:
+            summary = content_lines[0][:SUMMARY_MAX_CHARS]
+            if len(content_lines[0]) > SUMMARY_MAX_CHARS:
                 summary += "…"
 
         base = os.path.basename(fpath)
@@ -356,7 +380,9 @@ def main() -> None:
     parser = argparse.ArgumentParser(
         description="Pantheon inline compression — score, compress, or stat text.",
     )
-    parser.add_argument("mode", choices=["score", "compress", "stats", "batch"], help="Operation mode")
+    parser.add_argument(
+        "mode", choices=["score", "compress", "stats", "batch"], help="Operation mode"
+    )
     parser.add_argument("--text", type=str, default="", help="Input text to process")
     parser.add_argument(
         "--files",
@@ -364,9 +390,24 @@ def main() -> None:
         default="",
         help="Comma-separated file paths (batch mode, or for file count in scoring)",
     )
-    parser.add_argument("--from-agent", type=str, default=None, help="Source agent for downstream relevance")
-    parser.add_argument("--to-agent", type=str, default=None, help="Target agent for downstream relevance")
-    parser.add_argument("--blocker", action="store_true", default=False, help="Hint that entry was a blocker")
+    parser.add_argument(
+        "--from-agent",
+        type=str,
+        default=None,
+        help="Source agent for downstream relevance",
+    )
+    parser.add_argument(
+        "--to-agent",
+        type=str,
+        default=None,
+        help="Target agent for downstream relevance",
+    )
+    parser.add_argument(
+        "--blocker",
+        action="store_true",
+        default=False,
+        help="Hint that entry was a blocker",
+    )
 
     args = parser.parse_args()
 
@@ -378,7 +419,9 @@ def main() -> None:
             print("Error: --files is required for batch mode", file=sys.stderr)
             sys.exit(1)
         file_list = [f.strip() for f in args.files.split(",") if f.strip()]
-        output = process_batch(file_list, from_agent=args.from_agent, to_agent=args.to_agent)
+        output = process_batch(
+            file_list, from_agent=args.from_agent, to_agent=args.to_agent
+        )
         print(output)
         return
 
@@ -413,7 +456,9 @@ def main() -> None:
     # score mode
     # -----------------------------------------------------------------------
     if args.mode == "score":
-        file_count = len([f for f in args.files.split(",") if f.strip()]) if args.files else 0
+        file_count = (
+            len([f for f in args.files.split(",") if f.strip()]) if args.files else 0
+        )
         result = compute_score(
             text,
             from_agent=args.from_agent,

package/.pantheon/code-mode/manifest.json

@@ -3,15 +3,9 @@
   "scripts": {
     "checkpoint-session.py": "b70f6667ba287622d6353ada2612c7f2fb70d4ee170d456ecd7ee2b6ead891aa",
     "checkpoint-session.sh": "5b07e7c6c309e1db5c63f1f409eeb300a446bb9598899d94fdb13d94b56eb5f1",
-    "checkpoint_session.py": "8c52919eae450147742553f11faa347644c9e79f7acffa2fcc4452a5ed294a0a",
-    "compress-inline.py": "d3185cef07ff8b57d5a98d6c06a5b71504186ad2112fdb5a1ff48b0214d9cd3c",
-    "eval-llm-judge.py": "6d25df589c0f6cffa4766d0ad8eb86ac958960bc8c0f59e93098c7bf8effbbe8",
-    "eval-monte-carlo.py": "64c5eba9b072bec1f3eb713654da7edb9df46041395fdc4cb65730720135f8b1",
-    "eval-run.py": "5abfdac7d67d66838dd7ee402383e205ae39c0d912deb8a3a9a9a9c4d05952f5",
-    "eval-static.py": "33573295cf82a3c98e5f4c230ac376a40d1286ac16ff3aa031987396cde083b5",
+    "checkpoint_session.py": "487b4e3525ba03102fab1cd6283bb95d7489cd1848c72cf875884ac88b448ff7",
+    "compress-inline.py": "083ecc446cfe281be8f4aaca678eb2ae93adcbfef165f1746fb5bd364778f9d1",
     "example-sync.sh": "7fce84c8dc5a9d25d441a4cb59549a2731910e72d6ef82df45ac5ca6ea66c729",
-    "session-end-save.py": "11088a722642d022e5e2ebad78292db4aa4803087b32e261b6eb069e9b991c48",
-    "session-end-save.sh": "5fb410143bf62ed7d7c912805b00ae79171127b1b8ff0825db0eb4bf03b595a8",
     "test-allowed.sh": "723b116490044ffb403092c74b6bb94ee37330fecf453241f4cca22977ae8cdf",
     "test-auto-continue-checkpoint.sh": "de2641a4da0f26e9653f320d44763e5b5ed698cf9c701c103c5c82f91175376f",
     "test-env.sh": "6ea48a044451e5938e28fcb709368a7249a7d1b42615b190e40682ad26d4d1f9",