pantheon-opencode 1.4.3 → 1.5.0-beta.2

package/.pantheon/code-mode/session-end-save.py

@@ -0,0 +1,186 @@
+#!/usr/bin/env python3
+"""Session-end save — exports Vector DB entries to timestamped backup."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+# Bootstrap: resolve PANTHEON_HOME before _pantheon_paths is available
+_home_env = os.environ.get("PANTHEON_HOME")
+if _home_env:
+    _BOOT_HOME = Path(_home_env).expanduser().resolve()
+else:
+    _xdg = os.environ.get("XDG_CONFIG_HOME")
+    _BOOT_HOME = (
+        Path(_xdg).expanduser().resolve() / "opencode"
+        if _xdg
+        else Path.home() / ".config" / "opencode"
+    )
+sys.path.insert(0, str(_BOOT_HOME / "scripts"))
+
+from _pantheon_paths import pantheon_home, pantheon_project
+_PROJECT = pantheon_project()
+if _PROJECT is None:
+    print("ERROR: PANTHEON_PROJECT not set and CWD unavailable")
+    sys.exit(1)
+PROJECT_ROOT: Path = _PROJECT
+OUTPUT_DIR: Path = PROJECT_ROOT / ".pantheon" / "memory-bank" / ".tmp"
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Session-end memory save")
+    parser.add_argument("--dry-run", action="store_true", help="Preview without saving")
+    parser.add_argument("--agent", default="unknown", help="Agent name triggering save")
+    return parser.parse_args()
+
+
+def detect_agent(args_agent: str) -> str:
+    """Return agent name: CLI arg first, then env/fallback."""
+    if args_agent and args_agent != "unknown":
+        return args_agent
+    # Fall back to env var
+    from_env = sys.argv[0]
+    for candidate in ("zeus", "hermes", "aphrodite", "demeter",
+                       "themis", "apollo", "athena", "talos",
+                       "prometheus", "hephaestus", "iris",
+                       "nyx", "gaia", "mnemosyne"):
+        if candidate in from_env.lower():
+            return candidate
+    return "unknown"
+
+
+def try_export_memory() -> list[dict] | None:
+    """Try to export entries from pantheon-memory via MCP.
+
+    Tries three strategies:
+    1. Import memory_mcp_server module and call export directly
+    2. If ChromaDB unavailable, create placeholder (no crash)
+
+    Returns list of dicts with keys: content, importance, category, session_id
+    Returns None if absolutely unavailable (MCP down, no data).
+    Client-side filtering by importance >= 0.4.
+    """
+    # Strategy 1: Try direct module import
+    sys.path.insert(0, str(pantheon_home() / "scripts"))
+    try:
+        import vector_memory.index as vmi
+        # Use memory_sessions-like approach via ChromaDB
+        import chromadb
+        db_path = pantheon_home() / "memory" / "chroma_db"
+        if db_path.exists():
+            client = chromadb.PersistentClient(str(db_path))
+            collection = client.get_or_create_collection("pantheon_memory")
+            results = collection.get()
+            if results["ids"]:
+                entries = []
+                for i, doc_id in enumerate(results["ids"]):
+                    meta = results["metadatas"][i] if results["metadatas"] else {}
+                    doc = results["documents"][i] if results["documents"] else ""
+                    entries.append({
+                        "id": doc_id,
+                        "content": doc[:200] if doc else "",
+                        "importance": meta.get("importance", 0.5),
+                        "category": meta.get("category", "memory"),
+                        "session_id": meta.get("session_id", ""),
+                        "agent": meta.get("agent", "unknown"),
+                    })
+                # Client-side filter by importance >= 0.4
+                filtered = [e for e in entries if e["importance"] >= 0.4]
+                if filtered:
+                    return filtered
+                # If we have entries but all below threshold, don't return None
+                # (means MCP is working, just no high-importance entries yet)
+                return []
+    except ImportError:
+        pass
+    except Exception as e:
+        print(f"  (MCP export note: {e})")
+        pass
+
+    # Strategy 2: MCP unavailable — return None (caller handles placeholder)
+    return None
+
+
+def write_session_save(entries: list[dict], agent: str, dry_run: bool = False) -> Path | None:
+    """Write session save file. Returns path if written, None if dry-run."""
+    timestamp = datetime.now(UTC).strftime("%Y%m%d-%H%M%S")
+    filename = f"session-save-{timestamp}.md"
+    filepath = OUTPUT_DIR / filename
+
+    if dry_run:
+        print(f"[dry-run] Would save to: {filepath}")
+        print(f"[dry-run] Entries: {len(entries)} from agent '{agent}'")
+        return None
+
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    lines = [
+        f"# Session Save — {timestamp}",
+        f"**Agent:** {agent}",
+        f"**Entries:** {len(entries)}",
+        "",
+        "## Entries",
+    ]
+
+    if not entries:
+        lines.append("*(No entries with importance >= 0.4)*")
+    else:
+        for entry in entries:
+            content = entry.get("content", "—")
+            importance = entry.get("importance", 0)
+            category = entry.get("category", "memory")
+            lines.append(f"- [{importance:.1f}] ({category}) {content[:200]}")
+
+    filepath.write_text("\n".join(lines) + "\n")
+    print(f"  Saved {len(entries)} entries to {filepath}")
+    return filepath
+
+
+def update_deepwork_status(entries_count: int, agent: str) -> None:
+    """Append save record to active deepwork STATUS.md if found."""
+    deepwork_dir = PROJECT_ROOT / ".pantheon" / "deepwork"
+    if not deepwork_dir.exists():
+        return
+    for status_file in sorted(deepwork_dir.glob("*/STATUS.md")):
+        timestamp = datetime.now(UTC).strftime("%Y-%m-%d %H:%M")
+        line = f"- {timestamp}: Session save — {entries_count} entries (agent: {agent})"
+        with open(status_file, "a") as f:
+            f.write(f"{line}\n")
+        print(f"   Updated {status_file}")
+
+
+def main() -> None:
+    args = parse_args()
+    agent = detect_agent(args.agent)
+
+    print(f"Running session-end save (agent: {agent})")
+
+    if args.dry_run:
+        print("  --dry-run mode — no files will be written")
+
+    entries = try_export_memory()
+
+    if entries is None:
+        print("  pantheon-memory unavailable. Writing placeholder.")
+        entries = []
+
+    path = write_session_save(entries, agent, dry_run=args.dry_run)
+
+    if path and not args.dry_run:
+        update_deepwork_status(len(entries), agent)
+
+    print()
+    print(f"  Agent:     {agent}")
+    print(f"  Entries:   {len(entries)}")
+    print(f"  Dry-run:   {args.dry_run}")
+    print("Session-end save complete.")
+
+
+if __name__ == "__main__":
+    main()

package/.pantheon/code-mode/session-end-save.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# Wrapper for session-end-save.py
+# Usage: ./session-end-save.sh [agent_name] [--dry-run]
+#
+# Persists Vector DB entries to a timestamped backup file in
+# .pantheon/memory-bank/.tmp/ with client-side importance filtering.
+#
+# Arguments:
+#   agent_name  — name of the agent triggering the save (default: unknown)
+#   --dry-run   — preview without writing
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+AGENT="${1:-unknown}"
+shift || true
+
+python3 "$SCRIPT_DIR/session-end-save.py" --agent "$AGENT" "$@"

package/.pantheon/code-mode/test-allowed.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# ---
+# allowed_args: [foo, bar]
+# ---
+echo $*

package/.pantheon/code-mode/test-auto-continue-checkpoint.sh

@@ -0,0 +1,179 @@
+#!/bin/bash
+# Test: auto-continue-checkpoint.sh
+# Validates the checkpoint script creates checkpoints and heartbeat files correctly.
+# Usage: bash .pantheon/code-mode/test-auto-continue-checkpoint.sh
+
+set -euo pipefail
+
+TEST_DIR="$(mktemp -d)/test-auto-continue"
+trap 'rm -rf "$TEST_DIR"' EXIT
+SCRIPT=".pantheon/code-mode/auto-continue-checkpoint.sh"
+
+# Ensure script exists
+if [ ! -f "$SCRIPT" ]; then
+    echo "❌ FAIL: $SCRIPT not found"
+    exit 1
+fi
+
+echo "=== RED: Testing checkpoint script ==="
+
+# 1. Create a deepwork directory with a STATUS.md
+DEEPDIR="$TEST_DIR/test-slug"
+mkdir -p "$DEEPDIR"
+cat > "$DEEPDIR/STATUS.md" << 'EOF'
+# STATUS — test-slug
+**Date:** 2026-07-16T20:00:00Z
+**Phase:** 2
+**Turns:** 15
+**Status:** In Progress
+EOF
+
+# 2. Run the checkpoint script targeting our test directory
+# We need to run from repo root and use SLUG that maps to our test dir
+# The script uses .pantheon/deepwork/<slug>, so we need to symlink or override
+# Strategy: create a temporary .pantheon/deepwork/test-slug dir
+# Resolve the repo/runtime root from this script's location so the test never
+# depends on a hardcoded checkout path (the tarball must be machine-path-free).
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")/../.." && pwd)"
+mkdir -p "$REPO_ROOT/.pantheon/deepwork/test-slug"
+
+# Copy STATUS.md into the real deepwork path
+cp "$DEEPDIR/STATUS.md" "$REPO_ROOT/.pantheon/deepwork/test-slug/STATUS.md"
+
+# Run the actual script
+bash "$REPO_ROOT/$SCRIPT" "test-slug"
+
+# 3. VERIFY: checkpoint file created in the real deepwork path
+if [ ! -f "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-1.json" ]; then
+    echo "❌ FAIL: checkpoint-1.json not created"
+    # Cleanup
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint-1.json created"
+
+# 4. VERIFY: heartbeat file created
+if [ ! -f "$REPO_ROOT/.pantheon/deepwork/test-slug/heartbeat.json" ]; then
+    echo "❌ FAIL: heartbeat.json not created"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ heartbeat.json created"
+
+# 5. VERIFY: checkpoint content is valid JSON
+if ! jq empty "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-1.json" 2>/dev/null; then
+    echo "❌ FAIL: checkpoint-1.json is not valid JSON"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint-1.json is valid JSON"
+
+# 6. VERIFY: heartbeat content is valid JSON
+if ! jq empty "$REPO_ROOT/.pantheon/deepwork/test-slug/heartbeat.json" 2>/dev/null; then
+    echo "❌ FAIL: heartbeat.json is not valid JSON"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ heartbeat.json is valid JSON"
+
+# 7. VERIFY: checkpoint fields
+SLUG_CHECK=$(jq -r '.slug' "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-1.json")
+PHASE_CHECK=$(jq -r '.phase' "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-1.json")
+TURNS_CHECK=$(jq -r '.turn_count' "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-1.json")
+
+if [ "$SLUG_CHECK" != "test-slug" ]; then
+    echo "❌ FAIL: slug mismatch: got '$SLUG_CHECK'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint slug = '$SLUG_CHECK'"
+
+if [ "$PHASE_CHECK" != "2" ]; then
+    echo "❌ FAIL: phase mismatch: got '$PHASE_CHECK'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint phase = $PHASE_CHECK"
+
+if [ "$TURNS_CHECK" != "15" ]; then
+    echo "❌ FAIL: turn_count mismatch: got '$TURNS_CHECK'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint turn_count = $TURNS_CHECK"
+
+# 8. VERIFY: heartbeat fields
+HB_SLUG=$(jq -r '.slug' "$REPO_ROOT/.pantheon/deepwork/test-slug/heartbeat.json")
+HB_STATUS=$(jq -r '.status' "$REPO_ROOT/.pantheon/deepwork/test-slug/heartbeat.json")
+
+if [ "$HB_SLUG" != "test-slug" ]; then
+    echo "❌ FAIL: heartbeat slug mismatch: got '$HB_SLUG'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ heartbeat slug = '$HB_SLUG'"
+
+if [ "$HB_STATUS" != "alive" ]; then
+    echo "❌ FAIL: heartbeat status mismatch: got '$HB_STATUS'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ heartbeat status = '$HB_STATUS'"
+
+# 9. VERIFY: running a second time creates checkpoint-2.json
+bash "$REPO_ROOT/$SCRIPT" "test-slug"
+
+if [ ! -f "$REPO_ROOT/.pantheon/deepwork/test-slug/checkpoint-2.json" ]; then
+    echo "❌ FAIL: checkpoint-2.json not created on second run"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint-2.json created (auto-increment works)"
+
+# 10. VERIFY: second checkpoint has updated heartbeat
+HB_TIMESTAMP=$(jq -r '.last_action' "$REPO_ROOT/.pantheon/deepwork/test-slug/heartbeat.json")
+if [ -z "$HB_TIMESTAMP" ]; then
+    echo "❌ FAIL: heartbeat timestamp empty after second run"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ heartbeat timestamp updated = '$HB_TIMESTAMP'"
+
+# 11. VERIFY: without STATUS.md, script still works (defaults to 0)
+bash "$REPO_ROOT/$SCRIPT" "empty-test"
+if [ ! -f "$REPO_ROOT/.pantheon/deepwork/empty-test/checkpoint-1.json" ]; then
+    echo "❌ FAIL: checkpoint not created for slug without STATUS.md"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/empty-test"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+
+PHASE_DEFAULT=$(jq -r '.phase' "$REPO_ROOT/.pantheon/deepwork/empty-test/checkpoint-1.json")
+if [ "$PHASE_DEFAULT" != "0" ]; then
+    echo "❌ FAIL: phase should default to 0 without STATUS.md, got '$PHASE_DEFAULT'"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/empty-test"
+    rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+    rm -rf "$TEST_DIR"
+    exit 1
+fi
+echo "  ✅ checkpoint works without STATUS.md (phase=0 default)"
+
+# Cleanup all test artifacts
+rm -rf "$REPO_ROOT/.pantheon/deepwork/test-slug"
+rm -rf "$REPO_ROOT/.pantheon/deepwork/empty-test"
+rm -rf "$TEST_DIR"
+
+echo ""
+echo "=== ✅ ALL CHECKPOINT TESTS PASSED ==="

package/.pantheon/code-mode/test-env.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# ---
+# timeout: 5
+# ---
+env | wc -l
+echo "---"
+env | sort

package/.pantheon/code-mode/test-prlimit.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+# ---
+# timeout: 5
+# ---
+echo "pid: $$"
+cat /proc/self/limits | grep -E "Max cpu|Max address|Max processes" 2>&1 | head -n 5
+echo "--- prlimit in cmd check ---"
+# Show that prlimit limits are applied: prlimit --cpu=10 should show cpu 10
+prlimit --output RESOURCE,SOFT,HARD 2>&1 | head -n 20

package/.pantheon/code-mode/test-timeout.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# ---
+# timeout: 2
+# ---
+sleep 10
+echo "should not reach"