nexo-brain 2.6.12 → 2.6.14

package/src/evolution_cycle.py

@@ -275,19 +275,19 @@ def build_evolution_prompt(week_data: dict, objective: dict) -> str:
     if mode == "review":
         mode_desc = "review-only, nothing executes automatically"
         safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/"
-        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, cognitive.py, knowledge_graph.py, tools_*.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md"
+        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, cognitive.py, knowledge_graph.py, tools_*.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md, AGENTS.md"
     elif mode == "managed":
         mode_desc = f"owner-managed, max {max_auto} auto-applied changes with rollback and followups"
         safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/, ~/.nexo/brain/, NEXO_CODE/src, repo bin/docs/templates/tests"
-        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md, personality.md, user-profile.md"
+        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md, AGENTS.md, personality.md, user-profile.md"
     elif mode == "public_core":
         mode_desc = "public core contribution via isolated checkout and Draft PR"
         safe_zones = "isolated public repo checkout only"
-        immutable_files = "personal runtime, ~/.nexo/**, local DBs/logs, CLAUDE.md, user-profile.md"
+        immutable_files = "personal runtime, ~/.nexo/**, local DBs/logs, CLAUDE.md, AGENTS.md, user-profile.md"
     else:
         mode_desc = f"public auto, max {max_auto} auto-applied changes in personal safe zones"
         safe_zones = "~/.nexo/scripts/, ~/.nexo/plugins/"
-        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, cognitive.py, knowledge_graph.py, tools_*.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md"
+        immutable_files = "db.py, server.py, plugin_loader.py, storage_router.py, cognitive.py, knowledge_graph.py, tools_*.py, nexo-watchdog.sh, evolution_cycle.py, CLAUDE.md, AGENTS.md"
 
     prompt = f"""You are NEXO Evolution — the weekly self-improvement cycle.
 

package/src/hooks/session-start.sh

@@ -173,6 +173,22 @@ if os.path.exists(audit_file):
     except Exception:
         pass
 
+# Evolution status
+evolution_file = os.path.join(nexo_home, 'brain', 'evolution-objective.json')
+if os.path.exists(evolution_file):
+    try:
+        evo = json.load(open(evolution_file))
+        lines.append('## Evolution')
+        lines.append(f\"Enabled: {bool(evo.get('evolution_enabled', True))}\")
+        lines.append(f\"Mode: {evo.get('evolution_mode', 'auto')}\")
+        lines.append(f\"Last evolution: {evo.get('last_evolution', 'never')}\")
+        lines.append(f\"Total evolutions: {evo.get('total_evolutions', 0)}\")
+        if evo.get('disabled_reason'):
+            lines.append(f\"Disabled reason: {evo.get('disabled_reason')}\")
+        lines.append('')
+    except Exception:
+        pass
+
 print('\n'.join(lines))
 " > "$BRIEFING_FILE" 2>/dev/null
 

package/src/plugins/schedule.py

@@ -56,21 +56,20 @@ def handle_schedule_status(hours: int = 24, cron_id: str = '') -> str:
 
 def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
                         interval_seconds: int = 0, description: str = '',
-                        script_type: str = 'auto') -> str:
+                        script_type: str = 'auto', keep_alive: bool = False) -> str:
     """Add a new personal cron job. Generates and installs the LaunchAgent (macOS) or systemd timer (Linux).
 
     Args:
         cron_id: Unique ID for this cron (e.g. 'my-backup', 'report-daily'). Must be lowercase with hyphens.
         script: Path to the script to run (absolute or relative to NEXO_HOME/scripts/).
         schedule: Time-based schedule as 'HH:MM' (daily) or 'HH:MM:weekday' (e.g. '08:00:1' for Monday 8AM). Mutually exclusive with interval_seconds.
-        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule.
+        interval_seconds: Run every N seconds (e.g. 300 for every 5 min). Mutually exclusive with schedule/keep_alive.
         description: What this cron does (for logs and status).
         script_type: 'auto' (default), 'python', 'shell', 'node', or 'php'.
+        keep_alive: Run as a daemon/keep-alive service instead of a timer.
     """
     if not cron_id or not script:
         return "ERROR: cron_id and script are required."
-    if not schedule and not interval_seconds:
-        return "ERROR: either schedule (e.g. '08:00') or interval_seconds (e.g. 300) is required."
 
     nexo_home = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
     script_path = Path(script)
@@ -82,6 +81,11 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
     script_meta = parse_inline_metadata(script_path)
     detected_runtime = classify_runtime(script_path, script_meta)
     declared = get_declared_schedule(script_meta, script_meta.get("name", script_path.stem))
+    keep_alive = bool(keep_alive or declared.get("schedule_type") == "keep_alive")
+
+    if sum(bool(value) for value in [schedule, interval_seconds, keep_alive]) != 1:
+        return "ERROR: choose exactly one schedule mode: schedule, interval_seconds, or keep_alive."
+
     script_type = (script_type or "auto").strip().lower()
     if script_type == "auto":
         script_type = detected_runtime if detected_runtime != "unknown" else "python"
@@ -102,6 +106,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     elif system == "Linux":
@@ -114,6 +119,7 @@ def handle_schedule_add(cron_id: str, script: str, schedule: str = '',
             description or script_meta.get("description", ""),
             script_type,
             nexo_home,
+            keep_alive=keep_alive,
             declared=declared,
         )
     else:
@@ -134,7 +140,7 @@ def _runtime_command(script_type: str) -> str:
     return "python3"
 
 
-def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path=""):
+def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds, description, script_type, label="", plist_path="", keep_alive: bool = False):
     init_db()
     script_meta = parse_inline_metadata(Path(script_path))
     runtime = classify_runtime(Path(script_path), script_meta)
@@ -148,7 +154,11 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
         source="filesystem",
         has_inline_metadata=bool(script_meta),
     )
-    if interval_seconds:
+    if keep_alive:
+        schedule_type = "keep_alive"
+        schedule_value = "true"
+        schedule_label = "keep alive"
+    elif interval_seconds:
         schedule_type = "interval"
         schedule_value = str(interval_seconds)
         schedule_label = f"every {interval_seconds}s"
@@ -174,7 +184,7 @@ def _register_schedule_metadata(cron_id, script_path, schedule, interval_seconds
 
 
 def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                     description, script_type, nexo_home, *, declared: dict | None = None):
+                     description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and load a macOS LaunchAgent."""
     import plistlib
 
@@ -201,7 +211,9 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         },
     }
 
-    if interval_seconds:
+    if keep_alive:
+        plist["KeepAlive"] = True
+    elif interval_seconds:
         plist["StartInterval"] = interval_seconds
     elif schedule:
         parts = schedule.split(":")
@@ -211,7 +223,7 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         plist["StartCalendarInterval"] = cal
 
     declared = declared or {}
-    if declared.get("run_on_boot"):
+    if declared.get("run_on_boot") or (keep_alive and "run_on_boot" not in declared):
         plist["RunAtLoad"] = True
 
     with open(plist_path, "wb") as f:
@@ -228,13 +240,20 @@ def _add_launchagent(cron_id, script_path, wrapper_path, schedule, interval_seco
         script_type,
         label=label,
         plist_path=str(plist_path),
+        keep_alive=keep_alive,
     )
 
-    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{' Schedule: ' + schedule if schedule else f' Interval: {interval_seconds}s'}"
+    if keep_alive:
+        detail = " KeepAlive daemon"
+    elif schedule:
+        detail = f" Schedule: {schedule}"
+    else:
+        detail = f" Interval: {interval_seconds}s"
+    return f"Cron '{cron_id}' installed at {plist_path} and loaded.{detail}"
 
 
 def _add_systemd_timer(cron_id, script_path, wrapper_path, schedule, interval_seconds,
-                       description, script_type, nexo_home, *, declared: dict | None = None):
+                       description, script_type, nexo_home, *, keep_alive: bool = False, declared: dict | None = None):
     """Create and enable a systemd user timer (Linux)."""
     unit_dir = Path.home() / ".config" / "systemd" / "user"
     unit_dir.mkdir(parents=True, exist_ok=True)
@@ -257,9 +276,46 @@ Environment=NEXO_PERSONAL_CRON_ID={cron_id}
     service_path = unit_dir / f"nexo-{cron_id}.service"
     service_path.write_text(service_content)
 
-    # Timer unit
     declared = declared or {}
 
+    if keep_alive:
+        service_content = f"""[Unit]
+Description=NEXO daemon: {description or cron_id}
+
+[Service]
+Type=simple
+ExecStart={exec_cmd}
+Restart=always
+RestartSec=10
+Environment=NEXO_HOME={nexo_home}
+Environment=HOME={Path.home()}
+Environment={PERSONAL_SCHEDULE_MANAGED_ENV}=1
+Environment=NEXO_PERSONAL_CRON_ID={cron_id}
+
+[Install]
+WantedBy=default.target
+"""
+        service_path = unit_dir / f"nexo-{cron_id}.service"
+        service_path.write_text(service_content)
+
+        subprocess.run(["systemctl", "--user", "daemon-reload"], capture_output=True)
+        subprocess.run(["systemctl", "--user", "enable", "--now", f"nexo-{cron_id}.service"], capture_output=True)
+
+        _register_schedule_metadata(
+            cron_id,
+            script_path,
+            schedule,
+            interval_seconds,
+            description,
+            script_type,
+            label=f"nexo-{cron_id}",
+            plist_path="",
+            keep_alive=True,
+        )
+
+        return f"Cron '{cron_id}' installed as KeepAlive systemd service and enabled. Service: {service_path}"
+
+    # Timer unit
     if interval_seconds:
         timer_spec = f"OnUnitActiveSec={interval_seconds}s"
         if declared.get("run_on_boot") or not declared.get("required"):
@@ -301,6 +357,7 @@ WantedBy=timers.target
         script_type,
         label=f"nexo-{cron_id}",
         plist_path="",
+        keep_alive=False,
     )
 
     return f"Cron '{cron_id}' installed as systemd timer and enabled. Service: {service_path}, Timer: {timer_path}"

package/src/script_registry.py

@@ -32,6 +32,16 @@ _IGNORED_FILES = {
 }
 _IGNORED_DIRS = {"deep-sleep", "__pycache__"}
 
+_LEGACY_WAKE_RECOVERY_METADATA = [
+    "# nexo: name=nexo-wake-recovery",
+    "# nexo: description=Recover interval LaunchAgents after macOS sleep/wake gaps",
+    "# nexo: runtime=shell",
+    "# nexo: cron_id=wake-recovery",
+    "# nexo: schedule_required=true",
+    "# nexo: recovery_policy=restart_daemon",
+    "# nexo: run_on_boot=true",
+]
+
 # Forbidden patterns — direct DB access from personal scripts
 _FORBIDDEN_PATTERNS = [
     re.compile(r"\bsqlite3\b"),
@@ -77,6 +87,33 @@ def get_scripts_dir() -> Path:
     return NEXO_HOME / "scripts"
 
 
+def _apply_legacy_personal_script_backfills() -> None:
+    """Backfill metadata for known legacy personal scripts shipped before the registry existed."""
+    scripts_dir = get_scripts_dir()
+    wake_recovery = scripts_dir / "nexo-wake-recovery.sh"
+    if not wake_recovery.is_file():
+        return
+
+    try:
+        text = wake_recovery.read_text()
+    except Exception:
+        return
+
+    if "# nexo:" in "\n".join(text.splitlines()[:25]):
+        return
+    if "Wake Recovery" not in text:
+        return
+
+    lines = text.splitlines(keepends=True)
+    head: list[str] = []
+    start = 0
+    if lines and lines[0].startswith("#!"):
+        head.append(lines[0])
+        start = 1
+    head.extend([line + "\n" for line in _LEGACY_WAKE_RECOVERY_METADATA])
+    wake_recovery.write_text("".join(head + lines[start:]))
+
+
 def load_core_script_names() -> set[str]:
     """Load script names from crons/manifest.json (these are core, not personal)."""
     names: set[str] = set()
@@ -279,6 +316,11 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
                 "cron_id": cron_id,
             }
 
+    def _effective_run_on_boot(policy: str) -> bool:
+        if "run_on_boot" in metadata:
+            return run_on_boot
+        return policy == "restart_daemon"
+
     def _effective_run_on_wake(policy: str) -> bool:
         if "run_on_wake" in metadata:
             return run_on_wake
@@ -379,12 +421,29 @@ def get_declared_schedule(metadata: dict, default_name: str = "") -> dict:
             "schedule": schedule_raw,
             "interval_seconds": 0,
             "recovery_policy": recovery_policy_raw or "catchup",
-            "run_on_boot": run_on_boot,
+            "run_on_boot": _effective_run_on_boot(recovery_policy_raw or "catchup"),
             "run_on_wake": _effective_run_on_wake(recovery_policy_raw or "catchup"),
             "idempotent": _effective_idempotent(recovery_policy_raw or "catchup"),
             "max_catchup_age": max_catchup_age or (14 * 86400 if weekday is not None else 48 * 3600),
         }
 
+    if required and recovery_policy_raw == "restart_daemon":
+        return {
+            "required": required,
+            "valid": True,
+            "cron_id": cron_id,
+            "schedule_type": "keep_alive",
+            "schedule_value": "true",
+            "schedule_label": "keep alive",
+            "schedule": "",
+            "interval_seconds": 0,
+            "recovery_policy": "restart_daemon",
+            "run_on_boot": _effective_run_on_boot("restart_daemon"),
+            "run_on_wake": _effective_run_on_wake("restart_daemon"),
+            "idempotent": _effective_idempotent("restart_daemon"),
+            "max_catchup_age": max_catchup_age,
+        }
+
     return {
         "required": required,
         "valid": not required,
@@ -416,6 +475,7 @@ def _script_entry(path: Path, meta: dict, *, is_core: bool, classification: str,
 
 def classify_scripts_dir() -> dict:
     """Classify every file in NEXO_HOME/scripts into personal/core/ignored/non-script buckets."""
+    _apply_legacy_personal_script_backfills()
     scripts_dir = get_scripts_dir()
     if not scripts_dir.is_dir():
         return {"scripts_dir": str(scripts_dir), "entries": [], "summary": {}}
@@ -927,6 +987,7 @@ def ensure_personal_schedules(*, dry_run: bool = False) -> dict:
             interval_seconds=declared.get("interval_seconds", 0),
             description=script.get("description", ""),
             script_type=script.get("runtime", "auto"),
+            keep_alive=declared.get("schedule_type") == "keep_alive",
         )
         target = report["repaired" if existing else "created"]
         target.append({

package/src/scripts/deep-sleep/collect.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 Deep Sleep v2 -- Phase 1: Collect all context for overnight analysis.
 
 Gathers transcripts, DB data, logs, and discovered files into a single
-plain-text context file that subsequent phases read via Claude's Read tool.
+plain-text context file that subsequent phases read via the configured
+automation backend.
 
 Environment variables:
   NEXO_HOME  -- root of the NEXO installation (default: ~/.nexo)
@@ -52,22 +53,43 @@ def _redact_sensitive(text: str) -> str:
     return _SENSITIVE_PATTERNS.sub('[REDACTED]', text)
 
 
-# ── Transcript collection (kept from collect_transcripts.py) ──────────────
+# ── Transcript collection (Claude Code + Codex) ────────────────────────────
 
 
-def find_session_dirs() -> list[Path]:
-    """Find all Claude Code project directories that contain .jsonl files."""
+def _session_identifier(client: str, session_file: str) -> str:
+    return f"{client}:{session_file}"
+
+
+def find_claude_session_files() -> list[Path]:
+    """Find Claude Code session JSONL files under ~/.claude/projects."""
     claude_dir = Path.home() / ".claude" / "projects"
     if not claude_dir.exists():
         return []
-    dirs = set()
-    for jsonl in claude_dir.rglob("*.jsonl"):
-        dirs.add(jsonl.parent)
-    return list(dirs)
+    return sorted(claude_dir.rglob("*.jsonl"))
+
+
+def find_codex_session_files() -> list[Path]:
+    """Find Codex session JSONL files under ~/.codex/sessions and archived_sessions."""
+    roots = [
+        Path.home() / ".codex" / "sessions",
+        Path.home() / ".codex" / "archived_sessions",
+    ]
+    files: list[Path] = []
+    seen: set[str] = set()
+    for root in roots:
+        if not root.exists():
+            continue
+        for jsonl in sorted(root.rglob("*.jsonl")):
+            key = jsonl.name
+            if key in seen:
+                continue
+            seen.add(key)
+            files.append(jsonl)
+    return files
 
 
-def extract_session(jsonl_path: Path) -> dict | None:
-    """Extract clean transcript from a session JSONL file."""
+def extract_claude_session(jsonl_path: Path) -> dict | None:
+    """Extract clean transcript from a Claude Code JSONL session."""
     messages = []
     tool_uses = []
     user_msg_count = 0
@@ -136,13 +158,99 @@ def extract_session(jsonl_path: Path) -> dict | None:
         return None
 
     return {
-        "session_file": jsonl_path.name,
+        "client": "claude_code",
+        "session_file": _session_identifier("claude_code", jsonl_path.name),
+        "display_name": jsonl_path.name,
+        "session_path": str(jsonl_path),
+        "message_count": len(messages),
+        "user_message_count": user_msg_count,
+        "tool_use_count": len(tool_uses),
+        "messages": messages,
+        "tool_uses": tool_uses,
+        "source": "claude_projects",
+    }
+
+
+def extract_codex_session(jsonl_path: Path) -> dict | None:
+    """Extract clean transcript from a Codex JSONL session."""
+    messages = []
+    tool_uses = []
+    user_msg_count = 0
+    session_meta: dict = {}
+
+    try:
+        with open(jsonl_path, "r") as f:
+            for line_no, line in enumerate(f, 1):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                item_type = d.get("type")
+                payload = d.get("payload", {})
+
+                if item_type == "session_meta" and isinstance(payload, dict):
+                    session_meta = payload
+                    continue
+
+                if item_type == "event_msg" and isinstance(payload, dict) and payload.get("type") == "user_message":
+                    content = str(payload.get("message", "") or "").strip()
+                    if not content or content.startswith("<environment_context>"):
+                        continue
+                    messages.append({
+                        "role": "user",
+                        "index": line_no,
+                        "text": _redact_sensitive(content[:5000]),
+                    })
+                    user_msg_count += 1
+                    continue
+
+                if item_type == "response_item" and isinstance(payload, dict):
+                    response_type = payload.get("type")
+                    role = payload.get("role")
+                    if response_type == "message" and role == "assistant":
+                        text_parts = []
+                        for block in payload.get("content", []) or []:
+                            if isinstance(block, dict) and block.get("type") == "output_text":
+                                text_parts.append(str(block.get("text", "")))
+                        combined = "\n".join(part for part in text_parts if part).strip()
+                        if combined:
+                            messages.append({
+                                "role": "assistant",
+                                "index": line_no,
+                                "text": _redact_sensitive(combined[:5000]),
+                            })
+                    elif response_type == "function_call":
+                        tool_uses.append({
+                            "tool": payload.get("name", ""),
+                            "input_keys": [],
+                            "file": _redact_sensitive(str(payload.get("arguments", ""))[:100]),
+                        })
+
+    except Exception as e:
+        print(f"  [collect] Error reading {jsonl_path}: {e}", file=sys.stderr)
+        return None
+
+    if user_msg_count < MIN_USER_MESSAGES:
+        return None
+
+    return {
+        "client": "codex",
+        "session_file": _session_identifier("codex", jsonl_path.name),
+        "display_name": jsonl_path.name,
         "session_path": str(jsonl_path),
         "message_count": len(messages),
         "user_message_count": user_msg_count,
         "tool_use_count": len(tool_uses),
         "messages": messages,
-        "tool_uses": tool_uses
+        "tool_uses": tool_uses,
+        "source": session_meta.get("source", "codex"),
+        "cwd": session_meta.get("cwd", ""),
+        "originator": session_meta.get("originator", ""),
+        "session_uid": session_meta.get("id", ""),
     }
 
 
@@ -156,17 +264,22 @@ def collect_transcripts_since(since_iso: str, until_iso: str = "") -> list[dict]
     until_dt = datetime.fromisoformat(until_iso) if until_iso else datetime.now()
 
     sessions = []
-    for sdir in find_session_dirs():
-        for f in sdir.glob("*.jsonl"):
-            try:
-                mtime = datetime.fromtimestamp(f.stat().st_mtime)
-            except OSError:
-                continue
-            if since_dt < mtime <= until_dt:
-                session = extract_session(f)
-                if session:
-                    session["modified"] = mtime.isoformat()
-                    sessions.append(session)
+    transcript_files: list[tuple[str, Path]] = [
+        ("claude_code", path) for path in find_claude_session_files()
+    ] + [
+        ("codex", path) for path in find_codex_session_files()
+    ]
+    for client, session_file in transcript_files:
+        try:
+            mtime = datetime.fromtimestamp(session_file.stat().st_mtime)
+        except OSError:
+            continue
+        if not (since_dt < mtime <= until_dt):
+            continue
+        session = extract_codex_session(session_file) if client == "codex" else extract_claude_session(session_file)
+        if session:
+            session["modified"] = mtime.isoformat()
+            sessions.append(session)
     sessions.sort(key=lambda s: s["modified"])
     return sessions
 
@@ -353,6 +466,9 @@ def format_transcripts(sessions: list[dict]) -> str:
     for i, session in enumerate(sessions):
         lines.append(f"\n{'─' * 60}")
         lines.append(f"SESSION {i + 1}: {session['session_file']}")
+        lines.append(f"Client: {session.get('client', 'unknown')}")
+        if session.get("source"):
+            lines.append(f"Source: {session['source']}")
         lines.append(f"Modified: {session['modified']}")
         lines.append(f"Messages: {session['message_count']}, Tool uses: {session['tool_use_count']}")
         lines.append(f"{'─' * 60}")
@@ -460,18 +576,27 @@ def main():
 
     # Individual session files
     session_files_written = []
+    session_txt_map = {}
     total_size = len(shared_text.encode("utf-8"))
     for i, session in enumerate(sessions):
-        sid_short = session["session_file"].replace(".jsonl", "")[:20]
+        raw_id = session["session_file"].replace(".jsonl", "").replace(":", "-")
+        sid_short = raw_id[:30]
         filename = f"session-{i+1:02d}-{sid_short}.txt"
         session_path = date_dir / filename
 
         lines = [
             f"Session: {session['session_file']}",
+            f"Display name: {session.get('display_name', session['session_file'])}",
+            f"Client: {session.get('client', 'unknown')}",
+            f"Source: {session.get('source', 'unknown')}",
             f"Modified: {session['modified']}",
             f"Messages: {session['message_count']}, Tool uses: {session['tool_use_count']}",
             f"{'─' * 60}",
         ]
+        if session.get("cwd"):
+            lines.insert(4, f"CWD: {session['cwd']}")
+        if session.get("originator"):
+            lines.insert(4, f"Originator: {session['originator']}")
         for msg in session["messages"]:
             role = "USER" if msg["role"] == "user" else "AGENT"
             idx = msg.get("index", "?")
@@ -487,6 +612,7 @@ def main():
         session_text = "\n".join(lines)
         session_path.write_text(session_text, encoding="utf-8")
         session_files_written.append(filename)
+        session_txt_map[session["session_file"]] = filename
         total_size += len(session_text.encode("utf-8"))
         print(f"  {filename}: {len(session_text) / 1024:.0f} KB")
 
@@ -508,6 +634,18 @@ def main():
         "sessions_found": len(sessions),
         "session_files": [s["session_file"] for s in sessions],
         "session_txt_files": session_files_written,
+        "session_txt_map": session_txt_map,
+        "session_manifest": [
+            {
+                "session_id": s["session_file"],
+                "display_name": s.get("display_name", s["session_file"]),
+                "client": s.get("client", "unknown"),
+                "source": s.get("source", ""),
+                "session_path": s.get("session_path", ""),
+                "session_txt_file": session_txt_map.get(s["session_file"], ""),
+            }
+            for s in sessions
+        ],
         "total_messages": sum(s["message_count"] for s in sessions),
         "total_tool_uses": sum(s["tool_use_count"] for s in sessions),
         "followups_active": len(followups),