cdx-manager 0.5.7 → 0.6.0

package/README.md

@@ -1,6 +1,6 @@
 # CDX Manager
 
-[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.5.7-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
+[![License](https://img.shields.io/badge/license-MIT-4C8BF5)](LICENSE) ![Version](https://img.shields.io/badge/version-v0.6.0-4C8BF5) ![Python](https://img.shields.io/badge/python-3.9%2B-3776AB?logo=python&logoColor=white)
 
 **Run multiple Codex and Claude sessions from one terminal. Switch between accounts instantly.**
 
@@ -34,10 +34,14 @@ One command to launch any session. Zero auth juggling.
 
 - **Multiple accounts, one tool.** Register as many Codex or Claude sessions as you need. Each one gets its own isolated auth environment — no cross-contamination between accounts.
 - **Instant launch.** `cdx work` opens your "work" session. `cdx personal` opens another. No config files to edit mid-flow.
+- **Quick relaunch.** `cdx last` reopens the most recently launched assistant profile.
 - **Auth guardrails.** `cdx` checks authentication before launching. If a session is not logged in, it tells you exactly what to run — no silent failures.
 - **Usage at a glance.** `cdx status` shows token usage, 5-hour window quota, weekly quota, last-updated timestamps, priority guidance, and the last launched session in one aligned table.
+- **Next-ready notification.** `cdx ready` schedules a native system notification for the next assistant that comes back from cooldown, then returns immediately.
 - **Session control.** Disable a session without deleting it when an account is temporarily out of credits; disabled sessions remain visible and sort last.
 - **Persistent launch settings.** Pin per-session power, permission, and fast-mode preferences once; `cdx` reapplies them on every launch until you unset them.
+- **Launch history.** Inspect recent launches with provider, result, duration, working directory, launch settings, and transcript path.
+- **Update prompts.** Periodic update checks surface `cdx update` directly in the `cdx`, `cdx status`, and launch output when a newer release is available.
 - **Shared handoff context.** Keep a per-workspace Markdown context, or build one from a source session transcript, and install it into another assistant session before switching providers or accounts.
 - **Passive status resolution.** Codex status is read from the local Codex app-server rate-limit API when available, with legacy transcript/history parsing kept as a fallback.
 - **Session transcript capture.** Every launch is recorded to a local log file via `script`, giving you a full terminal transcript for each session.
@@ -127,7 +131,7 @@ For a specific version:
 
 ```bash
 curl -fsSL https://raw.githubusercontent.com/AlexAgo83/cdx-manager/main/install.sh -o install.sh
-CDX_VERSION=v0.5.7 sh install.sh
+CDX_VERSION=v0.6.0 sh install.sh
 ```
 
 From source:
@@ -230,6 +234,18 @@ cdx work
 
 # Check usage across all sessions
 cdx status
+
+# Notify when the next cooling-down assistant is ready
+cdx ready
+```
+
+### Next-Ready Notifications
+
+Use `cdx ready` when every useful assistant is cooling down and you want your terminal back. It is shorthand for `cdx notify --schedule --next-ready`: cdx picks the next known reset, registers a native OS notification, and exits immediately.
+
+```bash
+cdx ready
+cdx ready --refresh
 ```
 
 ### Persistent Launch Settings
@@ -251,6 +267,22 @@ cdx unset work --all
 
 `--power` maps to Codex `model_reasoning_effort` and Claude `--effort`. `--permission` maps to provider-native permission flags. `--fast on` uses low effort when no explicit power is set.
 
+### Launch History
+
+Every interactive `cdx <name>` launch is recorded under `CDX_HOME`, including success/failure, duration, cwd, launch settings, and transcript path.
+
+```bash
+cdx history
+cdx history work
+cdx history work --limit 5
+cdx history work --json
+cdx history --summary
+cdx history --summary --since 7d
+cdx history --summary --from 2026-05-01 --to 2026-05-28
+```
+
+`cdx history --summary` aggregates total time per assistant. Add `--since`, `--from`, or `--to` to focus on a period.
+
 ---
 
 ## All Commands
@@ -271,6 +303,8 @@ cdx unset work --all
 | `cdx config <name> [--json]` | Show persistent launch settings for a session |
 | `cdx set <name> [--power low\|medium\|high\|xhigh\|max] [--permission review\|default\|auto\|full] [--fast on\|off] [--json]` | Persist launch settings for a session |
 | `cdx unset <name> (--power\|--permission\|--fast\|--all) [--json]` | Remove persisted launch settings and fall back to provider defaults |
+| `cdx history [name] [--limit N] [--summary] [--since 7d\|today\|DATE] [--from DATE] [--to DATE] [--json]` | Show recent launch history or aggregate total launch time per assistant, optionally filtered by period |
+| `cdx last [--json]` | Launch the most recent existing session from launch history |
 | `cdx context show\|path\|init\|edit\|clear\|set [text...] [--json]` | Manage the shared Markdown context for the current workspace |
 | `cdx handoff <name> [--json]` | Install the current workspace context into a target session and launch it unless `--json` is used |
 | `cdx handoff <source> <target> [--json]` | Build shared context from the source session's latest launch transcript, install it into the target session, and launch the target unless `--json` is used; supports Codex and Claude targets, including cross-provider handoff |
@@ -281,6 +315,7 @@ cdx unset work --all
 | `cdx doctor [--json]` | Inspect CLI dependencies, CDX_HOME permissions, missing state, orphan profiles, and pending quarantines |
 | `cdx repair [--dry-run] [--force] [--json]` | Plan or apply safe repairs for missing state files, quarantines, and orphan profiles |
 | `cdx update [--check] [--yes] [--json] [--version TAG]` | Update cdx-manager using the installer that matches how it was installed |
+| `cdx ready [--refresh] [--json]` | Schedule an OS notification for the next cooling-down assistant that becomes ready, then return immediately |
 | `cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait for a session reset time or schedule an OS wake-up notification when due |
 | `cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh] [--json]` | Wait until the recommended session is usable, or schedule the next known reset notification |
 | `cdx status [--json] [--refresh]` | Show token usage table for all sessions; JSON returns a versioned payload with structured warnings |
@@ -313,9 +348,12 @@ Commands with machine-readable output:
 - `cdx enable ... --json`
 - `cdx context ... --json`
 - `cdx handoff ... --json`
+- `cdx history ... --json`
+- `cdx last --json`
 - `cdx doctor --json`
 - `cdx repair --json`
 - `cdx update --json`
+- `cdx ready --json`
 - `cdx notify ... --json`
 
 Success payloads follow a shared envelope:
@@ -452,6 +490,7 @@ All session data lives under `CDX_HOME` (default: `~/.cdx/`):
   sessions.json             # Session registry (versioned, all sessions)
   state/
     <encoded-name>.json     # Per-session rehydration state
+    launch_history.jsonl    # Append-only launch history
   profiles/
     <encoded-name>/         # Codex session: CODEX_HOME points here
       log/

package/changelogs/CHANGELOGS_0_6_0.md

@@ -0,0 +1,47 @@
+# Changelog (`0.5.7 -> 0.6.0`)
+
+Release date: 2026-05-28
+
+## Major Highlights
+
+- Added launch history workflows for reviewing, summarizing, and relaunching assistant sessions.
+- Improved `cdx status` guidance with reset-week countdowns, active-session marking, cleaner blocking quota labels, and periodic update notices.
+- Added shortcut commands that reduce routine assistant switching and waiting friction.
+
+## Launch History and Relaunch
+
+- Added `cdx history` to inspect recent assistant launches with provider, result, duration, working directory, launch settings, and transcript path.
+- Added `cdx history --summary` to aggregate assistant time by session.
+- Added period filters for history summaries with `--since`, `--from`, and `--to`.
+- Added `cdx last` to relaunch the most recent existing session from launch history.
+- Skips removed sessions when resolving the last launch target.
+
+## Status and Availability
+
+- Added reset-week countdowns to status output.
+- Hid healthy blocking quota labels so status tables stay focused on actionable quota limits.
+- Marked the active launched session in status and list output.
+- Added `cdx ready` as a shortcut for scheduling the next assistant reset notification.
+- Added update notices to `cdx status`, matching the existing periodic update check behavior.
+- Changed visual update notices to show `Run: cdx update` instead of a release URL.
+
+## CLI Ergonomics
+
+- Curated the main screen next-actions list around the commands users are most likely to run next.
+- Kept release URLs in JSON warning payloads for integrations while making text output directly actionable.
+- Added `cdx last [--json]` to help output and README command documentation.
+
+## Release Metadata and Documentation
+
+- Updated package metadata, CLI version output, README badge, and pinned installer example to `v0.6.0`.
+- Documented `cdx last` and the action-oriented update notices in the README.
+
+## Validation and Regression Coverage
+
+- Added regression coverage for launch history, assistant-time summaries, period filters, active session indicators, `cdx ready`, `cdx last`, and update notices in `cdx status`.
+- Added coverage to ensure visual update notices show `Run: cdx update` without leaking the release URL.
+
+## Validation and Regression Evidence
+
+- `npm run lint`
+- `npm test`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdx-manager",
-  "version": "0.5.7",
+  "version": "0.6.0",
   "description": "Terminal session manager for Codex and Claude accounts.",
   "license": "MIT",
   "author": "Alexandre Agostini",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdx-manager"
-version = "0.5.7"
+version = "0.6.0"
 description = "Terminal session manager for Codex and Claude accounts."
 readme = "README.md"
 requires-python = ">=3.9"

package/src/cli.py

@@ -18,6 +18,8 @@ from .cli_commands import (
     handle_export,
     handle_import,
     handle_handoff,
+    handle_history,
+    handle_last,
     handle_launch,
     handle_login,
     handle_logout,
@@ -52,7 +54,7 @@ from .status_view import (
 )
 from .update_check import check_for_update
 
-VERSION = "0.5.7"
+VERSION = "0.6.0"
 
 
 # ---------------------------------------------------------------------------
@@ -73,6 +75,8 @@ def _print_help(use_color=False):
         f"  {_style('cdx config <name> [--json]', '36', use_color)}",
         f"  {_style('cdx set <name> [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--json]', '36', use_color)}",
         f"  {_style('cdx unset <name> (--power|--permission|--fast|--all) [--json]', '36', use_color)}",
+        f"  {_style('cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]', '36', use_color)}",
+        f"  {_style('cdx last [--json]', '36', use_color)}",
         f"  {_style('cdx handoff <name> [--json]', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target> [--json]', '36', use_color)}",
         f"  {_style('cdx add [provider] <name> [--json]', '36', use_color)}",
@@ -89,6 +93,7 @@ def _print_help(use_color=False):
         f"  {_style('cdx doctor [--json]', '36', use_color)}",
         f"  {_style('cdx repair [--dry-run] [--force] [--json]', '36', use_color)}",
         f"  {_style('cdx update [--check] [--yes] [--json] [--version TAG]', '36', use_color)}",
+        f"  {_style('cdx ready [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify <name> --at-reset [--schedule] [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx notify --next-ready [--schedule] [--refresh] [--json]', '36', use_color)}",
         f"  {_style('cdx <name> [--json]', '36', use_color)}",
@@ -156,8 +161,7 @@ def _update_warning_payload(notice):
 def _update_warning_text(notice):
     if not notice:
         return None
-    suffix = f" {notice['url']}" if notice.get("url") else ""
-    return f"Update available: cdx-manager {notice['latest_version']} (current {VERSION}).{suffix}"
+    return f"Update available: cdx-manager {notice['latest_version']} (current {VERSION}). Run: cdx update"
 
 
 # ---------------------------------------------------------------------------
@@ -227,7 +231,7 @@ def main(argv, options=None):
         "version": VERSION,
         "cwd": options.get("cwd") or os.getcwd(),
         "update_notice": _get_update_notice(service, env, options) if command not in (
-            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "notify", "status", "context", "config", "set", "unset", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
+            "add", "cp", "ren", "rename", "mv", "rmv", "clean", "doctor", "repair", "update", "ready", "notify", "context", "config", "set", "unset", "history", "handoff", "login", "logout", "disable", "enable", "export", "import", "help", "version"
         ) else None,
         "use_color": use_color,
     }
@@ -268,6 +272,11 @@ def main(argv, options=None):
     if command == "update":
         return handle_update(rest, ctx)
 
+    if command == "ready":
+        if any(arg not in ("--refresh", "--json") for arg in rest):
+            raise CdxError("Usage: cdx ready [--refresh] [--json]")
+        return handle_notify(["--next-ready", "--schedule", *rest], ctx)
+
     if command == "notify":
         return handle_notify(rest, ctx)
 
@@ -283,6 +292,12 @@ def main(argv, options=None):
     if command == "unset":
         return handle_unset(rest, ctx)
 
+    if command == "history":
+        return handle_history(rest, ctx)
+
+    if command == "last":
+        return handle_last(rest, ctx)
+
     if command == "handoff":
         return handle_handoff(rest, ctx)
 

package/src/cli_commands.py

@@ -4,7 +4,7 @@ import json
 import os
 import sys
 import time
-from datetime import datetime
+from datetime import datetime, timedelta
 
 from .claude_refresh import _refresh_claude_sessions
 from .cli_render import _dim, _info, _success, _warn
@@ -52,6 +52,8 @@ HANDOFF_USAGE = "Usage: cdx handoff <name> [--json] | cdx handoff <source> <targ
 SET_USAGE = "Usage: cdx set <name> [--power low|medium|high|xhigh|max] [--permission review|default|auto|full] [--fast on|off] [--json]"
 UNSET_USAGE = "Usage: cdx unset <name> (--power|--permission|--fast|--all) [--json]"
 CONFIG_USAGE = "Usage: cdx config <name> [--json]"
+HISTORY_USAGE = "Usage: cdx history [name] [--limit N] [--summary] [--since 7d|today|DATE] [--from DATE] [--to DATE] [--json]"
+LAST_USAGE = "Usage: cdx last [--json]"
 API_SCHEMA_VERSION = 1
 HANDOFF_TRANSCRIPT_CHARS = 120000
 
@@ -76,6 +78,26 @@ def _write_json(ctx, payload):
     ctx["out"](f"{json.dumps(payload, indent=2)}\n")
 
 
+def _update_notice_warning(ctx):
+    notice = ctx.get("update_notice")
+    if not notice:
+        return None
+    return {
+        "code": "update_available",
+        "message": f"Update available: cdx-manager {notice['latest_version']}",
+        "latest_version": notice["latest_version"],
+        "url": notice.get("url"),
+    }
+
+
+def _write_update_notice(ctx):
+    notice = ctx.get("update_notice")
+    if not notice:
+        return
+    text = f"Update available: cdx-manager {notice['latest_version']} (current version installed may be older). Run: cdx update"
+    ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
+
+
 def _format_bytes(value):
     if value is None:
         return "n/a"
@@ -364,6 +386,154 @@ def _parse_config_args(args):
     return {"name": parsed["names"][0], "json": parsed["json"]}
 
 
+def _parse_positive_int(value):
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError) as error:
+        raise CdxError(HISTORY_USAGE) from error
+    if parsed < 1:
+        raise CdxError(HISTORY_USAGE)
+    return parsed
+
+
+def _local_timezone():
+    return datetime.now().astimezone().tzinfo
+
+
+def _parse_datetime_value(value, usage, end_of_day=False):
+    text = str(value or "").strip()
+    if not text:
+        raise CdxError(usage)
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    is_date_only = len(text) == 10 and text[4] == "-" and text[7] == "-"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError as error:
+        raise CdxError(usage) from error
+    if is_date_only and end_of_day:
+        parsed = parsed.replace(hour=23, minute=59, second=59, microsecond=999999)
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=_local_timezone())
+    return parsed.astimezone()
+
+
+def _parse_since_value(value, now, usage):
+    text = str(value or "").strip().lower()
+    if not text:
+        raise CdxError(usage)
+    if text == "today":
+        return now.replace(hour=0, minute=0, second=0, microsecond=0)
+    if text == "yesterday":
+        today = now.replace(hour=0, minute=0, second=0, microsecond=0)
+        return today - timedelta(days=1)
+    unit = text[-1:]
+    amount_text = text[:-1]
+    if unit in ("m", "h", "d", "w") and amount_text.isdigit():
+        amount = int(amount_text)
+        if amount < 1:
+            raise CdxError(usage)
+        multipliers = {
+            "m": timedelta(minutes=amount),
+            "h": timedelta(hours=amount),
+            "d": timedelta(days=amount),
+            "w": timedelta(weeks=amount),
+        }
+        return now - multipliers[unit]
+    return _parse_datetime_value(value, usage, end_of_day=False)
+
+
+def _format_period_datetime(value):
+    if value is None:
+        return None
+    return value.isoformat(timespec="seconds")
+
+
+def _parse_history_period(parsed, now):
+    since = parsed.get("since")
+    from_value = parsed.get("from")
+    to_value = parsed.get("to")
+    if since and from_value:
+        raise CdxError("Usage: cdx history cannot combine --since and --from.")
+    start = _parse_since_value(since, now, HISTORY_USAGE) if since else None
+    if from_value:
+        start = _parse_datetime_value(from_value, HISTORY_USAGE, end_of_day=False)
+    end = _parse_datetime_value(to_value, HISTORY_USAGE, end_of_day=True) if to_value else None
+    if start and end and start.timestamp() > end.timestamp():
+        raise CdxError("Usage: cdx history period start must be before period end.")
+    return {
+        "from": _format_period_datetime(start),
+        "to": _format_period_datetime(end),
+        "from_ts": start.timestamp() if start else None,
+        "to_ts": end.timestamp() if end else None,
+    }
+
+
+def _has_history_period(period):
+    return period.get("from_ts") is not None or period.get("to_ts") is not None
+
+
+def _parse_entry_timestamp(entry):
+    value = entry.get("started_at")
+    if not value:
+        return None
+    text = str(value)
+    if text.endswith("Z"):
+        text = f"{text[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=_local_timezone())
+    return parsed.timestamp()
+
+
+def _filter_history_period(entries, period):
+    if not _has_history_period(period):
+        return entries
+    filtered = []
+    start = period.get("from_ts")
+    end = period.get("to_ts")
+    for entry in entries:
+        timestamp = _parse_entry_timestamp(entry)
+        if timestamp is None:
+            continue
+        if start is not None and timestamp < start:
+            continue
+        if end is not None and timestamp > end:
+            continue
+        filtered.append(entry)
+    return filtered
+
+
+def _public_history_period(period):
+    return {
+        "from": period.get("from"),
+        "to": period.get("to"),
+    }
+
+
+def _parse_history_args(args, now=None):
+    now = now or datetime.now().astimezone()
+    parsed = _parse_flag_args(args, {
+        "--limit": {"key": "limit", "type": "str", "default": 20, "transform": _parse_positive_int},
+        "--summary": {"key": "summary", "type": "bool", "default": False},
+        "--since": {"key": "since", "type": "str", "default": None},
+        "--from": {"key": "from", "type": "str", "default": None},
+        "--to": {"key": "to", "type": "str", "default": None},
+        "--json": {"key": "json", "type": "bool", "default": False},
+    }, HISTORY_USAGE, positionals_key="names", max_positionals=1)
+    period = _parse_history_period(parsed, now)
+    return {
+        "name": parsed["names"][0] if parsed["names"] else None,
+        "limit": parsed["limit"],
+        "summary": parsed["summary"],
+        "period": period,
+        "json": parsed["json"],
+    }
+
+
 def _read_option_value(args, index, usage):
     if index + 1 >= len(args):
         raise CdxError(usage)
@@ -590,6 +760,123 @@ def _format_launch_config(session):
     ])
 
 
+def _format_duration_ms(value):
+    if value is None:
+        return "-"
+    try:
+        amount = int(value)
+    except (TypeError, ValueError):
+        return str(value)
+    if amount < 1000:
+        return f"{amount}ms"
+    seconds = amount / 1000
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes = int(seconds // 60)
+    remaining = int(seconds % 60)
+    return f"{minutes}m{remaining:02d}s"
+
+
+def _summarize_history(entries):
+    by_session = {}
+    for entry in entries:
+        name = entry.get("session_name") or "-"
+        row = by_session.setdefault(name, {
+            "session_name": name,
+            "provider": entry.get("provider") or "-",
+            "launches": 0,
+            "successes": 0,
+            "failures": 0,
+            "duration_ms": 0,
+            "last_started_at": None,
+        })
+        row["launches"] += 1
+        if entry.get("status") == "success":
+            row["successes"] += 1
+        elif entry.get("status") == "failed":
+            row["failures"] += 1
+        try:
+            row["duration_ms"] += int(entry.get("duration_ms") or 0)
+        except (TypeError, ValueError):
+            pass
+        started = entry.get("started_at")
+        if started and (not row["last_started_at"] or started > row["last_started_at"]):
+            row["last_started_at"] = started
+            row["provider"] = entry.get("provider") or row["provider"]
+    return sorted(
+        by_session.values(),
+        key=lambda item: (item["duration_ms"], item.get("last_started_at") or "", item["session_name"]),
+        reverse=True,
+    )
+
+
+def _format_history_period(period):
+    if not _has_history_period(period or {}):
+        return None
+    start = _format_period_display(period.get("from")) or "beginning"
+    end = _format_period_display(period.get("to")) or "now"
+    return f"Period: {start} -> {end}"
+
+
+def _format_period_display(value):
+    if not value:
+        return None
+    try:
+        parsed = datetime.fromisoformat(str(value))
+    except ValueError:
+        return str(value)
+    return parsed.strftime("%Y-%m-%d %H:%M")
+
+
+def _format_history_summary(entries, period=None, use_color=False):
+    from .cli_render import _format_relative_age, _pad_table
+
+    summary = _summarize_history(entries)
+    if not summary:
+        return "No launch history for this period." if _has_history_period(period or {}) else "No launch history."
+    rows = [["SESSION", "PROV.", "LAUNCHES", "OK", "FAIL", "TIME", "LAST"]]
+    for row in summary:
+        rows.append([
+            row["session_name"],
+            row["provider"],
+            str(row["launches"]),
+            str(row["successes"]),
+            str(row["failures"]),
+            _format_duration_ms(row["duration_ms"]),
+            _format_relative_age(row.get("last_started_at")),
+        ])
+    lines = ["Assistant time:"]
+    period_line = _format_history_period(period or {})
+    if period_line:
+        lines.extend([period_line, ""])
+    lines.append(_pad_table(rows))
+    return "\n".join(lines)
+
+
+def _format_history(entries, use_color=False):
+    from .cli_render import _format_relative_age, _pad_table
+
+    if not entries:
+        return "No launch history."
+    rows = [["SESSION", "PROV.", "RESULT", "DURATION", "WHEN", "TRANSCRIPT"]]
+    for entry in entries:
+        transcript_path = entry.get("transcript_path")
+        rows.append([
+            entry.get("session_name") or "-",
+            entry.get("provider") or "-",
+            entry.get("status") or "-",
+            _format_duration_ms(entry.get("duration_ms")),
+            _format_relative_age(entry.get("started_at")),
+            os.path.basename(transcript_path) if transcript_path else "-",
+        ])
+    return "\n".join([
+        "Recent launches:",
+        _pad_table(rows),
+        "",
+        _dim("Full transcript paths and cwd are available with --json.", use_color),
+    ])
+
+
 def handle_set(rest, ctx):
     parsed = _parse_set_args(rest)
     session = ctx["service"]["set_launch_settings"](parsed["name"], parsed["settings"])
@@ -627,6 +914,56 @@ def handle_config(rest, ctx):
     return 0
 
 
+def handle_history(rest, ctx):
+    now_fn = ctx["options"].get("now") or time.time
+    now = datetime.fromtimestamp(now_fn()).astimezone()
+    parsed = _parse_history_args(rest, now=now)
+    has_period = _has_history_period(parsed["period"])
+    limit = 0 if parsed["summary"] or has_period else parsed["limit"]
+    entries = ctx["service"]["get_launch_history"](parsed["name"], limit=limit)
+    entries = _filter_history_period(entries, parsed["period"])
+    if has_period and not parsed["summary"]:
+        entries = entries[:parsed["limit"]]
+    message = (
+        f"Listed launch history for {parsed['name']}"
+        if parsed["name"]
+        else "Listed launch history"
+    )
+    if parsed["json"]:
+        payload = {"history": entries, "period": _public_history_period(parsed["period"])}
+        if parsed["summary"]:
+            payload["summary"] = _summarize_history(entries)
+        _write_json(ctx, _json_success("history", message, **payload))
+        return 0
+    if parsed["summary"]:
+        ctx["out"](f"{_format_history_summary(entries, period=parsed['period'], use_color=ctx['use_color'])}\n")
+        return 0
+    ctx["out"](f"{_format_history(entries, use_color=ctx['use_color'])}\n")
+    return 0
+
+
+def _resolve_last_launch_session(ctx):
+    for entry in ctx["service"]["get_launch_history"](limit=0):
+        name = entry.get("session_name")
+        if not name:
+            continue
+        session = ctx["service"]["get_session"](name)
+        if session:
+            return session
+    raise CdxError("No launch history yet. Run cdx <name> first.")
+
+
+def handle_last(rest, ctx):
+    json_flag, args = _parse_json_flag(rest)
+    if args:
+        raise CdxError(LAST_USAGE)
+    session = _resolve_last_launch_session(ctx)
+    if not json_flag:
+        message = f"Launching last session: {session['name']}"
+        ctx["out"](f"{_info(message, ctx['use_color'])}\n")
+    return handle_launch(session["name"], ctx)
+
+
 def handle_clean(rest, ctx):
     json_flag, args = _parse_json_flag(rest)
     service = ctx["service"]
@@ -926,6 +1263,9 @@ def handle_status(rest, ctx):
         }
         for item in refresh_errors
     ]
+    update_warning = _update_notice_warning(ctx)
+    if update_warning:
+        warnings.append(update_warning)
 
     status_progress = None if parsed["json"] else _make_status_progress(ctx)
     rows = ctx["service"]["get_status_rows"](
@@ -938,6 +1278,7 @@ def handle_status(rest, ctx):
             return 0
         ctx["out"](f"{_format_status_rows(rows, use_color=ctx['use_color'], small=parsed['small'])}\n")
         _write_refresh_warnings(refresh_errors, ctx)
+        _write_update_notice(ctx)
         return 0
 
     row = next((r for r in rows if r["session_name"] == args[0]), None)
@@ -948,6 +1289,7 @@ def handle_status(rest, ctx):
         return 0
     ctx["out"](f"{_format_status_detail(row, use_color=ctx['use_color'])}\n")
     _write_refresh_warnings(refresh_errors, ctx)
+    _write_update_notice(ctx)
     return 0
 
 
@@ -1169,16 +1511,11 @@ def handle_update(rest, ctx):
 
 
 def handle_launch(command, ctx, initial_prompt=None):
-    json_flag = "--json" in ctx["options"].get("raw_args", [])
+    json_flag = "--json" in ctx.get("raw_args", ctx["options"].get("raw_args", []))
     update_notice = ctx.get("update_notice")
     warnings = []
     if update_notice:
-        warnings.append({
-            "code": "update_available",
-            "message": f"Update available: cdx-manager {update_notice['latest_version']}",
-            "latest_version": update_notice["latest_version"],
-            "url": update_notice.get("url"),
-        })
+        warnings.append(_update_notice_warning(ctx))
     session = ctx["service"]["launch_session"](command)
     _ensure_session_authentication(
         session,
@@ -1193,15 +1530,51 @@ def handle_launch(command, ctx, initial_prompt=None):
     message = f"Launching {session['provider']} session {session['name']}"
     if not json_flag:
         ctx["out"](f"{_info(message, ctx['use_color'])}\n")
-        if update_notice:
-            text = f"Update available: cdx-manager {update_notice['latest_version']} (current version installed may be older)."
-            if update_notice.get("url"):
-                text = f"{text} {update_notice['url']}"
-            ctx["out"](f"{_warn(text, ctx['use_color'])}\n")
-    _run_interactive_provider_command(
-        session, "launch", spawn=ctx.get("spawn"), env_override=ctx.get("env"),
-        signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
-    )
+        _write_update_notice(ctx)
+    cwd = ctx.get("cwd") or os.getcwd()
+    runtime_run_id = None
+
+    def runtime_lifecycle(event, info):
+        nonlocal runtime_run_id
+        if event == "started":
+            runtime = ctx["service"]["start_session_runtime"](session["name"], info)
+            runtime_run_id = runtime.get("runId")
+        elif event == "finished" and runtime_run_id:
+            ctx["service"]["finish_session_runtime"](
+                session["name"],
+                runtime_run_id,
+                {"status": "stopped", "returncode": info.get("returncode")},
+            )
+
+    try:
+        run_info = _run_interactive_provider_command(
+            session, "launch", spawn=ctx.get("spawn"), cwd=cwd, env_override=ctx.get("env"),
+            signal_emitter=ctx.get("signal_emitter"), initial_prompt=initial_prompt,
+            lifecycle_callback=runtime_lifecycle,
+        )
+    except CdxError as error:
+        run_info = getattr(error, "run_info", {}) or {}
+        if runtime_run_id:
+            ctx["service"]["finish_session_runtime"](
+                session["name"],
+                runtime_run_id,
+                {"status": "failed", "returncode": run_info.get("returncode")},
+            )
+        if run_info:
+            ctx["service"]["record_launch_history"](session["name"], {
+                "status": "failed",
+                "cwd": cwd,
+                "error": str(error),
+                "exit_code": error.exit_code,
+                **run_info,
+            })
+        raise
+    ctx["service"]["record_launch_history"](session["name"], {
+        "status": "success",
+        "cwd": cwd,
+        "exit_code": 0,
+        **run_info,
+    })
     if json_flag:
         _write_json(ctx, _json_success("launch", message, warnings=warnings, session=ctx["service"]["get_session"](session["name"])))
     return 0

package/src/cli_render.py

@@ -98,6 +98,19 @@ def _dim(text, use_color=False):
     return _style(text, "2", use_color)
 
 
+def _format_launch_text(launch):
+    if not launch:
+        return "default"
+    parts = []
+    if launch.get("power"):
+        parts.append(launch["power"])
+    if launch.get("permission"):
+        parts.append(launch["permission"])
+    if launch.get("fast") is True:
+        parts.append("fast-on")
+    return "/".join(parts) or "default"
+
+
 def format_error(error, env=None, stderr=None):
     return _style(str(error), "31", _should_use_color(env or os.environ, stderr or sys.stderr))
 
@@ -116,40 +129,26 @@ def _format_sessions(service, use_color=False):
     headers = [_style(header, "1", use_color) for header in headers]
     table_rows = []
     for r in rows:
-        parts = [r["name"]]
+        name = f"{r['name']}*" if r.get("active") else r["name"]
+        parts = [name]
         if has_provider:
             parts.append(r.get("provider") or "n/a")
         status = r.get("enabled_status") or ("enabled" if r.get("enabled", True) else "disabled")
         parts.append(_style(status, "2" if status == "disabled" else "32", use_color))
         if has_launch:
             launch = r.get("launch") or {}
-            if launch:
-                launch_text = "/".join([
-                    launch.get("power") or "-",
-                    launch.get("permission") or "-",
-                    "fast-on" if launch.get("fast") is True else "fast-off" if launch.get("fast") is False else "-",
-                ])
-            else:
-                launch_text = "default"
-            parts.append(_dim(launch_text, use_color))
+            parts.append(_dim(_format_launch_text(launch), use_color))
         parts.append(_dim(_format_relative_age(r.get("updated_at")), use_color))
         table_rows.append(parts)
     lines = [_style("Known sessions:", "1", use_color), _pad_table([headers] + table_rows), ""]
     lines += [
         _style("Next actions:", "1", use_color),
-        f"  {_style('cdx add <name>', '36', use_color)}",
-        f"  {_style('cdx <name>', '36', use_color)}",
-        f"  {_style('cdx login <name>', '36', use_color)}",
-        f"  {_style('cdx logout <name>', '36', use_color)}",
-        f"  {_style('cdx config <name>', '36', use_color)}",
+        f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx ready', '36', use_color)}",
         f"  {_style('cdx set <name> --power medium --permission default --fast off', '36', use_color)}",
-        f"  {_style('cdx context show', '36', use_color)}",
-        f"  {_style('cdx handoff <name>', '36', use_color)}",
         f"  {_style('cdx handoff <source> <target>', '36', use_color)}",
-        f"  {_style('cdx disable <name>', '36', use_color)}",
-        f"  {_style('cdx enable <name>', '36', use_color)}",
-        f"  {_style('cdx ren <source> <dest>', '36', use_color)}",
-        f"  {_style('cdx rmv <name>', '36', use_color)}",
-        f"  {_style('cdx status', '36', use_color)}",
+        f"  {_style('cdx history', '36', use_color)}",
+        f"  {_style('cdx help', '36', use_color)}",
+        f"  {_style('cdx update', '36', use_color)}",
     ]
     return "\n".join(lines)

package/src/provider_runtime.py

@@ -277,7 +277,7 @@ def _signal_name(sig):
 
 def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                                       env_override=None, signal_emitter=None,
-                                      initial_prompt=None):
+                                      initial_prompt=None, lifecycle_callback=None):
     spawn = spawn or subprocess.Popen
     spec = (
         _build_launch_spec(session, cwd=cwd, env_override=env_override, initial_prompt=initial_prompt)
@@ -293,11 +293,32 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
             **{k: v for k, v in current_spec.get("options", {}).items() if k != "stdio"},
         )
 
+    start_time = datetime.now(timezone.utc)
+
+    child_pid = None
+
+    def run_info(current_spec, returncode=None):
+        end_time = datetime.now(timezone.utc)
+        return {
+            "started_at": start_time.isoformat().replace("+00:00", "Z"),
+            "ended_at": end_time.isoformat().replace("+00:00", "Z"),
+            "duration_ms": int((end_time - start_time).total_seconds() * 1000),
+            "command": current_spec.get("command"),
+            "args": list(current_spec.get("args") or []),
+            "label": current_spec.get("label"),
+            "transcript_path": current_spec.get("transcript_path"),
+            "pid": child_pid,
+            "returncode": returncode,
+        }
+
     try:
         child = start_child(spec)
     except FileNotFoundError as error:
         spec = _fallback_launch_spec_or_raise(spec, error)
         child = start_child(spec)
+    child_pid = getattr(child, "pid", None) or os.getpid()
+    if lifecycle_callback:
+        lifecycle_callback("started", run_info(spec))
 
     forwarded_signal = None
     handlers = []
@@ -336,6 +357,9 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
         if forwarded_signal is None and child.returncode != 0 and _should_retry_without_transcript(spec):
             spec = _fallback_launch_spec_or_raise(spec)
             child = start_child(spec)
+            child_pid = getattr(child, "pid", None) or os.getpid()
+            if lifecycle_callback:
+                lifecycle_callback("started", run_info(spec))
             child.wait()
     finally:
         if use_emitter:
@@ -352,14 +376,26 @@ def _run_interactive_provider_command(session, action, spawn=None, cwd=None,
                     pass
 
     if forwarded_signal is not None:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} interrupted by {_signal_name(forwarded_signal)} for session {session['name']}",
             _signal_exit_code(forwarded_signal),
         )
+        error.run_info = run_info(spec, returncode=error.exit_code)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
     if child.returncode != 0:
-        raise CdxError(
+        error = CdxError(
             f"{spec['label']} exited with code {child.returncode} for session {session['name']}"
         )
+        error.run_info = run_info(spec, returncode=child.returncode)
+        if lifecycle_callback:
+            lifecycle_callback("finished", error.run_info)
+        raise error
+    info = run_info(spec, returncode=child.returncode)
+    if lifecycle_callback:
+        lifecycle_callback("finished", info)
+    return info
 
 
 def _fallback_launch_spec_or_raise(spec, original_error=None):

package/src/session_service.py

@@ -4,6 +4,7 @@ import json
 import base64
 import sys
 import tempfile
+import uuid
 from datetime import datetime, timezone
 from urllib.parse import quote
 
@@ -28,11 +29,13 @@ RESERVED_SESSION_NAMES = {
     "export",
     "help",
     "handoff",
+    "history",
     "import",
     "login",
     "logout",
     "mv",
     "notify",
+    "ready",
     "repair",
     "ren",
     "rename",
@@ -116,6 +119,24 @@ def _local_now_iso():
     return datetime.now().astimezone().isoformat()
 
 
+def _process_is_running(pid):
+    try:
+        pid = int(pid)
+    except (TypeError, ValueError):
+        return False
+    if pid <= 0:
+        return False
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    except OSError:
+        return False
+    return True
+
+
 def _safe_relpath(path):
     normalized = os.path.normpath(str(path or "").replace("\\", "/")).replace("\\", "/")
     if (
@@ -324,6 +345,32 @@ def create_session_service(options=None):
             raise CdxError(f"Unsupported provider: {value}")
         return value
 
+    def _runtime_is_active(runtime):
+        return (
+            isinstance(runtime, dict)
+            and runtime.get("status") == "running"
+            and _process_is_running(runtime.get("pid"))
+        )
+
+    def _session_runtime(name):
+        state = store["read_session_state"](name)
+        if not state:
+            return None
+        runtime = state.get("runtime")
+        if _runtime_is_active(runtime):
+            return runtime
+        if isinstance(runtime, dict) and runtime.get("status") == "running":
+            store["write_session_state"](name, {
+                **state,
+                "status": "ready",
+                "runtime": {
+                    **runtime,
+                    "status": "stale",
+                    "endedAt": _local_now_iso(),
+                },
+            })
+        return None
+
     def _validate_new_session_name(name):
         if not name:
             raise CdxError("Session name is required")
@@ -585,6 +632,56 @@ def create_session_service(options=None):
             **s, "updatedAt": now, "lastLaunchedAt": now
         })
 
+    def start_session_runtime(name, payload=None):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        state = store["read_session_state"](name)
+        if not state:
+            raise CdxError(f"Session state missing for {name}. Reconnect required.")
+        payload = dict(payload or {})
+        now = _local_now_iso()
+        runtime = {
+            "status": "running",
+            "runId": payload.get("runId") or uuid.uuid4().hex,
+            "startedAt": payload.get("startedAt") or now,
+            "pid": payload.get("pid") or os.getpid(),
+            "command": payload.get("command"),
+            "label": payload.get("label"),
+            "transcriptPath": payload.get("transcript_path") or payload.get("transcriptPath"),
+        }
+        store["write_session_state"](name, {
+            **state,
+            "status": "running",
+            "runtime": runtime,
+        })
+        return runtime
+
+    def finish_session_runtime(name, run_id=None, payload=None):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        state = store["read_session_state"](name)
+        if not state:
+            return None
+        runtime = state.get("runtime") or {}
+        if run_id and runtime.get("runId") != run_id:
+            return runtime
+        payload = dict(payload or {})
+        updated_runtime = {
+            **runtime,
+            "status": payload.get("status") or "stopped",
+            "endedAt": payload.get("endedAt") or _local_now_iso(),
+        }
+        if "returncode" in payload:
+            updated_runtime["returncode"] = payload["returncode"]
+        store["write_session_state"](name, {
+            **state,
+            "status": "ready",
+            "runtime": updated_runtime,
+        })
+        return updated_runtime
+
     def ensure_session_state(name):
         session = store["get_session"](name)
         if not session:
@@ -669,6 +766,25 @@ def create_session_service(options=None):
             raise CdxError(f"Unknown session: {name}")
         return updated
 
+    def record_launch_history(name, payload):
+        session = store["get_session"](name)
+        if not session:
+            raise CdxError(f"Unknown session: {name}")
+        entry = {
+            "schema_version": 1,
+            "session_name": session["name"],
+            "provider": session["provider"],
+            "launch": session.get("launch") or {},
+            **payload,
+        }
+        store["append_launch_history"](entry)
+        return entry
+
+    def get_launch_history(name=None, limit=20):
+        if name and not store["get_session"](name):
+            raise CdxError(f"Unknown session: {name}")
+        return store["list_launch_history"](session_name=name, limit=limit)
+
     def _resolve_session_status(session, force_refresh=False, cache_ttl_seconds=STATUS_CACHE_TTL_SECONDS):
         current_status = session.get("lastStatus")
         if session.get("enabled", True) is False:
@@ -806,6 +922,7 @@ def create_session_service(options=None):
                 "session_name": s["name"],
                 "provider": s["provider"],
                 "enabled": enabled,
+                "active": bool(_session_runtime(s["name"])) if enabled else False,
                 "status": "enabled" if enabled else "disabled",
                 "remaining_5h_pct": row_status.get("remaining_5h_pct") if row_status else None,
                 "remaining_week_pct": row_status.get("remaining_week_pct") if row_status else None,
@@ -839,6 +956,7 @@ def create_session_service(options=None):
             "name": s["name"],
             "provider": s["provider"] if has_multiple else None,
             "enabled": s.get("enabled", True) is not False,
+            "active": bool(_session_runtime(s["name"])) if s.get("enabled", True) is not False else False,
             "enabled_status": "disabled" if s.get("enabled", True) is False else "enabled",
             "status": s.get("lastStatus"),
             "launch": s.get("launch") or {},
@@ -992,6 +1110,8 @@ def create_session_service(options=None):
         "copy_session": copy_session,
         "rename_session": rename_session,
         "launch_session": launch_session,
+        "start_session_runtime": start_session_runtime,
+        "finish_session_runtime": finish_session_runtime,
         "ensure_session_state": ensure_session_state,
         "list_sessions": list_sessions,
         "get_session": get_session,
@@ -999,6 +1119,8 @@ def create_session_service(options=None):
         "set_launch_settings": set_launch_settings,
         "unset_launch_settings": unset_launch_settings,
         "record_status": record_status,
+        "record_launch_history": record_launch_history,
+        "get_launch_history": get_launch_history,
         "update_auth_state": update_auth_state,
         "get_status_rows": get_status_rows,
         "format_list_rows": format_list_rows,

package/src/session_store.py

@@ -105,6 +105,7 @@ def create_session_store(base_dir):
     store_file = os.path.join(base_dir, "sessions.json")
     lock_file = os.path.join(base_dir, ".sessions.lock")
     state_dir = os.path.join(base_dir, "state")
+    launch_history_file = os.path.join(state_dir, "launch_history.jsonl")
 
     def _state_file_path(name):
         return os.path.join(state_dir, f"{_encode(name)}.json")
@@ -259,6 +260,39 @@ def create_session_store(base_dir):
         with _file_lock(lock_file):
             _write_session_state_unlocked(name, state)
 
+    def append_launch_history(entry):
+        with _file_lock(lock_file):
+            _ensure_dir(state_dir)
+            with open(launch_history_file, "a", encoding="utf-8") as handle:
+                handle.write(json.dumps(entry, separators=(",", ":")))
+                handle.write("\n")
+                handle.flush()
+                os.fsync(handle.fileno())
+            _fsync_directory(state_dir)
+
+    def list_launch_history(session_name=None, limit=20):
+        with _file_lock(lock_file):
+            try:
+                with open(launch_history_file, "r", encoding="utf-8") as handle:
+                    lines = handle.readlines()
+            except FileNotFoundError:
+                return []
+            entries = []
+            for line in reversed(lines):
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError as error:
+                    raise CdxError(f"Corrupt JSONL file: {launch_history_file}") from error
+                if session_name and entry.get("session_name") != session_name:
+                    continue
+                entries.append(entry)
+                if limit and len(entries) >= limit:
+                    break
+            return entries
+
     return {
         "list_sessions": list_sessions,
         "get_session": get_session,
@@ -269,4 +303,6 @@ def create_session_store(base_dir):
         "replace_session": replace_session,
         "read_session_state": read_session_state,
         "write_session_state": write_session_state,
+        "append_launch_history": append_launch_history,
+        "list_launch_history": list_launch_history,
     }

package/src/status_view.py

@@ -11,6 +11,7 @@ from .cli_render import (
 
 RESET_COUNTDOWN_SAFETY_SECONDS = 60
 PRIORITY_EMPTY_AVAILABLE_THRESHOLD = 5
+BLOCKING_QUOTA_WARNING_THRESHOLD = 10
 
 
 def _format_reset_time(value):
@@ -42,7 +43,11 @@ def _format_reset_time(value):
         if remaining_minutes == 0:
             return f"in {hours}h"
         return f"in {hours}h {remaining_minutes}m"
-    return value
+    days = int(delta_s // (24 * 60 * 60))
+    hours = int((delta_s % (24 * 60 * 60)) // (60 * 60))
+    if hours == 0:
+        return f"in {days}d"
+    return f"in {days}d {hours}h"
 
 
 def _style_reset_time(value, use_color=False):
@@ -77,7 +82,7 @@ def _format_status_rows(rows, use_color=False, small=False):
     priority = _recommend_priority_sessions(active_rows)
     table_rows = []
     for r in priority + disabled_rows:
-        base = [r["session_name"]]
+        base = [_format_session_name(r)]
         if has_provider:
             base.append(r.get("provider") or "n/a")
         status = r.get("status") or ("enabled" if r.get("enabled", True) else "disabled")
@@ -133,6 +138,10 @@ def _format_current_session_line(rows):
     return f"Current: last launched {row['session_name']} ({label})."
 
 
+def _format_session_name(row):
+    return f"{row['session_name']}*" if row.get("active") else row["session_name"]
+
+
 def _recommend_priority_sessions(rows):
     if not rows:
         return []
@@ -166,6 +175,9 @@ def _format_blocking_quota(row):
     remaining_week = row.get("remaining_week_pct")
     if remaining_5h is None and remaining_week is None:
         return "?"
+    known = [value for value in (remaining_5h, remaining_week) if value is not None]
+    if known and min(known) > BLOCKING_QUOTA_WARNING_THRESHOLD:
+        return "-"
     if remaining_5h is None:
         return "WEEK"
     if remaining_week is None:
@@ -284,7 +296,7 @@ def _now_timestamp():
 
 def _format_status_detail(row, use_color=False):
     lines = [
-        f"{_style('Session:', '1', use_color)} {row['session_name']}",
+        f"{_style('Session:', '1', use_color)} {_format_session_name(row)}",
         f"{_style('Provider:', '1', use_color)} {row.get('provider') or 'n/a'}",
         f"{_style('Status:', '1', use_color)} {_style(row.get('status') or ('enabled' if row.get('enabled', True) else 'disabled'), '2' if row.get('enabled', True) is False else '32', use_color)}",
         f"{_style('Available:', '1', use_color)} {_style_pct(row.get('available_pct'), use_color)}",