agent-resurrect-btw 0.1.0__tar.gz

agent_resurrect_btw-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Entire Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_resurrect_btw-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agent-resurrect-btw
+Version: 0.1.0
+Summary: Agent Resurrect SDK
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: requests>=2.31.0
+Dynamic: license-file
+
+# Agent Resurrect SDK
+
+Agent Resurrect is a real-time loop-breaker and telemetry co-pilot for agentic workflows. It is designed to sit alongside a Databricks-backed failure trap table, observe agent activity, and provide the control surface needed to inspect, diagnose, and recover from runaway loops.
+
+This repository currently contains the foundational SDK scaffold only. The business logic, Databricks integration, and runtime loop-breaking behavior will be added incrementally on top of this structure.
+
+## Project Layout
+
+```text
+resurrect/
+  __init__.py
+  cli.py
+  config.py
+  core/
+    __init__.py
+    entire_bridge.py
+    databricks_client.py
+  ui/
+    __init__.py
+    console.py
+tests/
+  __init__.py
+  test_config.py
+  test_connectivity.py
+```
+
+## Planned CLI
+
+The `resurrect` command will eventually expose these entry points:
+
+- `resurrect init`
+- `resurrect doctor`
+- `resurrect run`
+
+Those commands are not implemented yet. The current CLI module only provides a minimal Typer application stub so the package can be installed and extended safely.
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and populate the Databricks connection settings:
+
+- `DATABRICKS_HOST`
+- `DATABRICKS_TOKEN`
+- `DATABRICKS_WAREHOUSE_ID`
+- `DELTA_TABLE_NAME`
+
+## Build Metadata
+
+- Package name: `agent-resurrect`
+- Version: `0.1.0`
+- Entry point: `resurrect`
+

agent_resurrect_btw-0.1.0/README.md

@@ -0,0 +1,51 @@
+# Agent Resurrect SDK
+
+Agent Resurrect is a real-time loop-breaker and telemetry co-pilot for agentic workflows. It is designed to sit alongside a Databricks-backed failure trap table, observe agent activity, and provide the control surface needed to inspect, diagnose, and recover from runaway loops.
+
+This repository currently contains the foundational SDK scaffold only. The business logic, Databricks integration, and runtime loop-breaking behavior will be added incrementally on top of this structure.
+
+## Project Layout
+
+```text
+resurrect/
+  __init__.py
+  cli.py
+  config.py
+  core/
+    __init__.py
+    entire_bridge.py
+    databricks_client.py
+  ui/
+    __init__.py
+    console.py
+tests/
+  __init__.py
+  test_config.py
+  test_connectivity.py
+```
+
+## Planned CLI
+
+The `resurrect` command will eventually expose these entry points:
+
+- `resurrect init`
+- `resurrect doctor`
+- `resurrect run`
+
+Those commands are not implemented yet. The current CLI module only provides a minimal Typer application stub so the package can be installed and extended safely.
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and populate the Databricks connection settings:
+
+- `DATABRICKS_HOST`
+- `DATABRICKS_TOKEN`
+- `DATABRICKS_WAREHOUSE_ID`
+- `DELTA_TABLE_NAME`
+
+## Build Metadata
+
+- Package name: `agent-resurrect`
+- Version: `0.1.0`
+- Entry point: `resurrect`
+

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: agent-resurrect-btw
+Version: 0.1.0
+Summary: Agent Resurrect SDK
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: requests>=2.31.0
+Dynamic: license-file
+
+# Agent Resurrect SDK
+
+Agent Resurrect is a real-time loop-breaker and telemetry co-pilot for agentic workflows. It is designed to sit alongside a Databricks-backed failure trap table, observe agent activity, and provide the control surface needed to inspect, diagnose, and recover from runaway loops.
+
+This repository currently contains the foundational SDK scaffold only. The business logic, Databricks integration, and runtime loop-breaking behavior will be added incrementally on top of this structure.
+
+## Project Layout
+
+```text
+resurrect/
+  __init__.py
+  cli.py
+  config.py
+  core/
+    __init__.py
+    entire_bridge.py
+    databricks_client.py
+  ui/
+    __init__.py
+    console.py
+tests/
+  __init__.py
+  test_config.py
+  test_connectivity.py
+```
+
+## Planned CLI
+
+The `resurrect` command will eventually expose these entry points:
+
+- `resurrect init`
+- `resurrect doctor`
+- `resurrect run`
+
+Those commands are not implemented yet. The current CLI module only provides a minimal Typer application stub so the package can be installed and extended safely.
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and populate the Databricks connection settings:
+
+- `DATABRICKS_HOST`
+- `DATABRICKS_TOKEN`
+- `DATABRICKS_WAREHOUSE_ID`
+- `DELTA_TABLE_NAME`
+
+## Build Metadata
+
+- Package name: `agent-resurrect`
+- Version: `0.1.0`
+- Entry point: `resurrect`
+

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+agent_resurrect_btw.egg-info/PKG-INFO
+agent_resurrect_btw.egg-info/SOURCES.txt
+agent_resurrect_btw.egg-info/dependency_links.txt
+agent_resurrect_btw.egg-info/entry_points.txt
+agent_resurrect_btw.egg-info/requires.txt
+agent_resurrect_btw.egg-info/top_level.txt
+resurrect/__init__.py
+resurrect/cli.py
+resurrect/config.py
+resurrect/handoff.py
+resurrect/parser.py
+resurrect/core/__init__.py
+resurrect/core/databricks_client.py
+resurrect/core/entire_bridge.py
+resurrect/ui/__init__.py
+resurrect/ui/console.py
+tests/test_config.py
+tests/test_connectivity.py
+tests/test_privacy_boundary.py

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+resurrect = resurrect.cli:app

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer>=0.9.0
+rich>=13.0.0
+requests>=2.31.0

agent_resurrect_btw-0.1.0/agent_resurrect_btw.egg-info/top_level.txt

@@ -0,0 +1 @@
+resurrect

agent_resurrect_btw-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "agent-resurrect-btw"
+version = "0.1.0"
+description = "Agent Resurrect SDK"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "typer>=0.9.0",
+  "rich>=13.0.0",
+  "requests>=2.31.0",
+]
+
+[project.scripts]
+resurrect = "resurrect.cli:app"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["resurrect*"]
+

agent_resurrect_btw-0.1.0/resurrect/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.1.0"
+

agent_resurrect_btw-0.1.0/resurrect/cli.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from resurrect.config import ResurrectConfig
+from resurrect.core.databricks_client import DatabricksClient
+from resurrect.core.entire_bridge import CommandResult, check_entire_status, setup_entire
+from resurrect.handoff import build_handoff_manifest, write_handoff_manifest
+from resurrect.parser import ParsedTelemetry, parse_telemetry
+from resurrect.ui.console import StatusItem, render_status_board
+
+
+app = typer.Typer(help="Agent Resurrect command-line interface.")
+console = Console()
+
+
+@app.callback(invoke_without_command=True)
+def main() -> None:
+    """Entry point for the resurrect CLI."""
+    return None
+
+
+@app.command()
+def init(
+    agent: str = "codex",
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show debug details."),
+    cwd: Path = typer.Argument(Path.cwd(), exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+) -> None:
+    result = setup_entire(agent=agent, cwd=cwd)
+    config = ResurrectConfig().save(cwd)
+    if verbose or not result.ok:
+        _render_debug("entire enable", result, cwd)
+    if result.ok:
+        typer.echo(f"Initialized Entire hooks and created {config}")
+    else:
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def doctor(
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show debug details."),
+    cwd: Path = typer.Argument(Path.cwd(), exists=True, file_okay=False, dir_okay=True, resolve_path=True),
+) -> None:
+    config = ResurrectConfig.load(cwd)
+    items: list[StatusItem] = []
+
+    missing = config.missing_fields()
+    items.append(StatusItem("Config", not missing, "All required values loaded." if not missing else f"Missing: {', '.join(missing)}"))
+
+    entire_status = check_entire_status(cwd)
+    items.append(StatusItem("Entire", entire_status.ok, entire_status.stderr or entire_status.stdout))
+    if verbose or not entire_status.ok:
+        _render_debug("entire status", entire_status, cwd)
+
+    client = DatabricksClient(config.databricks_host, config.databricks_token, config.databricks_warehouse_id)
+    ping = client.ping_connection()
+    items.append(StatusItem("Databricks ping", ping.ok, ping.error or (f"{ping.latency_ms:.1f} ms" if ping.latency_ms is not None else "")))
+
+    table = client.verify_table_exists(config.delta_table_name)
+    items.append(StatusItem("Delta table", table.ok, table.error or f"{config.delta_table_name} is queryable"))
+
+    telemetry = parse_telemetry(cwd / "refs" / "entire" / "checkpoints")
+    query_result = client.query_failure_traps(telemetry, config.delta_table_name)
+    context_label = "[PARTIAL / REDACTED CONTEXT]" if not telemetry.status.is_complete else "[COMPLETE CONTEXT]"
+    items.append(StatusItem("Failure traps", query_result.ok, query_result.error or telemetry.error_signature, context_label=context_label))
+
+    render_status_board(items)
+    manifest_dir = cwd / ".resurrect"
+    manifest_dir.mkdir(parents=True, exist_ok=True)
+    write_handoff_manifest(manifest_dir / "handoff_manifest.json", telemetry, verified_match=query_result.ok and telemetry.status.is_complete)
+    if not all(item.ok for item in items):
+        raise typer.Exit(code=1)
+
+
+def _render_debug(label: str, result: CommandResult, cwd: Path) -> None:
+    body = Text()
+    body.append(f"Running: {result.command}\n", style="dim")
+    body.append(f"cwd: {cwd}\n", style="dim")
+    body.append(f"returncode: {result.returncode}\n", style="dim")
+    body.append("stdout:\n", style="bold")
+    body.append(f"{result.stdout or '<empty>'}\n")
+    body.append("stderr:\n", style="bold")
+    body.append(f"{result.stderr or '<empty>'}")
+    console.print(Panel(body, title=f"Debug: {label}", border_style="yellow"))

agent_resurrect_btw-0.1.0/resurrect/config.py

@@ -0,0 +1,51 @@
+"""Configuration loading and persistence for Agent Resurrect."""
+
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Mapping
+
+
+DEFAULT_DELTA_TABLE_NAME = "dev_failure_traps"
+
+
+@dataclass(slots=True)
+class ResurrectConfig:
+    databricks_host: str | None = None
+    databricks_token: str | None = None
+    databricks_warehouse_id: str | None = None
+    delta_table_name: str = DEFAULT_DELTA_TABLE_NAME
+
+    @classmethod
+    def load(cls, base_dir: Path | str = Path.cwd(), env: Mapping[str, str] | None = None) -> "ResurrectConfig":
+        env_map = os.environ if env is None else env
+        config_path = Path(base_dir) / ".resurrect" / "config.json"
+        data: dict[str, Any] = {}
+        if config_path.exists():
+            data = json.loads(config_path.read_text(encoding="utf-8"))
+        return cls(
+            databricks_host=data.get("databricks_host") or env_map.get("DATABRICKS_HOST"),
+            databricks_token=data.get("databricks_token") or env_map.get("DATABRICKS_TOKEN"),
+            databricks_warehouse_id=data.get("databricks_warehouse_id") or env_map.get("DATABRICKS_WAREHOUSE_ID"),
+            delta_table_name=data.get("delta_table_name") or env_map.get("DELTA_TABLE_NAME") or DEFAULT_DELTA_TABLE_NAME,
+        )
+
+    def save(self, base_dir: Path | str = Path.cwd()) -> Path:
+        config_dir = Path(base_dir) / ".resurrect"
+        config_dir.mkdir(parents=True, exist_ok=True)
+        config_path = config_dir / "config.json"
+        config_path.write_text(json.dumps(asdict(self), indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        return config_path
+
+    def missing_fields(self) -> list[str]:
+        missing = []
+        if not self.databricks_host:
+            missing.append("databricks_host")
+        if not self.databricks_token:
+            missing.append("databricks_token")
+        if not self.databricks_warehouse_id:
+            missing.append("databricks_warehouse_id")
+        return missing

agent_resurrect_btw-0.1.0/resurrect/core/__init__.py

@@ -0,0 +1,2 @@
+"""Core integration layer for Agent Resurrect."""
+

agent_resurrect_btw-0.1.0/resurrect/core/databricks_client.py

@@ -0,0 +1,100 @@
+"""Databricks connectivity helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from time import perf_counter
+from typing import Any
+
+import requests
+
+from resurrect.parser import ParsedTelemetry
+
+
+@dataclass(slots=True)
+class DiagnosticResult:
+    ok: bool
+    latency_ms: float | None = None
+    error: str | None = None
+
+
+class DatabricksClient:
+    def __init__(self, host: str | None, token: str | None, warehouse_id: str | None, session: requests.Session | None = None) -> None:
+        self.host = host.rstrip("/") if host else None
+        self.token = token
+        self.warehouse_id = warehouse_id
+        self.session = session or requests.Session()
+
+    def _headers(self) -> dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}", "Content-Type": "application/json"}
+
+    def _post_statement(self, sql: str, parameters: list[dict[str, Any]] | None = None) -> requests.Response:
+        url = f"{self.host}/api/2.0/sql/statements"
+        payload: dict[str, Any] = {
+            "warehouse_id": self.warehouse_id,
+            "statement": sql,
+            "wait_timeout": "10s",
+        }
+        if parameters:
+            payload["parameters"] = parameters
+        return self.session.post(url, json=payload, headers=self._headers(), timeout=15)
+
+    def ping_connection(self) -> DiagnosticResult:
+        if not self.host:
+            return DiagnosticResult(ok=False, error="Missing DATABRICKS_HOST.")
+        if not self.token:
+            return DiagnosticResult(ok=False, error="Missing DATABRICKS_TOKEN.")
+        if not self.warehouse_id:
+            return DiagnosticResult(ok=False, error="Missing DATABRICKS_WAREHOUSE_ID.")
+
+        start = perf_counter()
+        try:
+            response = self._post_statement("SELECT 1")
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            return DiagnosticResult(ok=False, error=str(exc))
+        latency_ms = (perf_counter() - start) * 1000
+        return DiagnosticResult(ok=True, latency_ms=latency_ms)
+
+    def verify_table_exists(self, table_name: str = "dev_failure_traps") -> DiagnosticResult:
+        if not self.host or not self.token or not self.warehouse_id:
+            return DiagnosticResult(ok=False, error="Databricks configuration is incomplete.")
+        query = f"SELECT 1 FROM {table_name} LIMIT 1"
+        try:
+            response = self._post_statement(query)
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            return DiagnosticResult(ok=False, error=str(exc))
+        return DiagnosticResult(ok=True)
+
+    def query_failure_traps(self, telemetry: ParsedTelemetry, table_name: str = "dev_failure_traps") -> DiagnosticResult:
+        if not self.host or not self.token or not self.warehouse_id:
+            return DiagnosticResult(ok=False, error="Databricks configuration is incomplete.")
+        if not telemetry.error_signature:
+            return DiagnosticResult(ok=False, error="Missing sanitized error signature.")
+
+        if telemetry.status.is_complete:
+            statement = (
+                f"SELECT * FROM {table_name} "
+                "WHERE error_signature = :error_signature "
+                "AND module_name IN (:module_0, :module_1, :module_2) "
+                "LIMIT 5"
+            )
+            parameters = [{"name": "error_signature", "value": telemetry.error_signature}]
+            parameters.extend({"name": f"module_{idx}", "value": module} for idx, module in enumerate(telemetry.module_names[:3]))
+        else:
+            statement = (
+                f"SELECT * FROM {table_name} "
+                "WHERE error_signature LIKE :error_signature "
+                "OR module_name IN (:module_0, :module_1, :module_2) "
+                "LIMIT 5"
+            )
+            parameters = [{"name": "error_signature", "value": f"%{telemetry.error_signature.split(':', 1)[0]}%"}]
+            parameters.extend({"name": f"module_{idx}", "value": module} for idx, module in enumerate(telemetry.module_names[:3]))
+        try:
+            response = self._post_statement(statement, parameters=parameters)
+            response.raise_for_status()
+        except requests.RequestException as exc:
+            return DiagnosticResult(ok=False, error=str(exc))
+        suffix = "heuristic/partial" if not telemetry.status.is_complete else "verified"
+        return DiagnosticResult(ok=True, error=suffix)

agent_resurrect_btw-0.1.0/resurrect/core/entire_bridge.py

@@ -0,0 +1,110 @@
+"""Helpers for Entire CLI integration."""
+
+from __future__ import annotations
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(slots=True)
+class CommandResult:
+    ok: bool
+    command: str
+    stdout: str = ""
+    stderr: str = ""
+    returncode: int | None = None
+
+
+def _run(command: list[str], cwd: Path | str | None = None) -> CommandResult:
+    try:
+        completed = subprocess.run(
+            command,
+            cwd=cwd,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            check=False,
+            timeout=15,
+        )
+        stdout = (completed.stdout or "").strip()
+        stderr = (completed.stderr or "").strip()
+        return CommandResult(
+            ok=completed.returncode == 0,
+            command=" ".join(command),
+            stdout=stdout,
+            stderr=stderr,
+            returncode=completed.returncode,
+        )
+    except subprocess.TimeoutExpired as exc:
+        return CommandResult(
+            ok=False,
+            command=" ".join(command),
+            stdout=(exc.stdout or "").strip() if isinstance(exc.stdout, str) else "",
+            stderr=f"Command timed out after 15 seconds while running: {' '.join(command)}",
+            returncode=None,
+        )
+    except FileNotFoundError as exc:
+        return CommandResult(
+            ok=False,
+            command=" ".join(command),
+            stderr=f"Command not found: {command[0]}. Install it and ensure it is on PATH. Details: {exc}",
+            returncode=None,
+        )
+    except Exception as exc:
+        return CommandResult(
+            ok=False,
+            command=" ".join(command),
+            stderr=f"Failed to run {' '.join(command)} in {cwd}: {exc}",
+            returncode=None,
+        )
+
+
+def setup_entire(agent: str = "codex", cwd: Path | str = Path.cwd()) -> CommandResult:
+    git_dir = Path(cwd) / ".git"
+    if not git_dir.exists():
+        return CommandResult(ok=False, command="git rev-parse --is-inside-work-tree", stderr="Git repository not initialized.")
+
+    enable = _run(["entire", "enable", "--force"], cwd=cwd)
+    if not enable.ok:
+        return enable
+
+    hooks = _run(["entire", "hooks", "configure", "--agent", agent], cwd=cwd)
+    if not hooks.ok:
+        return hooks
+
+    return CommandResult(
+        ok=True,
+        command=f"entire enable --force && entire hooks configure --agent {agent}",
+        stdout="\n".join(part for part in [enable.stdout, hooks.stdout] if part),
+        stderr="\n".join(part for part in [enable.stderr, hooks.stderr] if part),
+        returncode=0,
+    )
+
+
+def check_entire_status(cwd: Path | str = Path.cwd()) -> CommandResult:
+    status = _run(["entire", "status"], cwd=cwd)
+    text = f"{status.stdout}\n{status.stderr}".lower()
+    if status.returncode == 0 and ("enabled" in text or "checkpoints active" in text):
+        first_line = (status.stdout or "").splitlines()[0] if (status.stdout or "").splitlines() else ""
+        detail = f"Entire active ({first_line})" if first_line else "Entire active"
+        return CommandResult(
+            ok=True,
+            command=status.command,
+            stdout=status.stdout,
+            stderr=detail,
+            returncode=status.returncode,
+        )
+    if not status.ok:
+        return status
+    if "checkpoint" not in text or ("active" not in text and "enabled" not in text):
+        return CommandResult(
+            ok=False,
+            command=status.command,
+            stdout=status.stdout,
+            stderr=status.stderr or "Entire is not enabled on this repository.",
+            returncode=status.returncode,
+        )
+    return status

agent_resurrect_btw-0.1.0/resurrect/handoff.py

@@ -0,0 +1,47 @@
+"""Handoff manifest assembly for privacy-aware checkpoint resolution."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+import json
+from pathlib import Path
+from typing import Any
+
+from resurrect.parser import ParsedTelemetry
+
+
+@dataclass(slots=True)
+class HandoffManifest:
+    status_label: str
+    resolution_kind: str
+    privacy_provenance: str
+    confidence: str
+    error_signature: str
+    module_names: list[str] = field(default_factory=list)
+    is_complete: bool = False
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_json(self) -> str:
+        return json.dumps(asdict(self), indent=2, sort_keys=True) + "\n"
+
+
+def build_handoff_manifest(telemetry: ParsedTelemetry, verified_match: bool) -> HandoffManifest:
+    partial = not telemetry.status.is_complete or telemetry.status.confidence != "complete" or not verified_match
+    return HandoffManifest(
+        status_label="[PARTIAL / REDACTED CONTEXT]" if partial else "[COMPLETE CONTEXT]",
+        resolution_kind="heuristic" if partial else "verified",
+        privacy_provenance=telemetry.privacy_provenance,
+        confidence=telemetry.status.confidence,
+        error_signature=telemetry.error_signature,
+        module_names=telemetry.module_names,
+        is_complete=telemetry.status.is_complete and verified_match,
+        metadata={
+            "missing_fields": telemetry.status.missing_fields,
+            "source_path": str(telemetry.source_path) if telemetry.source_path else None,
+        },
+    )
+
+
+def write_handoff_manifest(path: Path, telemetry: ParsedTelemetry, verified_match: bool) -> Path:
+    path.write_text(build_handoff_manifest(telemetry, verified_match).to_json(), encoding="utf-8")
+    return path

agent_resurrect_btw-0.1.0/resurrect/parser.py

@@ -0,0 +1,132 @@
+"""Telemetry parsing and privacy sanitization for checkpoint context."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import json
+import re
+from typing import Any
+
+
+REDACTION_MARKERS = ("[REDACTED]", "***")
+DEFAULT_CHECKPOINT_DIR = Path("refs/entire/checkpoints")
+
+
+@dataclass(slots=True)
+class ContextStatus:
+    is_complete: bool
+    confidence: str
+    missing_fields: list[str] = field(default_factory=list)
+
+
+@dataclass(slots=True)
+class ParsedTelemetry:
+    error_signature: str = ""
+    module_names: list[str] = field(default_factory=list)
+    privacy_provenance: str = "sanitized"
+    status: ContextStatus = field(default_factory=lambda: ContextStatus(is_complete=False, confidence="partial"))
+    source_path: Path | None = None
+
+
+def _looks_redacted(text: str) -> bool:
+    return any(marker in text for marker in REDACTION_MARKERS)
+
+
+def _sanitize_text(text: str) -> str:
+    text = re.sub(r"(?i)\b[A-Z]:\\[^ \n\r\t]+|/[^ \n\r\t]+", "<path>", text)
+    text = re.sub(r"(?i)\b(token|password|secret|api[_-]?key)\s*[:=]\s*[^ \n\r\t]+", r"\1=<redacted>", text)
+    text = re.sub(r"(?i)\b[0-9a-f]{16,}\b", "<token>", text)
+    text = re.sub(r"`[^`]+`", "<redacted>", text)
+    return text.strip()
+
+
+def _extract_exception_signature(text: str) -> str:
+    if not text:
+        return "UnknownError: missing checkpoint content"
+    lines = [line.strip() for line in text.splitlines() if line.strip()]
+    if not lines:
+        return "UnknownError: empty checkpoint content"
+    for line in reversed(lines):
+        if ":" in line:
+            return _sanitize_text(line)
+    return _sanitize_text(lines[-1])
+
+
+def _extract_module_names(events: list[dict[str, Any]]) -> list[str]:
+    modules: set[str] = set()
+    for event in events:
+        module = event.get("module") or event.get("tool") or event.get("source")
+        if isinstance(module, str) and module:
+            modules.add(module.split(".")[0])
+    return sorted(modules)
+
+
+def _read_checkpoint_records(checkpoint_dir: Path) -> tuple[list[dict[str, Any]], list[str]]:
+    records: list[dict[str, Any]] = []
+    missing_fields: list[str] = []
+    if not checkpoint_dir.exists():
+        missing_fields.append("checkpoint_dir")
+        return records, missing_fields
+    for path in sorted(checkpoint_dir.glob("**/*.jsonl")):
+        try:
+            for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+                if not line.strip():
+                    continue
+                try:
+                    record = json.loads(line)
+                except json.JSONDecodeError:
+                    missing_fields.append(f"truncated_line:{path.name}")
+                    continue
+                if isinstance(record, dict):
+                    records.append(record)
+        except OSError:
+            missing_fields.append(f"unreadable:{path.name}")
+    return records, missing_fields
+
+
+def parse_telemetry(checkpoint_dir: Path | None = None, fixture_path: Path | None = None) -> ParsedTelemetry:
+    checkpoint_root = checkpoint_dir or DEFAULT_CHECKPOINT_DIR
+    records, missing_fields = _read_checkpoint_records(checkpoint_root)
+    source_path: Path | None = checkpoint_root if records else None
+
+    if not records and fixture_path and fixture_path.exists():
+        source_path = fixture_path
+        try:
+            for line in fixture_path.read_text(encoding="utf-8", errors="replace").splitlines():
+                if line.strip():
+                    obj = json.loads(line)
+                    if isinstance(obj, dict):
+                        records.append(obj)
+        except (OSError, json.JSONDecodeError):
+            missing_fields.append("fixture_parse_failed")
+
+    transcript_parts: list[str] = []
+    redacted = False
+    for record in records:
+        if "prompt" not in record:
+            missing_fields.append("prompt")
+        if "stderr" not in record and "stdout" not in record:
+            missing_fields.append("tool_output")
+        for field in ("prompt", "transcript", "stderr", "stdout", "error", "message"):
+            value = record.get(field)
+            if isinstance(value, str) and value:
+                if _looks_redacted(value):
+                    redacted = True
+                transcript_parts.append(value)
+    transcript = "\n".join(transcript_parts)
+    if _looks_redacted(transcript):
+        redacted = True
+    signature = _extract_exception_signature(transcript)
+    status = ContextStatus(
+        is_complete=not redacted and not missing_fields,
+        confidence="complete" if not redacted and not missing_fields else "partial",
+        missing_fields=sorted(set(missing_fields)),
+    )
+    return ParsedTelemetry(
+        error_signature=signature,
+        module_names=_extract_module_names(records),
+        privacy_provenance="checkpoint" if source_path == checkpoint_root else "fixture",
+        status=status,
+        source_path=source_path,
+    )

agent_resurrect_btw-0.1.0/resurrect/ui/__init__.py

@@ -0,0 +1,2 @@
+"""UI helpers for Agent Resurrect."""
+

agent_resurrect_btw-0.1.0/resurrect/ui/console.py

@@ -0,0 +1,34 @@
+"""Rich console rendering for diagnostics."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+@dataclass(slots=True)
+class StatusItem:
+    name: str
+    ok: bool
+    detail: str = ""
+    context_label: str = ""
+
+
+def render_status_board(items: list[StatusItem], title: str = "Resurrect Doctor") -> Console:
+    console = Console()
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Check")
+    table.add_column("Status")
+    table.add_column("Details")
+    for item in items:
+        status = "[green]PASS[/green]" if item.ok else "[red]FAIL[/red]"
+        check = "[green]✓[/green]" if item.ok else "[yellow]![/yellow]"
+        detail = item.detail or ""
+        if item.context_label:
+            detail = f"{item.context_label} {detail}".strip()
+        table.add_row(f"{check} {item.name}", status, detail)
+    console.print(Panel(table, title=title, border_style="blue"))
+    return console

agent_resurrect_btw-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_resurrect_btw-0.1.0/tests/test_config.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from resurrect.config import DEFAULT_DELTA_TABLE_NAME, ResurrectConfig
+
+
+def test_loads_from_env_when_config_missing(tmp_path: Path) -> None:
+    env = {
+        "DATABRICKS_HOST": "https://example.databricks.com",
+        "DATABRICKS_TOKEN": "token",
+        "DATABRICKS_WAREHOUSE_ID": "wh-1",
+    }
+    config = ResurrectConfig.load(tmp_path, env=env)
+    assert config.databricks_host == env["DATABRICKS_HOST"]
+    assert config.databricks_token == env["DATABRICKS_TOKEN"]
+    assert config.databricks_warehouse_id == env["DATABRICKS_WAREHOUSE_ID"]
+    assert config.delta_table_name == DEFAULT_DELTA_TABLE_NAME
+
+
+def test_save_and_load_round_trip(tmp_path: Path) -> None:
+    config = ResurrectConfig(
+        databricks_host="https://example.databricks.com",
+        databricks_token="token",
+        databricks_warehouse_id="wh-1",
+        delta_table_name="custom_table",
+    )
+    path = config.save(tmp_path)
+    assert path.exists()
+    saved = json.loads(path.read_text(encoding="utf-8"))
+    assert saved["delta_table_name"] == "custom_table"
+
+    loaded = ResurrectConfig.load(tmp_path, env={})
+    assert loaded == config

agent_resurrect_btw-0.1.0/tests/test_connectivity.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import requests
+
+from resurrect.core.databricks_client import DatabricksClient
+from resurrect.core.entire_bridge import _run, check_entire_status, setup_entire
+
+
+def test_setup_entire_runs_commands(monkeypatch, tmp_path: Path) -> None:
+    (tmp_path / ".git").mkdir()
+    calls: list[list[str]] = []
+
+    def fake_run(command, cwd=None, stdin=None, capture_output=None, text=None, encoding=None, errors=None, check=None, timeout=None):
+        calls.append(command)
+        return SimpleNamespace(returncode=0, stdout="ok", stderr="")
+
+    monkeypatch.setattr("resurrect.core.entire_bridge.subprocess.run", fake_run)
+    result = setup_entire(cwd=tmp_path)
+    assert result.ok
+    assert calls == [["entire", "enable", "--force"], ["entire", "hooks", "configure", "--agent", "codex"]]
+
+
+def test_check_entire_status_detects_active_checkpoints(monkeypatch, tmp_path: Path) -> None:
+    def fake_run(command, cwd=None, stdin=None, capture_output=None, text=None, encoding=None, errors=None, check=None, timeout=None):
+        return SimpleNamespace(returncode=0, stdout="checkpoints active", stderr="")
+
+    monkeypatch.setattr("resurrect.core.entire_bridge.subprocess.run", fake_run)
+    result = check_entire_status(cwd=tmp_path)
+    assert result.ok
+
+
+def test_ping_connection_and_table_query(monkeypatch) -> None:
+    session = Mock(spec=requests.Session)
+    response = Mock()
+    response.raise_for_status.return_value = None
+    session.post.return_value = response
+    client = DatabricksClient("https://example.databricks.com", "token", "wh-1", session=session)
+
+    ping = client.ping_connection()
+    table = client.verify_table_exists()
+
+    assert ping.ok
+    assert table.ok
+    assert session.post.call_count == 2
+    assert session.post.call_args_list[0].args[0].endswith("/api/2.0/sql/statements")
+
+
+def test_ping_connection_reports_missing_fields() -> None:
+    client = DatabricksClient(None, None, None)
+    result = client.ping_connection()
+    assert not result.ok
+    assert "Missing DATABRICKS_HOST" in result.error
+
+
+def test_run_handles_none_output(monkeypatch, tmp_path: Path) -> None:
+    def fake_run(command, cwd=None, stdin=None, capture_output=None, text=None, encoding=None, errors=None, check=None, timeout=None):
+        return SimpleNamespace(returncode=0, stdout=None, stderr=None)
+
+    monkeypatch.setattr("resurrect.core.entire_bridge.subprocess.run", fake_run)
+    result = _run(["entire", "status"], cwd=tmp_path)
+    assert result.ok
+    assert result.stdout == ""
+    assert result.stderr == ""
+
+
+def test_run_decodes_non_ascii_output(monkeypatch, tmp_path: Path) -> None:
+    def fake_run(command, cwd=None, stdin=None, capture_output=None, text=None, encoding=None, errors=None, check=None, timeout=None):
+        return SimpleNamespace(returncode=0, stdout="naïve ✓", stderr="错误")
+
+    monkeypatch.setattr("resurrect.core.entire_bridge.subprocess.run", fake_run)
+    result = _run(["entire", "status"], cwd=tmp_path)
+    assert result.ok
+    assert result.stdout == "naïve ✓"
+    assert result.stderr == "错误"

agent_resurrect_btw-0.1.0/tests/test_privacy_boundary.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import requests
+
+from resurrect.core.databricks_client import DatabricksClient
+from resurrect.handoff import build_handoff_manifest
+from resurrect.parser import parse_telemetry
+from resurrect.ui.console import StatusItem
+
+
+def test_privacy_boundary_with_redacted_checkpoint(monkeypatch, tmp_path: Path) -> None:
+    checkpoint_dir = tmp_path / "refs" / "entire" / "checkpoints"
+    checkpoint_dir.mkdir(parents=True)
+    fixture = Path(__file__).parent / "fixtures" / "redacted_checkpoint.jsonl"
+    (checkpoint_dir / "checkpoint.jsonl").write_text(fixture.read_text(encoding="utf-8"), encoding="utf-8")
+
+    telemetry = parse_telemetry(checkpoint_dir)
+    assert telemetry.error_signature
+    assert not telemetry.status.is_complete
+    assert telemetry.status.confidence == "partial"
+    assert "prompt" in telemetry.status.missing_fields
+
+    session = Mock(spec=requests.Session)
+    response = Mock()
+    response.raise_for_status.return_value = None
+    session.post.return_value = response
+    client = DatabricksClient("https://example.databricks.com", "token", "wh-1", session=session)
+
+    result = client.query_failure_traps(telemetry)
+    assert result.ok
+
+    payload = session.post.call_args.kwargs["json"]
+    assert "prompt" not in str(payload).lower()
+    assert "[redacted]" not in str(payload).lower()
+    assert "***" not in str(payload)
+    assert "statement" in payload
+    assert payload["statement"].startswith("SELECT * FROM dev_failure_traps")
+    assert "parameters" in payload
+
+    manifest = build_handoff_manifest(telemetry, verified_match=result.ok)
+    assert manifest.status_label == "[PARTIAL / REDACTED CONTEXT]"
+    assert manifest.confidence == "partial"
+    assert manifest.is_complete is False
+
+    item = StatusItem("Failure traps", result.ok, result.error or "", context_label=manifest.status_label)
+    assert item.context_label == "[PARTIAL / REDACTED CONTEXT]"