[codex-analytics] add protocol-native item timestamps

## Summary
- Fetch remote plugin detail before sending the uninstall request.
- Use the detail response to derive the marketplace namespace and plugin
name for cache cleanup.
- Stop the uninstall before the backend POST if detail lookup fails, so
backend state and local cache state do not diverge.

## Testing
- `just fmt`
- `cargo test -p codex-app-server plugin_uninstall`
- `cargo test -p codex-core-plugins`
- `git diff --check`

.codex/skills/codex-issue-digest/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: codex-issue-digest
+description: Run a GitHub issue digest for openai/codex by feature-area labels, all areas, and configurable time windows. Use when asked to summarize recent Codex bug reports or enhancement requests, especially for owner-specific labels such as tui, exec, app, or similar areas.
+---
+
+# Codex Issue Digest
+
+## Objective
+
+Produce a headline-first, insight-oriented digest of `openai/codex` issues for the requested feature-area labels over the previous 24 hours by default. Honor a different duration when the user asks for one, for example "past week" or "48 hours". Default to a summary-only response; include details only when requested.
+
+Include only issues that currently have `bug` or `enhancement` plus at least one requested owner label. If the user asks for all areas or all labels, collect `bug`/`enhancement` issues across all labels.
+
+## Inputs
+
+- Feature-area labels, for example `tui exec`
+- `all areas` / `all labels` to scan all current feature labels
+- Optional repo override, default `openai/codex`
+- Optional time window, default previous 24 hours; examples: `48h`, `7d`, `1w`, `past week`
+
+## Workflow
+
+1. Run the collector from a current Codex repo checkout:
+
+```bash
+python3 .codex/skills/codex-issue-digest/scripts/collect_issue_digest.py --labels tui exec --window-hours 24
+```
+
+Use `--window "past week"` or `--window-hours 168` when the user asks for a non-default duration. Use `--all-labels` when the user says all areas or all labels.
+
+2. Use the JSON as the source of truth. It includes new issues, new issue comments, new reactions/upvotes, current labels, current reaction counts, model-ready `summary_inputs`, and detailed `digest_rows`.
+3. Choose the output mode from the user's request:
+   - Default mode: start the report with `## Summary` and do not emit `## Details`.
+   - Details-upfront mode: if the user asks for details, a table, a full digest, "include details", or similar, start with `## Summary`, then include `## Details`.
+   - Follow-up details mode: if the user asks for more detail after a summary-only digest, produce `## Details` from the existing collector JSON when it is still available; otherwise rerun the collector.
+4. In `## Summary`, write a headline-first executive summary:
+   - The first nonblank line under `## Summary` must be a single-line headline or judgment, not a bullet. It should be useful even if the reader stops there.
+   - On quiet days, prefer exactly: `No major issues reported by users.` Use this when there are no elevated rows, no newly repeated theme, and nothing that needs owner action.
+   - When users are surfacing notable issues, make the headline name the count or theme, for example `Two issues are being surfaced by users:`.
+   - Immediately under an active headline, list only the issues or themes driving attention, ordered by importance. Start each line with the row's `attention_marker` when present, then a concise owner-readable description and inline issue refs.
+   - Treat `🔥🔥` as headline-worthy and `🔥` as elevated. Do not add fire emoji yourself; only copy the row's `attention_marker`.
+   - Keep any extra summary detail after the headline to 1-3 terse lines, only when it adds a decision-relevant caveat, repeated theme, or owner action.
+   - Do not include routine counts, broad stats, or low-signal table summaries in `## Summary` unless they change the headline. Put metadata and optional counts in `## Details` or the footer.
+   - In default mode, end the report with a concise prompt such as `Want details? I can expand this into the issue table.` Keep this separate from the summary headline so the headline stays clean.
+   - Cluster and name themes yourself from `summary_inputs`; the collector intentionally does not hard-code issue categories.
+   - Use a cluster only when the issues genuinely share the same product problem. If several issues merely share a broad platform or label, describe them individually.
+   - Do not omit a repeated theme just because its individual issues fall below the details table cutoff. Several similar reports should be called out as a repeated customer concern.
+   - For single-issue rows, summarize the concern directly instead of calling it a cluster.
+   - Use inline numbered issue links from each relevant row's `ref_markdown`.
+   - Example quiet summary:
+
+```markdown
+## Summary
+No major issues reported by users.
+
+Source: collector v4, git `abc123def456`, window `2026-04-27T00:00:00Z` to `2026-04-28T00:00:00Z`.
+Want details? I can expand this into the issue table.
+```
+
+   - Example active summary:
+
+```markdown
+## Summary
+Two issues are being surfaced by users:
+🔥🔥 Terminal launch hangs on startup [1](https://github.com/openai/codex/issues/123)
+🔥 Resume switches model providers unexpectedly [2](https://github.com/openai/codex/issues/456)
+
+Source: collector v4, git `abc123def456`, window `2026-04-27T00:00:00Z` to `2026-04-28T00:00:00Z`.
+Want details? I can expand this into the issue table.
+```
+5. In `## Details`, when details are requested, include a compact table only when useful:
+   - Prefer rows from `digest_rows`; include a `Refs` column using each row's `ref_markdown`.
+   - Keep the table short; omit low-signal rows when the summary already covers them.
+   - Use compact columns such as marker, area, type, description, interactions, and refs.
+   - The `Description` cell should be a short owner-readable phrase. Use row `description`, title, body excerpts, and recent comments, but do not mechanically copy the raw GitHub issue title when it contains incidental details.
+   - A clear quiet/no-concern sentence when there is no meaningful signal.
+6. Use the JSON `attention_marker` exactly. It is empty for normal rows, `🔥` for elevated rows, and `🔥🔥` for very high-attention rows. The actual cutoffs are in `attention_thresholds`.
+7. Use inline numbered references where a row or bullet points to issues, for example `Compaction bugs [1](https://github.com/openai/codex/issues/123), [2](https://github.com/openai/codex/issues/456)`. Do not add a separate footnotes section.
+8. Label `interactions` as `Interactions`; it counts posts/comments/reactions during the requested window, not unique people.
+9. Mention the collector `script_version`, repo checkout `git_head`, and time window in one compact source line. In default mode, put this before the details prompt so the final line still asks whether the user wants details. In details-upfront mode, it can be the footer.
+
+## Reaction Handling
+
+The collector uses GitHub reactions endpoints, which include `created_at`, to count reactions created during the digest window for hydrated issues. It reports both in-window reaction counts and current reaction totals. Treat current reaction totals as standing engagement, and treat `new_reactions` / `new_upvotes` as windowed activity.
+
+By default, the collector fetches issue comments with `since=<window start>` and caps the number of comment pages per issue. This keeps very long historical threads from dominating a digest run and focuses the report on recent posts. Use `--fetch-all-comments` only when exhaustive comment history is more important than runtime.
+
+GitHub issue search is still seeded by issue `updated_at`, so a purely reaction-only issue may be missed if reactions do not bump `updated_at`. Covering every reaction-only case would require either a persisted snapshot store or a broader scan of labeled issues.
+
+## Attention Markers
+
+The collector scales attention markers by the requested time window. The baseline is 5 human user interactions for `🔥` and 10 for `🔥🔥` over 24 hours; longer or shorter windows scale those cutoffs linearly and round up. For example, a one-week report uses 35 and 70 interactions. Human user interactions are human-authored new issue posts, human-authored new comments, and human reactions created during the window, including upvotes. Bot posts and bot reactions are excluded. In prose, explain this as high user interaction rather than naming the emoji.
+
+## Freshness
+
+The automation should run from a repo checkout that contains this skill. For shared daily use, prefer one of these patterns:
+
+- Run the automation in a checkout that is refreshed before the automation starts, for example with `git pull --ff-only`.
+- If the automation cannot safely mutate the checkout, have it report the current `git_head` from the collector output so readers know which skill/script version produced the digest.
+
+## Sample Owner Prompt
+
+```text
+Use $codex-issue-digest to run the Codex issue digest for labels tui and exec over the previous 24 hours.
+```
+
+```text
+Use $codex-issue-digest to run the Codex issue digest for all areas over the past week.
+```
+
+## Validation
+
+Dry run the collector against recent issues:
+
+```bash
+python3 .codex/skills/codex-issue-digest/scripts/collect_issue_digest.py --labels tui exec --window-hours 24
+```
+
+```bash
+python3 .codex/skills/codex-issue-digest/scripts/collect_issue_digest.py --all-labels --window "past week" --limit-issues 10
+```
+
+Run the focused script tests:
+
+```bash
+pytest .codex/skills/codex-issue-digest/scripts/test_collect_issue_digest.py
+```

.codex/skills/codex-issue-digest/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Codex Issue Digest"
+  short_description: "Summarize Codex issues by labels or all areas"
+  default_prompt: "Use $codex-issue-digest to run the Codex issue digest for labels tui and exec over the previous 24 hours."

.codex/skills/codex-issue-digest/scripts/collect_issue_digest.py

@@ -0,0 +1,994 @@
+#!/usr/bin/env python3
+"""Collect recent openai/codex issue activity for owner-focused digests."""
+
+import argparse
+import json
+import math
+import re
+import subprocess
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from urllib.parse import quote
+
+SCRIPT_VERSION = 4
+QUALIFYING_KIND_LABELS = ("bug", "enhancement")
+REACTION_KEYS = ("+1", "-1", "laugh", "hooray", "confused", "heart", "rocket", "eyes")
+BASE_ATTENTION_WINDOW_HOURS = 24.0
+ONE_ATTENTION_INTERACTION_THRESHOLD = 5
+TWO_ATTENTION_INTERACTION_THRESHOLD = 10
+ALL_LABEL_PHRASES = {"all", "all areas", "all labels", "all-areas", "all-labels", "*"}
+
+
+class GhCommandError(RuntimeError):
+    pass
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Collect recent GitHub issue activity for a Codex owner digest."
+    )
+    parser.add_argument(
+        "--repo", default="openai/codex", help="OWNER/REPO, default openai/codex"
+    )
+    parser.add_argument(
+        "--labels",
+        nargs="+",
+        default=[],
+        help="Feature-area labels owned by the digest recipient, for example: tui exec",
+    )
+    parser.add_argument(
+        "--all-labels",
+        action="store_true",
+        help="Collect bug/enhancement issues across all feature-area labels",
+    )
+    parser.add_argument(
+        "--window",
+        help='Lookback duration such as "24h", "7d", "1w", or "past week"',
+    )
+    parser.add_argument(
+        "--window-hours", type=float, default=24.0, help="Lookback window"
+    )
+    parser.add_argument(
+        "--since", help="UTC ISO timestamp override for the window start"
+    )
+    parser.add_argument("--until", help="UTC ISO timestamp override for the window end")
+    parser.add_argument(
+        "--limit-issues",
+        type=int,
+        default=200,
+        help="Maximum candidate issues to hydrate after search",
+    )
+    parser.add_argument(
+        "--body-chars", type=int, default=1200, help="Issue body excerpt length"
+    )
+    parser.add_argument(
+        "--comment-chars", type=int, default=900, help="Comment excerpt length"
+    )
+    parser.add_argument(
+        "--max-comment-pages",
+        type=int,
+        default=3,
+        help=(
+            "Maximum pages of issue comments to hydrate per issue after applying the "
+            "window filter. Use 0 with --fetch-all-comments for no page cap."
+        ),
+    )
+    parser.add_argument(
+        "--fetch-all-comments",
+        action="store_true",
+        help="Hydrate complete issue comment histories instead of only window-updated comments.",
+    )
+    return parser.parse_args()
+
+
+def parse_timestamp(value, arg_name):
+    if value is None:
+        return None
+    normalized = value.strip()
+    if not normalized:
+        return None
+    if normalized.endswith("Z"):
+        normalized = f"{normalized[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError as err:
+        raise ValueError(f"{arg_name} must be an ISO timestamp") from err
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.astimezone(timezone.utc)
+
+
+def format_timestamp(value):
+    return (
+        value.astimezone(timezone.utc)
+        .replace(microsecond=0)
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
+def resolve_window(args):
+    until = parse_timestamp(args.until, "--until") or datetime.now(timezone.utc)
+    since = parse_timestamp(args.since, "--since")
+    if since is None:
+        hours = parse_duration_hours(getattr(args, "window", None))
+        if hours is None:
+            hours = getattr(args, "window_hours", 24.0)
+        if hours <= 0:
+            raise ValueError("window duration must be > 0")
+        since = until - timedelta(hours=hours)
+    if since >= until:
+        raise ValueError("--since must be before --until")
+    return since, until
+
+
+def parse_duration_hours(value):
+    if value is None:
+        return None
+    text = value.strip().casefold().replace("_", " ")
+    if not text:
+        return None
+    text = re.sub(r"^(past|last)\s+", "", text)
+    aliases = {
+        "day": 24.0,
+        "24h": 24.0,
+        "week": 168.0,
+        "7d": 168.0,
+    }
+    if text in aliases:
+        return aliases[text]
+    match = re.fullmatch(r"(\d+(?:\.\d+)?)\s*(h|hr|hrs|hour|hours)", text)
+    if match:
+        return float(match.group(1))
+    match = re.fullmatch(r"(\d+(?:\.\d+)?)\s*(d|day|days)", text)
+    if match:
+        return float(match.group(1)) * 24.0
+    match = re.fullmatch(r"(\d+(?:\.\d+)?)\s*(w|week|weeks)", text)
+    if match:
+        return float(match.group(1)) * 168.0
+    raise ValueError(f"Unsupported duration: {value}")
+
+
+def normalize_requested_labels(labels, all_labels=False):
+    out = []
+    seen = set()
+    for raw in labels:
+        for piece in raw.split(","):
+            label = piece.strip()
+            if not label:
+                continue
+            key = label.casefold()
+            if key not in seen:
+                out.append(label)
+                seen.add(key)
+    phrase = " ".join(label.casefold() for label in out)
+    if all_labels or phrase in ALL_LABEL_PHRASES:
+        return [], True
+    if not out:
+        raise ValueError(
+            "At least one feature-area label is required, or use --all-labels"
+        )
+    return out, False
+
+
+def quote_label(label):
+    if re.fullmatch(r"[A-Za-z0-9_.:-]+", label):
+        return f"label:{label}"
+    escaped = label.replace('"', '\\"')
+    return f'label:"{escaped}"'
+
+
+def build_search_queries(
+    repo, owner_labels, since, kind_labels=QUALIFYING_KIND_LABELS, all_labels=False
+):
+    since_date = since.date().isoformat()
+    queries = []
+    if all_labels:
+        for kind_label in kind_labels:
+            queries.append(
+                " ".join(
+                    [
+                        f"repo:{repo}",
+                        "is:issue",
+                        f"updated:>={since_date}",
+                        quote_label(kind_label),
+                    ]
+                )
+            )
+        return queries
+    for owner_label in owner_labels:
+        for kind_label in kind_labels:
+            queries.append(
+                " ".join(
+                    [
+                        f"repo:{repo}",
+                        "is:issue",
+                        f"updated:>={since_date}",
+                        quote_label(owner_label),
+                        quote_label(kind_label),
+                    ]
+                )
+            )
+    return queries
+
+
+def _format_gh_error(cmd, err):
+    stdout = (err.stdout or "").strip()
+    stderr = (err.stderr or "").strip()
+    parts = [f"GitHub CLI command failed: {' '.join(cmd)}"]
+    if stdout:
+        parts.append(f"stdout: {stdout}")
+    if stderr:
+        parts.append(f"stderr: {stderr}")
+    return "\n".join(parts)
+
+
+def gh_json(args):
+    cmd = ["gh", *args]
+    try:
+        proc = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except FileNotFoundError as err:
+        raise GhCommandError("`gh` command not found") from err
+    except subprocess.CalledProcessError as err:
+        raise GhCommandError(_format_gh_error(cmd, err)) from err
+    raw = proc.stdout.strip()
+    if not raw:
+        return None
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError as err:
+        raise GhCommandError(
+            f"Failed to parse JSON from gh output for {' '.join(args)}"
+        ) from err
+
+
+def gh_text(args):
+    cmd = ["gh", *args]
+    try:
+        proc = subprocess.run(cmd, check=True, capture_output=True, text=True)
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return ""
+    return proc.stdout.strip()
+
+
+def git_head():
+    try:
+        proc = subprocess.run(
+            ["git", "rev-parse", "--short=12", "HEAD"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return None
+    return proc.stdout.strip() or None
+
+
+def skill_relative_path():
+    try:
+        return str(Path(__file__).resolve().relative_to(Path.cwd().resolve()))
+    except ValueError:
+        return str(Path(__file__).resolve())
+
+
+def gh_api_list_paginated(endpoint, per_page=100, max_pages=None, with_metadata=False):
+    items = []
+    page = 1
+    truncated = False
+    while True:
+        sep = "&" if "?" in endpoint else "?"
+        page_endpoint = f"{endpoint}{sep}per_page={per_page}&page={page}"
+        payload = gh_json(["api", page_endpoint])
+        if payload is None:
+            break
+        if not isinstance(payload, list):
+            raise GhCommandError(f"Unexpected paginated payload from gh api {endpoint}")
+        items.extend(payload)
+        if len(payload) < per_page:
+            break
+        if max_pages is not None and page >= max_pages:
+            truncated = True
+            break
+        page += 1
+    if with_metadata:
+        return {
+            "items": items,
+            "truncated": truncated,
+            "pages": page,
+            "max_pages": max_pages,
+        }
+    return items
+
+
+def search_issue_numbers(queries, limit):
+    numbers = {}
+    for query in queries:
+        page = 1
+        seen_for_query = 0
+        while True:
+            payload = gh_json(
+                [
+                    "api",
+                    "search/issues",
+                    "-X",
+                    "GET",
+                    "-f",
+                    f"q={query}",
+                    "-f",
+                    "sort=updated",
+                    "-f",
+                    "order=desc",
+                    "-f",
+                    "per_page=100",
+                    "-f",
+                    f"page={page}",
+                ]
+            )
+            if not isinstance(payload, dict):
+                raise GhCommandError("Unexpected payload from GitHub issue search")
+            items = payload.get("items") or []
+            if not isinstance(items, list):
+                raise GhCommandError("Expected search `items` to be a list")
+            for item in items:
+                if not isinstance(item, dict):
+                    continue
+                number = item.get("number")
+                if isinstance(number, int):
+                    numbers[number] = str(item.get("updated_at") or "")
+                    seen_for_query += 1
+            if len(items) < 100 or seen_for_query >= limit:
+                break
+            page += 1
+    ordered = sorted(
+        numbers, key=lambda number: (numbers[number], number), reverse=True
+    )
+    return ordered[:limit]
+
+
+def fetch_issue(repo, number):
+    payload = gh_json(["api", f"repos/{repo}/issues/{number}"])
+    if not isinstance(payload, dict):
+        raise GhCommandError(f"Unexpected issue payload for #{number}")
+    return payload
+
+
+def fetch_comments(repo, number, since=None, max_pages=None):
+    endpoint = f"repos/{repo}/issues/{number}/comments"
+    if since is not None:
+        endpoint = f"{endpoint}?since={quote(format_timestamp(since), safe='')}"
+    return gh_api_list_paginated(
+        endpoint,
+        max_pages=max_pages,
+        with_metadata=True,
+    )
+
+
+def fetch_reactions_for_item(endpoint, item):
+    if reaction_summary(item)["total"] <= 0:
+        return []
+    return gh_api_list_paginated(endpoint)
+
+
+def fetch_comment_reactions(repo, comments):
+    reactions_by_comment_id = {}
+    for comment in comments:
+        comment_id = comment.get("id")
+        if comment_id in (None, ""):
+            continue
+        endpoint = f"repos/{repo}/issues/comments/{comment_id}/reactions"
+        reactions_by_comment_id[comment_id] = fetch_reactions_for_item(
+            endpoint, comment
+        )
+    return reactions_by_comment_id
+
+
+def extract_login(user_obj):
+    if isinstance(user_obj, dict):
+        return str(user_obj.get("login") or "")
+    return ""
+
+
+def is_bot_login(login):
+    return bool(login) and login.lower().endswith("[bot]")
+
+
+def is_human_user(user_obj):
+    login = extract_login(user_obj)
+    return bool(login) and not is_bot_login(login)
+
+
+def label_names(issue):
+    labels = []
+    for label in issue.get("labels") or []:
+        if isinstance(label, dict) and label.get("name"):
+            labels.append(str(label["name"]))
+    return sorted(labels, key=str.casefold)
+
+
+def matching_labels(labels, requested):
+    labels_by_key = {label.casefold(): label for label in labels}
+    return [label for label in requested if label.casefold() in labels_by_key]
+
+
+def area_labels(labels):
+    kind_keys = {label.casefold() for label in QUALIFYING_KIND_LABELS}
+    return [label for label in labels if label.casefold() not in kind_keys]
+
+
+def attention_thresholds_for_window(window_hours):
+    if window_hours <= 0:
+        raise ValueError("window_hours must be > 0")
+    window_hours = round(window_hours, 6)
+    scale = window_hours / BASE_ATTENTION_WINDOW_HOURS
+    elevated = max(1, math.ceil(ONE_ATTENTION_INTERACTION_THRESHOLD * scale))
+    very_high = max(
+        elevated + 1, math.ceil(TWO_ATTENTION_INTERACTION_THRESHOLD * scale)
+    )
+    return {
+        "base_window_hours": BASE_ATTENTION_WINDOW_HOURS,
+        "window_hours": round(window_hours, 3),
+        "scale": round(scale, 3),
+        "elevated": elevated,
+        "very_high": very_high,
+    }
+
+
+def attention_level_for(user_interactions, attention_thresholds=None):
+    thresholds = attention_thresholds or attention_thresholds_for_window(
+        BASE_ATTENTION_WINDOW_HOURS
+    )
+    if user_interactions >= thresholds["very_high"]:
+        return 2
+    if user_interactions >= thresholds["elevated"]:
+        return 1
+    return 0
+
+
+def attention_marker_for(user_interactions, attention_thresholds=None):
+    return "🔥" * attention_level_for(user_interactions, attention_thresholds)
+
+
+def reaction_summary(item):
+    reactions = item.get("reactions")
+    if not isinstance(reactions, dict):
+        return {"total": 0, "counts": {}}
+    counts = {}
+    for key in REACTION_KEYS:
+        value = reactions.get(key, 0)
+        if isinstance(value, int) and value:
+            counts[key] = value
+    total = reactions.get("total_count")
+    if not isinstance(total, int):
+        total = sum(counts.values())
+    return {"total": total, "counts": counts}
+
+
+def reaction_event_summary(reactions, since, until):
+    counts = {}
+    total = 0
+    for reaction in reactions or []:
+        if not isinstance(reaction, dict):
+            continue
+        if not is_in_window(str(reaction.get("created_at") or ""), since, until):
+            continue
+        if not is_human_user(reaction.get("user")):
+            continue
+        content = str(reaction.get("content") or "")
+        if not content:
+            continue
+        counts[content] = counts.get(content, 0) + 1
+        total += 1
+    return {
+        "total": total,
+        "counts": counts,
+        "upvotes": counts.get("+1", 0),
+    }
+
+
+def compact_text(value, limit):
+    text = re.sub(r"\s+", " ", str(value or "")).strip()
+    if limit <= 0:
+        return ""
+    if len(text) <= limit:
+        return text
+    return f"{text[: max(limit - 1, 0)].rstrip()}..."
+
+
+def clean_title_for_description(title):
+    cleaned = re.sub(r"\s+", " ", str(title or "")).strip()
+    cleaned = re.sub(
+        r"^(codex(?: desktop| app|\.app| cli)?|desktop|windows codex app)\s*[:,-]\s*",
+        "",
+        cleaned,
+        flags=re.IGNORECASE,
+    )
+    cleaned = re.sub(r"^on windows,\s*", "Windows: ", cleaned, flags=re.IGNORECASE)
+    cleaned = cleaned.strip(" -:;")
+    return compact_text(cleaned, 80) or "Issue needs owner review"
+
+
+def issue_description(issue):
+    return clean_title_for_description(issue.get("title"))
+
+
+def is_in_window(timestamp, since, until):
+    parsed = parse_timestamp(timestamp, "timestamp")
+    if parsed is None:
+        return False
+    return since <= parsed < until
+
+
+def summarize_comment(
+    comment, comment_chars, reaction_events=None, since=None, until=None
+):
+    reactions = reaction_summary(comment)
+    new_reactions = (
+        reaction_event_summary(reaction_events, since, until)
+        if since is not None and until is not None
+        else {"total": 0, "counts": {}, "upvotes": 0}
+    )
+    human_user_interaction = is_human_user(comment.get("user"))
+    return {
+        "id": comment.get("id"),
+        "author": extract_login(comment.get("user")),
+        "author_association": str(comment.get("author_association") or ""),
+        "created_at": str(comment.get("created_at") or ""),
+        "updated_at": str(comment.get("updated_at") or ""),
+        "url": str(comment.get("html_url") or ""),
+        "human_user_interaction": human_user_interaction,
+        "reactions": reactions["counts"],
+        "reaction_total": reactions["total"],
+        "new_reactions": new_reactions["total"],
+        "new_upvotes": new_reactions["upvotes"],
+        "new_reaction_counts": new_reactions["counts"],
+        "body_excerpt": compact_text(comment.get("body"), comment_chars),
+    }
+
+
+def summarize_issue(
+    issue,
+    comments,
+    requested_labels,
+    since,
+    until,
+    body_chars,
+    comment_chars,
+    issue_reaction_events=None,
+    comment_reactions_by_id=None,
+    all_labels=False,
+    comments_hydration=None,
+    attention_thresholds=None,
+):
+    labels = label_names(issue)
+    labels_by_key = {label.casefold() for label in labels}
+    kind_labels = [
+        label for label in QUALIFYING_KIND_LABELS if label.casefold() in labels_by_key
+    ]
+    if all_labels:
+        owner_labels = area_labels(labels) or ["unlabeled"]
+    else:
+        owner_labels = matching_labels(labels, requested_labels)
+    if not kind_labels or not owner_labels:
+        return None
+
+    updated_at = str(issue.get("updated_at") or "")
+    if not is_in_window(updated_at, since, until):
+        return None
+
+    new_issue = is_in_window(str(issue.get("created_at") or ""), since, until)
+    comment_reactions_by_id = comment_reactions_by_id or {}
+    new_comments = [
+        summarize_comment(
+            comment,
+            comment_chars,
+            reaction_events=comment_reactions_by_id.get(comment.get("id")),
+            since=since,
+            until=until,
+        )
+        for comment in comments
+        if is_in_window(str(comment.get("created_at") or ""), since, until)
+    ]
+    new_comments.sort(key=lambda item: (item["created_at"], str(item["id"])))
+
+    issue_reactions = reaction_summary(issue)
+    issue_reaction_events_summary = reaction_event_summary(
+        issue_reaction_events, since, until
+    )
+    comment_reaction_events_summary = reaction_event_summary(
+        [
+            reaction
+            for reactions in comment_reactions_by_id.values()
+            for reaction in reactions
+        ],
+        since,
+        until,
+    )
+    new_reactions = (
+        issue_reaction_events_summary["total"]
+        + comment_reaction_events_summary["total"]
+    )
+    new_upvotes = (
+        issue_reaction_events_summary["upvotes"]
+        + comment_reaction_events_summary["upvotes"]
+    )
+    all_comment_reaction_total = sum(
+        reaction_summary(comment)["total"] for comment in comments
+    )
+    new_comment_reaction_total = sum(
+        comment["reaction_total"] for comment in new_comments
+    )
+    new_issue_user_interaction = new_issue and is_human_user(issue.get("user"))
+    new_comment_user_interactions = sum(
+        1 for comment in new_comments if comment["human_user_interaction"]
+    )
+    user_interactions = (
+        int(new_issue_user_interaction) + new_comment_user_interactions + new_reactions
+    )
+    attention_level = attention_level_for(user_interactions, attention_thresholds)
+    attention_marker = attention_marker_for(user_interactions, attention_thresholds)
+    updated_without_visible_new_post = (
+        not new_issue and not new_comments and new_reactions == 0
+    )
+
+    engagement_score = (
+        len(new_comments) * 3
+        + new_reactions
+        + issue_reactions["total"]
+        + new_comment_reaction_total
+        + min(int(issue.get("comments") or len(comments) or 0), 10)
+    )
+
+    return {
+        "number": issue.get("number"),
+        "title": str(issue.get("title") or ""),
+        "description": issue_description(issue),
+        "url": str(issue.get("html_url") or ""),
+        "state": str(issue.get("state") or ""),
+        "author": extract_login(issue.get("user")),
+        "author_association": str(issue.get("author_association") or ""),
+        "created_at": str(issue.get("created_at") or ""),
+        "updated_at": updated_at,
+        "labels": labels,
+        "kind_labels": kind_labels,
+        "owner_labels": owner_labels,
+        "comments_total": int(issue.get("comments") or len(comments) or 0),
+        "comments_hydration": comments_hydration
+        or {
+            "fetched": len(comments),
+            "since": None,
+            "truncated": False,
+            "max_pages": None,
+        },
+        "issue_reactions": issue_reactions["counts"],
+        "issue_reaction_total": issue_reactions["total"],
+        "comment_reaction_total": all_comment_reaction_total,
+        "new_comment_reaction_total": new_comment_reaction_total,
+        "new_issue_reactions": issue_reaction_events_summary["total"],
+        "new_issue_upvotes": issue_reaction_events_summary["upvotes"],
+        "new_comment_reactions": comment_reaction_events_summary["total"],
+        "new_comment_upvotes": comment_reaction_events_summary["upvotes"],
+        "new_reactions": new_reactions,
+        "new_upvotes": new_upvotes,
+        "user_interactions": user_interactions,
+        "attention": attention_level > 0,
+        "attention_level": attention_level,
+        "attention_marker": attention_marker,
+        "engagement_score": engagement_score,
+        "activity": {
+            "new_issue": new_issue,
+            "new_comments": len(new_comments),
+            "new_human_comments": new_comment_user_interactions,
+            "new_reactions": new_reactions,
+            "new_upvotes": new_upvotes,
+            "updated_without_visible_new_post": updated_without_visible_new_post,
+        },
+        "body_excerpt": compact_text(issue.get("body"), body_chars),
+        "new_comments": new_comments,
+    }
+
+
+def count_by_label(issues, labels):
+    out = {}
+    for label in labels:
+        matching = [issue for issue in issues if label in issue["owner_labels"]]
+        out[label] = {
+            "issues": len(matching),
+            "new_issues": sum(
+                1 for issue in matching if issue["activity"]["new_issue"]
+            ),
+            "new_comments": sum(
+                issue["activity"]["new_comments"] for issue in matching
+            ),
+        }
+    return out
+
+
+def count_by_kind(issues):
+    out = {}
+    for kind in QUALIFYING_KIND_LABELS:
+        matching = [issue for issue in issues if kind in issue["kind_labels"]]
+        out[kind] = {
+            "issues": len(matching),
+            "new_issues": sum(
+                1 for issue in matching if issue["activity"]["new_issue"]
+            ),
+            "new_comments": sum(
+                issue["activity"]["new_comments"] for issue in matching
+            ),
+        }
+    return out
+
+
+def hot_items(issues, limit=8):
+    ranked = sorted(
+        issues,
+        key=lambda issue: (
+            issue["attention"],
+            issue["attention_level"],
+            issue["user_interactions"],
+            issue["engagement_score"],
+            issue["activity"]["new_comments"],
+            issue["issue_reaction_total"] + issue["comment_reaction_total"],
+            issue["updated_at"],
+        ),
+        reverse=True,
+    )
+    return [
+        {
+            "number": issue["number"],
+            "title": issue["title"],
+            "url": issue["url"],
+            "owner_labels": issue["owner_labels"],
+            "kind_labels": issue["kind_labels"],
+            "attention": issue["attention"],
+            "attention_level": issue["attention_level"],
+            "attention_marker": issue["attention_marker"],
+            "user_interactions": issue["user_interactions"],
+            "new_reactions": issue["new_reactions"],
+            "new_upvotes": issue["new_upvotes"],
+            "engagement_score": issue["engagement_score"],
+            "new_comments": issue["activity"]["new_comments"],
+            "reaction_total": issue["issue_reaction_total"]
+            + issue["comment_reaction_total"],
+        }
+        for issue in ranked[:limit]
+        if issue["engagement_score"] > 0
+    ]
+
+
+def ranked_digest_issues(issues):
+    return sorted(
+        issues,
+        key=lambda issue: (
+            issue["attention"],
+            issue["attention_level"],
+            issue["user_interactions"],
+            issue["engagement_score"],
+            issue["activity"]["new_comments"],
+            issue["updated_at"],
+        ),
+        reverse=True,
+    )
+
+
+def digest_rows(issues, limit=10, ref_map=None):
+    ranked = ranked_digest_issues(issues)
+    if ref_map is None:
+        ref_map = {issue["number"]: ref for ref, issue in enumerate(ranked, start=1)}
+    rows = []
+    for issue in ranked[:limit]:
+        ref = ref_map[issue["number"]]
+        reaction_total = issue["issue_reaction_total"] + issue["comment_reaction_total"]
+        rows.append(
+            {
+                "ref": ref,
+                "ref_markdown": f"[{ref}]({issue['url']})",
+                "marker": issue["attention_marker"],
+                "attention_marker": issue["attention_marker"],
+                "number": issue["number"],
+                "description": issue["description"],
+                "title": issue["title"],
+                "url": issue["url"],
+                "area": ", ".join(issue["owner_labels"]),
+                "kind": ", ".join(issue["kind_labels"]),
+                "state": issue["state"],
+                "interactions": issue["user_interactions"],
+                "user_interactions": issue["user_interactions"],
+                "new_reactions": issue["new_reactions"],
+                "new_upvotes": issue["new_upvotes"],
+                "current_reactions": reaction_total,
+            }
+        )
+    return rows
+
+
+def issue_ref_markdown(issue, ref_map):
+    ref = ref_map[issue["number"]]
+    return f"[{ref}]({issue['url']})"
+
+
+def summary_inputs(issues, limit=80, ref_map=None):
+    ranked = ranked_digest_issues(issues)
+    if ref_map is None:
+        ref_map = {issue["number"]: ref for ref, issue in enumerate(ranked, start=1)}
+    rows = []
+    for issue in ranked[:limit]:
+        rows.append(
+            {
+                "ref": ref_map[issue["number"]],
+                "ref_markdown": issue_ref_markdown(issue, ref_map),
+                "number": issue["number"],
+                "title": issue["title"],
+                "description": issue["description"],
+                "url": issue["url"],
+                "labels": issue["labels"],
+                "owner_labels": issue["owner_labels"],
+                "kind_labels": issue["kind_labels"],
+                "state": issue.get("state", ""),
+                "attention_marker": issue.get("attention_marker", ""),
+                "interactions": issue["user_interactions"],
+                "new_comments": issue["activity"].get("new_comments", 0),
+                "new_reactions": issue.get("new_reactions", 0),
+                "new_upvotes": issue.get("new_upvotes", 0),
+                "current_reactions": issue.get("issue_reaction_total", 0)
+                + issue.get("comment_reaction_total", 0),
+            }
+        )
+    return rows
+
+
+def collect_digest(args):
+    since, until = resolve_window(args)
+    window_hours = (until - since).total_seconds() / 3600
+    attention_thresholds = attention_thresholds_for_window(window_hours)
+    requested_labels, all_labels = normalize_requested_labels(
+        args.labels, all_labels=args.all_labels
+    )
+    queries = build_search_queries(
+        args.repo, requested_labels, since, all_labels=all_labels
+    )
+    numbers = search_issue_numbers(queries, args.limit_issues)
+    gh_version_output = gh_text(["--version"])
+
+    issues = []
+    max_comment_pages = None if args.max_comment_pages <= 0 else args.max_comment_pages
+    for number in numbers:
+        issue = fetch_issue(args.repo, number)
+        comments_since = None if args.fetch_all_comments else since
+        comments_payload = fetch_comments(
+            args.repo,
+            number,
+            since=comments_since,
+            max_pages=max_comment_pages,
+        )
+        comments = comments_payload["items"]
+        issue_reaction_events = fetch_reactions_for_item(
+            f"repos/{args.repo}/issues/{number}/reactions", issue
+        )
+        comment_reactions_by_id = fetch_comment_reactions(args.repo, comments)
+        comments_hydration = {
+            "fetched": len(comments),
+            "total": int(issue.get("comments") or len(comments) or 0),
+            "since": format_timestamp(comments_since) if comments_since else None,
+            "truncated": comments_payload["truncated"],
+            "max_pages": comments_payload["max_pages"],
+            "fetch_all_comments": args.fetch_all_comments,
+        }
+        summary = summarize_issue(
+            issue,
+            comments,
+            requested_labels,
+            since,
+            until,
+            args.body_chars,
+            args.comment_chars,
+            issue_reaction_events=issue_reaction_events,
+            comment_reactions_by_id=comment_reactions_by_id,
+            all_labels=all_labels,
+            comments_hydration=comments_hydration,
+            attention_thresholds=attention_thresholds,
+        )
+        if summary is not None:
+            issues.append(summary)
+
+    issues.sort(
+        key=lambda issue: (issue["updated_at"], int(issue["number"] or 0)), reverse=True
+    )
+    totals = {
+        "candidate_issues": len(numbers),
+        "included_issues": len(issues),
+        "new_issues": sum(1 for issue in issues if issue["activity"]["new_issue"]),
+        "issues_with_new_comments": sum(
+            1 for issue in issues if issue["activity"]["new_comments"] > 0
+        ),
+        "new_comments": sum(issue["activity"]["new_comments"] for issue in issues),
+        "comments_fetched": sum(
+            issue["comments_hydration"]["fetched"] for issue in issues
+        ),
+        "issues_with_truncated_comment_hydration": sum(
+            1 for issue in issues if issue["comments_hydration"]["truncated"]
+        ),
+        "updated_without_visible_new_post": sum(
+            1
+            for issue in issues
+            if issue["activity"]["updated_without_visible_new_post"]
+        ),
+        "issue_reactions_current_total": sum(
+            issue["issue_reaction_total"] for issue in issues
+        ),
+        "comment_reactions_current_total": sum(
+            issue["comment_reaction_total"] for issue in issues
+        ),
+        "new_reactions": sum(issue["new_reactions"] for issue in issues),
+        "new_upvotes": sum(issue["new_upvotes"] for issue in issues),
+        "user_interactions": sum(issue["user_interactions"] for issue in issues),
+    }
+    ranked = ranked_digest_issues(issues)
+    ref_map = {issue["number"]: ref for ref, issue in enumerate(ranked, start=1)}
+    filter_label = "all" if all_labels else requested_labels
+
+    return {
+        "generated_at": format_timestamp(datetime.now(timezone.utc)),
+        "source": {
+            "repo": args.repo,
+            "skill": "codex-issue-digest",
+            "collector": skill_relative_path(),
+            "script_version": SCRIPT_VERSION,
+            "git_head": git_head(),
+            "gh_version": gh_version_output.splitlines()[0]
+            if gh_version_output
+            else None,
+        },
+        "window": {
+            "since": format_timestamp(since),
+            "until": format_timestamp(until),
+            "hours": round(window_hours, 3),
+        },
+        "attention_thresholds": attention_thresholds,
+        "filters": {
+            "owner_labels": filter_label,
+            "all_labels": all_labels,
+            "kind_labels": list(QUALIFYING_KIND_LABELS),
+        },
+        "collection_notes": [
+            "Issues are selected when they currently have bug or enhancement plus at least one requested owner label and were updated during the window.",
+            "By default, issue comments are fetched with since=window_start and a max page cap to avoid long historical threads; use --fetch-all-comments when exhaustive comment history is needed.",
+            "New issue comments are filtered by comment creation time within the window from the fetched comment set.",
+            "Reaction events are counted by GitHub reaction created_at timestamps for hydrated issues and fetched comments.",
+            "Current reaction totals are standing engagement signals; new_reactions and new_upvotes are windowed activity.",
+            "The collector does not assign semantic clusters; use summary_inputs as model-ready evidence for report-time clustering.",
+            "Pure reaction-only issues may be missed if GitHub issue search does not surface them via updated_at.",
+            "Issues updated during the window without a new issue body or new comment are retained because label/status edits can still be useful owner signals.",
+        ],
+        "totals": totals,
+        "by_owner_label": count_by_label(
+            issues,
+            sorted(
+                {area for issue in issues for area in issue["owner_labels"]},
+                key=str.casefold,
+            )
+            if all_labels
+            else requested_labels,
+        ),
+        "by_kind_label": count_by_kind(issues),
+        "hot_items": hot_items(issues),
+        "summary_inputs": summary_inputs(issues, ref_map=ref_map),
+        "digest_rows": digest_rows(issues, ref_map=ref_map),
+        "issues": issues,
+    }
+
+
+def main():
+    args = parse_args()
+    try:
+        digest = collect_digest(args)
+    except (GhCommandError, RuntimeError, ValueError) as err:
+        sys.stderr.write(f"collect_issue_digest.py error: {err}\n")
+        return 1
+    sys.stdout.write(json.dumps(digest, indent=2, sort_keys=True) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

.codex/skills/codex-issue-digest/scripts/test_collect_issue_digest.py

@@ -0,0 +1,685 @@
+import importlib.util
+from datetime import timezone
+from pathlib import Path
+
+
+MODULE_PATH = Path(__file__).with_name("collect_issue_digest.py")
+MODULE_SPEC = importlib.util.spec_from_file_location(
+    "collect_issue_digest", MODULE_PATH
+)
+collect_issue_digest = importlib.util.module_from_spec(MODULE_SPEC)
+assert MODULE_SPEC.loader is not None
+MODULE_SPEC.loader.exec_module(collect_issue_digest)
+
+
+def test_build_search_queries_uses_each_owner_and_kind_label():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T12:34:56Z", "--since")
+
+    queries = collect_issue_digest.build_search_queries(
+        "openai/codex", ["tui", "exec"], since
+    )
+
+    assert queries == [
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:tui label:bug",
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:tui label:enhancement",
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:exec label:bug",
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:exec label:enhancement",
+    ]
+
+
+def test_build_search_queries_can_scan_all_labels():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T12:34:56Z", "--since")
+
+    queries = collect_issue_digest.build_search_queries(
+        "openai/codex", [], since, all_labels=True
+    )
+
+    assert queries == [
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:bug",
+        "repo:openai/codex is:issue updated:>=2026-04-25 label:enhancement",
+    ]
+
+
+def test_normalize_requested_labels_accepts_all_area_phrases():
+    assert collect_issue_digest.normalize_requested_labels(["all", "areas"]) == (
+        [],
+        True,
+    )
+    assert collect_issue_digest.normalize_requested_labels(["all-labels"]) == (
+        [],
+        True,
+    )
+
+
+def test_search_issue_numbers_requests_updated_sort(monkeypatch):
+    calls = []
+
+    def fake_gh_json(args):
+        calls.append(args)
+        return {
+            "items": [
+                {"number": 1, "updated_at": "2026-04-25T00:00:00Z"},
+            ]
+        }
+
+    monkeypatch.setattr(collect_issue_digest, "gh_json", fake_gh_json)
+
+    assert collect_issue_digest.search_issue_numbers(["query"], limit=10) == [1]
+    assert "-f" in calls[0]
+    assert "sort=updated" in calls[0]
+    assert "order=desc" in calls[0]
+
+
+def test_search_issue_numbers_applies_limit_per_query(monkeypatch):
+    calls = []
+
+    def fake_gh_json(args):
+        calls.append(args)
+        query = next(
+            value.removeprefix("q=") for value in args if value.startswith("q=")
+        )
+        page = int(
+            next(
+                value.removeprefix("page=")
+                for value in args
+                if value.startswith("page=")
+            )
+        )
+        base = 10_000 if query == "first" else 20_000
+        offset = (page - 1) * 100
+        return {
+            "items": [
+                {
+                    "number": base + offset + idx,
+                    "updated_at": f"2026-04-25T00:{idx:02d}:00Z",
+                }
+                for idx in range(100)
+            ]
+        }
+
+    monkeypatch.setattr(collect_issue_digest, "gh_json", fake_gh_json)
+
+    collect_issue_digest.search_issue_numbers(["first", "second"], limit=150)
+
+    queried_pages = [
+        (
+            next(
+                value.removeprefix("q=") for value in args if value.startswith("q=")
+            ),
+            next(
+                value.removeprefix("page=")
+                for value in args
+                if value.startswith("page=")
+            ),
+        )
+        for args in calls
+    ]
+    assert queried_pages == [
+        ("first", "1"),
+        ("first", "2"),
+        ("second", "1"),
+        ("second", "2"),
+    ]
+
+
+def test_summarize_issue_keeps_new_comments_and_reaction_signals():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T00:00:00Z", "--since")
+    until = collect_issue_digest.parse_timestamp("2026-04-26T00:00:00Z", "--until")
+    issue = {
+        "number": 123,
+        "title": "TUI does not redraw",
+        "html_url": "https://github.com/openai/codex/issues/123",
+        "state": "open",
+        "created_at": "2026-04-24T20:00:00Z",
+        "updated_at": "2026-04-25T10:00:00Z",
+        "user": {"login": "alice"},
+        "author_association": "NONE",
+        "comments": 2,
+        "body": "The terminal freezes after resize.",
+        "labels": [{"name": "bug"}, {"name": "tui"}],
+        "reactions": {"total_count": 3, "+1": 2, "rocket": 1},
+    }
+    comments = [
+        {
+            "id": 1,
+            "created_at": "2026-04-25T11:00:00Z",
+            "updated_at": "2026-04-25T11:00:00Z",
+            "html_url": "https://github.com/openai/codex/issues/123#issuecomment-1",
+            "user": {"login": "bob"},
+            "author_association": "MEMBER",
+            "body": "I can reproduce this on main.",
+            "reactions": {"total_count": 4, "heart": 1, "+1": 3},
+        },
+        {
+            "id": 2,
+            "created_at": "2026-04-24T11:00:00Z",
+            "updated_at": "2026-04-24T11:00:00Z",
+            "html_url": "https://github.com/openai/codex/issues/123#issuecomment-2",
+            "user": {"login": "carol"},
+            "author_association": "NONE",
+            "body": "Older comment.",
+            "reactions": {"total_count": 1, "eyes": 1},
+        },
+    ]
+
+    summary = collect_issue_digest.summarize_issue(
+        issue,
+        comments,
+        ["tui", "exec"],
+        since,
+        until,
+        body_chars=200,
+        comment_chars=200,
+    )
+
+    assert summary == {
+        "number": 123,
+        "title": "TUI does not redraw",
+        "description": "TUI does not redraw",
+        "url": "https://github.com/openai/codex/issues/123",
+        "state": "open",
+        "author": "alice",
+        "author_association": "NONE",
+        "created_at": "2026-04-24T20:00:00Z",
+        "updated_at": "2026-04-25T10:00:00Z",
+        "labels": ["bug", "tui"],
+        "kind_labels": ["bug"],
+        "owner_labels": ["tui"],
+        "comments_total": 2,
+        "comments_hydration": {
+            "fetched": 2,
+            "since": None,
+            "truncated": False,
+            "max_pages": None,
+        },
+        "issue_reactions": {"+1": 2, "rocket": 1},
+        "issue_reaction_total": 3,
+        "comment_reaction_total": 5,
+        "new_comment_reaction_total": 4,
+        "new_issue_reactions": 0,
+        "new_issue_upvotes": 0,
+        "new_comment_reactions": 0,
+        "new_comment_upvotes": 0,
+        "new_reactions": 0,
+        "new_upvotes": 0,
+        "user_interactions": 1,
+        "attention": False,
+        "attention_level": 0,
+        "attention_marker": "",
+        "engagement_score": 12,
+        "activity": {
+            "new_issue": False,
+            "new_comments": 1,
+            "new_human_comments": 1,
+            "new_reactions": 0,
+            "new_upvotes": 0,
+            "updated_without_visible_new_post": False,
+        },
+        "body_excerpt": "The terminal freezes after resize.",
+        "new_comments": [
+            {
+                "id": 1,
+                "author": "bob",
+                "author_association": "MEMBER",
+                "created_at": "2026-04-25T11:00:00Z",
+                "updated_at": "2026-04-25T11:00:00Z",
+                "url": "https://github.com/openai/codex/issues/123#issuecomment-1",
+                "human_user_interaction": True,
+                "reactions": {"+1": 3, "heart": 1},
+                "reaction_total": 4,
+                "new_reactions": 0,
+                "new_upvotes": 0,
+                "new_reaction_counts": {},
+                "body_excerpt": "I can reproduce this on main.",
+            }
+        ],
+    }
+
+
+def test_summarize_issue_filters_non_owner_or_non_kind_labels():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T00:00:00Z", "--since")
+    until = collect_issue_digest.parse_timestamp("2026-04-26T00:00:00Z", "--until")
+    base_issue = {
+        "number": 1,
+        "title": "Question",
+        "created_at": "2026-04-25T01:00:00Z",
+        "updated_at": "2026-04-25T01:00:00Z",
+        "labels": [{"name": "question"}, {"name": "tui"}],
+    }
+
+    assert (
+        collect_issue_digest.summarize_issue(
+            base_issue,
+            [],
+            ["tui"],
+            since,
+            until,
+            body_chars=100,
+            comment_chars=100,
+        )
+        is None
+    )
+
+    issue_without_owner = dict(base_issue)
+    issue_without_owner["labels"] = [{"name": "bug"}, {"name": "app"}]
+
+    assert (
+        collect_issue_digest.summarize_issue(
+            issue_without_owner,
+            [],
+            ["tui"],
+            since,
+            until,
+            body_chars=100,
+            comment_chars=100,
+        )
+        is None
+    )
+
+
+def test_resolve_window_defaults_to_previous_hours():
+    class Args:
+        since = None
+        until = "2026-04-26T12:00:00Z"
+        window_hours = 24
+
+    since, until = collect_issue_digest.resolve_window(Args())
+
+    assert since.isoformat() == "2026-04-25T12:00:00+00:00"
+    assert until.tzinfo == timezone.utc
+
+
+def test_parse_duration_hours_accepts_common_phrases():
+    assert collect_issue_digest.parse_duration_hours("past week") == 168
+    assert collect_issue_digest.parse_duration_hours("48h") == 48
+    assert collect_issue_digest.parse_duration_hours("2 days") == 48
+    assert collect_issue_digest.parse_duration_hours("1w") == 168
+
+
+def test_attention_thresholds_scale_by_window_length():
+    one_day = collect_issue_digest.attention_thresholds_for_window(24)
+    assert one_day["elevated"] == 5
+    assert one_day["very_high"] == 10
+
+    half_day = collect_issue_digest.attention_thresholds_for_window(12)
+    assert half_day["elevated"] == 3
+    assert half_day["very_high"] == 5
+
+    week = collect_issue_digest.attention_thresholds_for_window(168)
+    assert week["elevated"] == 35
+    assert week["very_high"] == 70
+    assert collect_issue_digest.attention_marker_for(34, week) == ""
+    assert collect_issue_digest.attention_marker_for(35, week) == "🔥"
+    assert collect_issue_digest.attention_marker_for(70, week) == "🔥🔥"
+
+
+def test_fetch_comments_uses_since_filter_and_page_cap(monkeypatch):
+    calls = []
+
+    def fake_gh_json(args):
+        calls.append(args)
+        return [{"id": idx} for idx in range(100)]
+
+    monkeypatch.setattr(collect_issue_digest, "gh_json", fake_gh_json)
+    since = collect_issue_digest.parse_timestamp("2026-04-25T00:00:00Z", "--since")
+
+    payload = collect_issue_digest.fetch_comments(
+        "openai/codex", 123, since=since, max_pages=1
+    )
+
+    assert len(payload["items"]) == 100
+    assert payload["truncated"] is True
+    assert payload["max_pages"] == 1
+    assert calls == [
+        [
+            "api",
+            "repos/openai/codex/issues/123/comments?since=2026-04-25T00%3A00%3A00Z&per_page=100&page=1",
+        ]
+    ]
+
+
+def test_issue_description_prefers_title_over_body_noise():
+    issue = {
+        "title": "Codex.app GUI: MCP child processes not reaped after task completion",
+        "body": "A later crash mention should not override the title-level symptom.",
+        "labels": [{"name": "app"}, {"name": "bug"}],
+    }
+
+    description = collect_issue_digest.issue_description(issue)
+    assert "MCP child processes" in description
+    assert "crash" not in description.casefold()
+
+
+def test_attention_markers_count_human_user_interactions():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T00:00:00Z", "--since")
+    until = collect_issue_digest.parse_timestamp("2026-04-26T00:00:00Z", "--until")
+    issue = {
+        "number": 456,
+        "title": "Agent context is exploding",
+        "html_url": "https://github.com/openai/codex/issues/456",
+        "state": "open",
+        "created_at": "2026-04-25T01:00:00Z",
+        "updated_at": "2026-04-25T12:00:00Z",
+        "user": {"login": "alice"},
+        "labels": [{"name": "bug"}, {"name": "agent"}],
+    }
+    comments = [
+        {
+            "id": idx,
+            "created_at": "2026-04-25T02:00:00Z",
+            "updated_at": "2026-04-25T02:00:00Z",
+            "user": {"login": f"user-{idx}"},
+            "body": "same here",
+        }
+        for idx in range(4)
+    ]
+    comments.append(
+        {
+            "id": 99,
+            "created_at": "2026-04-25T02:00:00Z",
+            "updated_at": "2026-04-25T02:00:00Z",
+            "user": {"login": "github-actions[bot]"},
+            "body": "duplicate bot note",
+        }
+    )
+
+    summary = collect_issue_digest.summarize_issue(
+        issue,
+        comments,
+        ["agent"],
+        since,
+        until,
+        body_chars=100,
+        comment_chars=100,
+    )
+
+    assert summary["user_interactions"] == 5
+    assert summary["activity"]["new_human_comments"] == 4
+    assert summary["attention"] is True
+    assert summary["attention_level"] == 1
+    assert summary["attention_marker"] == "🔥"
+
+    issue["created_at"] = "2026-04-24T01:00:00Z"
+    comments.extend(
+        {
+            "id": idx,
+            "created_at": "2026-04-25T03:00:00Z",
+            "updated_at": "2026-04-25T03:00:00Z",
+            "user": {"login": f"extra-user-{idx}"},
+            "body": "also seeing this",
+        }
+        for idx in range(100, 106)
+    )
+
+    summary = collect_issue_digest.summarize_issue(
+        issue,
+        comments,
+        ["agent"],
+        since,
+        until,
+        body_chars=100,
+        comment_chars=100,
+    )
+
+    assert summary["user_interactions"] == 10
+    assert summary["attention_level"] == 2
+    assert summary["attention_marker"] == "🔥🔥"
+
+
+def test_reactions_count_toward_attention_markers():
+    since = collect_issue_digest.parse_timestamp("2026-04-25T00:00:00Z", "--since")
+    until = collect_issue_digest.parse_timestamp("2026-04-26T00:00:00Z", "--until")
+    issue = {
+        "number": 789,
+        "title": "Support 1M token context",
+        "html_url": "https://github.com/openai/codex/issues/789",
+        "state": "open",
+        "created_at": "2026-04-24T01:00:00Z",
+        "updated_at": "2026-04-25T12:00:00Z",
+        "user": {"login": "alice"},
+        "labels": [{"name": "enhancement"}, {"name": "context"}],
+        "reactions": {"total_count": 20, "+1": 20},
+    }
+    comments = [
+        {
+            "id": 1,
+            "created_at": "2026-04-25T02:00:00Z",
+            "updated_at": "2026-04-25T02:00:00Z",
+            "user": {"login": "commenter"},
+            "body": "please",
+            "reactions": {"total_count": 2, "+1": 2},
+        }
+    ]
+    issue_reactions = [
+        {
+            "content": "+1",
+            "created_at": "2026-04-25T03:00:00Z",
+            "user": {"login": f"reactor-{idx}"},
+        }
+        for idx in range(18)
+    ]
+    comment_reactions_by_id = {
+        1: [
+            {
+                "content": "heart",
+                "created_at": "2026-04-25T04:00:00Z",
+                "user": {"login": "human-reactor"},
+            },
+            {
+                "content": "+1",
+                "created_at": "2026-04-25T04:00:00Z",
+                "user": {"login": "github-actions[bot]"},
+            },
+        ]
+    }
+
+    summary = collect_issue_digest.summarize_issue(
+        issue,
+        comments,
+        ["context"],
+        since,
+        until,
+        body_chars=100,
+        comment_chars=100,
+        issue_reaction_events=issue_reactions,
+        comment_reactions_by_id=comment_reactions_by_id,
+    )
+
+    assert summary["new_reactions"] == 19
+    assert summary["new_upvotes"] == 18
+    assert summary["user_interactions"] == 20
+    assert summary["attention_level"] == 2
+    assert summary["attention_marker"] == "🔥🔥"
+    assert summary["new_comments"][0]["new_reactions"] == 1
+    assert summary["new_comments"][0]["new_upvotes"] == 0
+
+
+def test_digest_rows_are_table_ready_with_concise_descriptions():
+    rows = collect_issue_digest.digest_rows(
+        [
+            {
+                "number": 1,
+                "title": "Quiet bug",
+                "description": "Quiet bug",
+                "url": "https://github.com/openai/codex/issues/1",
+                "owner_labels": ["context"],
+                "kind_labels": ["bug"],
+                "state": "open",
+                "attention": False,
+                "attention_level": 0,
+                "attention_marker": "",
+                "user_interactions": 1,
+                "new_reactions": 0,
+                "new_upvotes": 0,
+                "engagement_score": 3,
+                "issue_reaction_total": 0,
+                "comment_reaction_total": 0,
+                "updated_at": "2026-04-25T01:00:00Z",
+                "activity": {
+                    "new_issue": True,
+                    "new_comments": 0,
+                    "new_reactions": 0,
+                    "updated_without_visible_new_post": False,
+                },
+            },
+            {
+                "number": 2,
+                "title": "Busy bug",
+                "description": "High-volume bug report",
+                "url": "https://github.com/openai/codex/issues/2",
+                "owner_labels": ["agent"],
+                "kind_labels": ["bug"],
+                "state": "open",
+                "attention": True,
+                "attention_level": 1,
+                "attention_marker": "🔥",
+                "user_interactions": 17,
+                "new_reactions": 3,
+                "new_upvotes": 2,
+                "engagement_score": 20,
+                "issue_reaction_total": 5,
+                "comment_reaction_total": 2,
+                "updated_at": "2026-04-25T02:00:00Z",
+                "activity": {
+                    "new_issue": False,
+                    "new_comments": 16,
+                    "new_reactions": 3,
+                    "updated_without_visible_new_post": False,
+                },
+            },
+        ]
+    )
+
+    assert rows[0] == {
+        "ref": 1,
+        "ref_markdown": "[1](https://github.com/openai/codex/issues/2)",
+        "marker": "🔥",
+        "attention_marker": "🔥",
+        "number": 2,
+        "description": "High-volume bug report",
+        "title": "Busy bug",
+        "url": "https://github.com/openai/codex/issues/2",
+        "area": "agent",
+        "kind": "bug",
+        "state": "open",
+        "interactions": 17,
+        "user_interactions": 17,
+        "new_reactions": 3,
+        "new_upvotes": 2,
+        "current_reactions": 7,
+    }
+
+
+def test_summary_inputs_are_model_ready_without_preclustering():
+    issues = [
+        {
+            "number": 20,
+            "title": "Windows app Browser Use external navigation fails",
+            "description": "Browser Use navigation or app-server failure",
+            "url": "https://github.com/openai/codex/issues/20",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "attention": False,
+            "attention_level": 0,
+            "attention_marker": "",
+            "user_interactions": 3,
+            "new_reactions": 1,
+            "engagement_score": 8,
+            "updated_at": "2026-04-25T04:00:00Z",
+            "activity": {"new_comments": 2},
+        },
+        {
+            "number": 21,
+            "title": "On Windows, cmake output waits until timeout",
+            "description": "Windows command timeout/capture problem",
+            "url": "https://github.com/openai/codex/issues/21",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "attention": False,
+            "attention_level": 0,
+            "attention_marker": "",
+            "user_interactions": 3,
+            "new_reactions": 0,
+            "engagement_score": 7,
+            "updated_at": "2026-04-25T03:00:00Z",
+            "activity": {"new_comments": 3},
+        },
+        {
+            "number": 22,
+            "title": "Windows computer use tool fails to click buttons",
+            "description": "Computer-use workflow failure",
+            "url": "https://github.com/openai/codex/issues/22",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "attention": False,
+            "attention_level": 0,
+            "attention_marker": "",
+            "user_interactions": 3,
+            "new_reactions": 0,
+            "engagement_score": 6,
+            "updated_at": "2026-04-25T02:00:00Z",
+            "activity": {"new_comments": 3},
+        },
+    ]
+
+    rows = collect_issue_digest.summary_inputs(issues, ref_map={20: 1, 21: 2, 22: 3})
+
+    assert rows == [
+        {
+            "ref": 1,
+            "ref_markdown": "[1](https://github.com/openai/codex/issues/20)",
+            "number": 20,
+            "title": "Windows app Browser Use external navigation fails",
+            "description": "Browser Use navigation or app-server failure",
+            "url": "https://github.com/openai/codex/issues/20",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "state": "",
+            "attention_marker": "",
+            "interactions": 3,
+            "new_comments": 2,
+            "new_reactions": 1,
+            "new_upvotes": 0,
+            "current_reactions": 0,
+        },
+        {
+            "ref": 2,
+            "ref_markdown": "[2](https://github.com/openai/codex/issues/21)",
+            "number": 21,
+            "title": "On Windows, cmake output waits until timeout",
+            "description": "Windows command timeout/capture problem",
+            "url": "https://github.com/openai/codex/issues/21",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "state": "",
+            "attention_marker": "",
+            "interactions": 3,
+            "new_comments": 3,
+            "new_reactions": 0,
+            "new_upvotes": 0,
+            "current_reactions": 0,
+        },
+        {
+            "ref": 3,
+            "ref_markdown": "[3](https://github.com/openai/codex/issues/22)",
+            "number": 22,
+            "title": "Windows computer use tool fails to click buttons",
+            "description": "Computer-use workflow failure",
+            "url": "https://github.com/openai/codex/issues/22",
+            "labels": ["app", "bug"],
+            "owner_labels": ["app"],
+            "kind_labels": ["bug"],
+            "state": "",
+            "attention_marker": "",
+            "interactions": 3,
+            "new_comments": 3,
+            "new_reactions": 0,
+            "new_upvotes": 0,
+            "current_reactions": 0,
+        },
+    ]

.github/actions/setup-bazel-ci/action.yml

@@ -33,7 +33,7 @@ runs:
       run: Copy-Item (Get-Command dotslash).Source -Destination "$env:LOCALAPPDATA\Microsoft\WindowsApps\dotslash.exe"
 
     - name: Set up Bazel
-      uses: bazelbuild/setup-bazelisk@b39c379c82683a5f25d34f0d062761f62693e0b2 # v3
+      uses: bazel-contrib/setup-bazel@c5acdfb288317d0b5c0bbd7a396a3dc868bb0f86 # 0.19.0
 
     - name: Configure Bazel repository cache
       id: configure_bazel_repository_cache

.github/pull_request_template.md

@@ -1,6 +1,6 @@
 # External (non-OpenAI) Pull Request Requirements
 
-Before opening this Pull Request, please read the dedicated "Contributing" markdown file or your PR may be closed:
+External code contributions are by invitation only. Please read the dedicated "Contributing" markdown file for details:
 https://github.com/openai/codex/blob/main/docs/contributing.md
 
 If your PR conforms to our contribution guidelines, replace this text with a detailed and high quality description of your changes.

.github/workflows/bazel.yml

@@ -17,6 +17,13 @@ concurrency:
   cancel-in-progress: ${{ github.ref_name != 'main' }}
 jobs:
   test:
+    # Even though a no-cache-hit Windows build seems to exceed the 30-minute
+    # limit on occasion, the more common reason for exceeding the limit is a
+    # true test failure in a rust_test() marked "flaky" that gets run 3x.
+    # In that case, extra time generally does not give us more signal.
+    #
+    # Ultimately we need true distributed builds (e.g.,
+    # https://www.buildbuddy.io/docs/rbe-setup/) to speed things up.
     timeout-minutes: 30
     strategy:
       fail-fast: false

.github/workflows/ci.yml

@@ -45,11 +45,16 @@ jobs:
           GH_TOKEN: ${{ github.token }}
         run: |
           set -euo pipefail
-          # Use a rust-release version that includes all native binaries.
-          CODEX_VERSION=0.115.0
+          # Use a recent successful rust-release run that published the full
+          # cross-platform native payload required by the npm package layout.
+          # Passing the workflow URL directly avoids relying on old rust-v*
+          # branches remaining discoverable via `gh run list --branch ...`.
+          CODEX_VERSION=0.125.0
+          WORKFLOW_URL="https://github.com/openai/codex/actions/runs/24901475298"
           OUTPUT_DIR="${RUNNER_TEMP}"
           python3 ./scripts/stage_npm_packages.py \
             --release-version "$CODEX_VERSION" \
+            --workflow-url "$WORKFLOW_URL" \
             --package codex \
             --output-dir "$OUTPUT_DIR"
           PACK_OUTPUT="${OUTPUT_DIR}/codex-npm-${CODEX_VERSION}.tgz"

.github/workflows/rust-release.yml

@@ -651,11 +651,59 @@ jobs:
             prefix="${NPM_TAG}-"
           fi
 
+          root_tarball="dist/npm/codex-npm-${VERSION}.tgz"
+          sdk_tarball="dist/npm/codex-sdk-npm-${VERSION}.tgz"
+          # Keep this list in sync with CODEX_PLATFORM_PACKAGES in
+          # codex-cli/scripts/build_npm_package.py. The root wrapper advances
+          # @openai/codex@latest as soon as it publishes, so every platform
+          # package it aliases must already exist in the registry first.
+          platform_tarballs=(
+            "dist/npm/codex-npm-linux-x64-${VERSION}.tgz"
+            "dist/npm/codex-npm-linux-arm64-${VERSION}.tgz"
+            "dist/npm/codex-npm-darwin-x64-${VERSION}.tgz"
+            "dist/npm/codex-npm-darwin-arm64-${VERSION}.tgz"
+            "dist/npm/codex-npm-win32-x64-${VERSION}.tgz"
+            "dist/npm/codex-npm-win32-arm64-${VERSION}.tgz"
+          )
+
+          for required_tarball in "${platform_tarballs[@]}" "${root_tarball}"; do
+            if [[ ! -f "${required_tarball}" ]]; then
+              echo "Missing npm tarball: ${required_tarball}"
+              exit 1
+            fi
+          done
+
           shopt -s nullglob
-          tarballs=(dist/npm/*-"${VERSION}".tgz)
-          if [[ ${#tarballs[@]} -eq 0 ]]; then
-            echo "No npm tarballs found in dist/npm for version ${VERSION}"
-            exit 1
+          other_tarballs=()
+          for tarball in dist/npm/*-"${VERSION}".tgz; do
+            if [[ "${tarball}" == "${root_tarball}" || "${tarball}" == "${sdk_tarball}" ]]; then
+              continue
+            fi
+
+            is_platform_tarball=false
+            for platform_tarball in "${platform_tarballs[@]}"; do
+              if [[ "${tarball}" == "${platform_tarball}" ]]; then
+                is_platform_tarball=true
+                break
+              fi
+            done
+            if [[ "${is_platform_tarball}" == true ]]; then
+              continue
+            fi
+
+            other_tarballs+=("${tarball}")
+          done
+
+          # Publish the platform packages before the root CLI wrapper. The root
+          # wrapper advances @openai/codex@latest, so it should only publish
+          # after the optional dependency versions it references exist.
+          tarballs=(
+            "${platform_tarballs[@]}"
+            "${other_tarballs[@]}"
+            "${root_tarball}"
+          )
+          if [[ -f "${sdk_tarball}" ]]; then
+            tarballs+=("${sdk_tarball}")
           fi
 
           for tarball in "${tarballs[@]}"; do

.github/workflows/rusty-v8-release.yml

@@ -78,7 +78,9 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Set up Bazel
-        uses: bazelbuild/setup-bazelisk@b39c379c82683a5f25d34f0d062761f62693e0b2 # v3
+        uses: ./.github/actions/setup-bazel-ci
+        with:
+          target: ${{ matrix.target }}
 
       - name: Set up Python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6

.github/workflows/v8-canary.yml

@@ -3,6 +3,7 @@ name: v8-canary
 on:
   pull_request:
     paths:
+      - ".github/actions/setup-bazel-ci/**"
       - ".github/scripts/rusty_v8_bazel.py"
       - ".github/workflows/rusty-v8-release.yml"
       - ".github/workflows/v8-canary.yml"
@@ -16,6 +17,7 @@ on:
     branches:
       - main
     paths:
+      - ".github/actions/setup-bazel-ci/**"
       - ".github/scripts/rusty_v8_bazel.py"
       - ".github/workflows/rusty-v8-release.yml"
       - ".github/workflows/v8-canary.yml"
@@ -75,7 +77,9 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Set up Bazel
-        uses: bazelbuild/setup-bazelisk@b39c379c82683a5f25d34f0d062761f62693e0b2 # v3
+        uses: ./.github/actions/setup-bazel-ci
+        with:
+          target: ${{ matrix.target }}
 
       - name: Set up Python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6

MODULE.bazel.lock

@@ -1560,6 +1560,7 @@
       "system-deps_7.0.7": "{\"dependencies\":[{\"kind\":\"dev\",\"name\":\"assert_matches\",\"req\":\"^1.5\"},{\"features\":[\"targets\"],\"name\":\"cfg-expr\",\"req\":\">=0.17, <0.21\"},{\"name\":\"heck\",\"req\":\"^0.5\"},{\"kind\":\"dev\",\"name\":\"itertools\",\"req\":\"^0.14\"},{\"kind\":\"dev\",\"name\":\"lazy_static\",\"req\":\"^1\"},{\"name\":\"pkg-config\",\"req\":\"^0.3.25\"},{\"default_features\":false,\"features\":[\"parse\",\"std\"],\"name\":\"toml\",\"req\":\"^0.9\"},{\"name\":\"version-compare\",\"req\":\"^0.2\"}],\"features\":{}}",
       "tagptr_0.2.0": "{\"dependencies\":[],\"features\":{}}",
       "tar_0.4.44": "{\"dependencies\":[{\"name\":\"filetime\",\"req\":\"^0.2.8\"},{\"name\":\"libc\",\"req\":\"^0.2\",\"target\":\"cfg(unix)\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"},{\"name\":\"xattr\",\"optional\":true,\"req\":\"^1.1.3\",\"target\":\"cfg(unix)\"}],\"features\":{\"default\":[\"xattr\"]}}",
+      "tar_0.4.45": "{\"dependencies\":[{\"kind\":\"dev\",\"name\":\"astral-tokio-tar\",\"req\":\"^0.5\"},{\"name\":\"filetime\",\"req\":\"^0.2.8\"},{\"name\":\"libc\",\"req\":\"^0.2\",\"target\":\"cfg(unix)\"},{\"features\":[\"small_rng\"],\"kind\":\"dev\",\"name\":\"rand\",\"req\":\"^0.8\"},{\"kind\":\"dev\",\"name\":\"tempfile\",\"req\":\"^3\"},{\"features\":[\"macros\",\"rt\"],\"kind\":\"dev\",\"name\":\"tokio\",\"req\":\"^1\"},{\"kind\":\"dev\",\"name\":\"tokio-stream\",\"req\":\"^0.1\"},{\"name\":\"xattr\",\"optional\":true,\"req\":\"^1.1.3\",\"target\":\"cfg(unix)\"}],\"features\":{\"default\":[\"xattr\"]}}",
       "target-lexicon_0.13.3": "{\"dependencies\":[{\"name\":\"serde\",\"optional\":true,\"req\":\"^1.0\"},{\"kind\":\"dev\",\"name\":\"serde_json\",\"req\":\"^1.0\"}],\"features\":{\"arch_z80\":[],\"arch_zkasm\":[],\"default\":[],\"serde_support\":[\"serde\",\"std\"],\"std\":[]}}",
       "tempfile_3.27.0": "{\"dependencies\":[{\"kind\":\"dev\",\"name\":\"doc-comment\",\"req\":\"^0.3\"},{\"name\":\"fastrand\",\"req\":\"^2.1.1\"},{\"default_features\":false,\"name\":\"getrandom\",\"optional\":true,\"req\":\">=0.3.0, <0.5\",\"target\":\"cfg(any(unix, windows, target_os = \\\"wasi\\\"))\"},{\"default_features\":false,\"features\":[\"std\"],\"name\":\"once_cell\",\"req\":\"^1.19.0\"},{\"features\":[\"fs\"],\"name\":\"rustix\",\"req\":\"^1.1.4\",\"target\":\"cfg(any(unix, target_os = \\\"wasi\\\"))\"},{\"features\":[\"Win32_Storage_FileSystem\",\"Win32_Foundation\"],\"name\":\"windows-sys\",\"req\":\">=0.52, <0.62\",\"target\":\"cfg(windows)\"}],\"features\":{\"default\":[\"getrandom\"],\"nightly\":[]}}",
       "temporal_capi_0.1.2": "{\"dependencies\":[{\"default_features\":false,\"name\":\"diplomat\",\"req\":\"^0.14.0\"},{\"default_features\":false,\"name\":\"diplomat-runtime\",\"req\":\"^0.14.0\"},{\"default_features\":false,\"features\":[\"unstable\"],\"name\":\"icu_calendar\",\"req\":\"^2.1.0\"},{\"name\":\"icu_locale\",\"req\":\"^2.1.0\"},{\"default_features\":false,\"name\":\"num-traits\",\"req\":\"^0.2.19\"},{\"default_features\":false,\"name\":\"temporal_rs\",\"req\":\"^0.1.2\"},{\"name\":\"timezone_provider\",\"req\":\"^0.1.2\"},{\"name\":\"writeable\",\"req\":\"^0.6.0\"},{\"name\":\"zoneinfo64\",\"optional\":true,\"req\":\"^0.2.0\"}],\"features\":{\"compiled_data\":[\"temporal_rs/compiled_data\"],\"zoneinfo64\":[\"dep:zoneinfo64\",\"timezone_provider/zoneinfo64\"]}}",

codex-cli/scripts/run_in_container.sh

@@ -92,4 +92,4 @@ quoted_args=""
 for arg in "$@"; do
   quoted_args+=" $(printf '%q' "$arg")"
 done
-docker exec -it "$CONTAINER_NAME" bash -c "cd \"/app$WORK_DIR\" && codex --full-auto ${quoted_args}"
+docker exec -it "$CONTAINER_NAME" bash -c "cd \"/app$WORK_DIR\" && codex --sandbox workspace-write --ask-for-approval on-request ${quoted_args}"

codex-rs/Cargo.lock

@@ -1758,6 +1758,7 @@ dependencies = [
  "codex-protocol",
  "crypto_box",
  "ed25519-dalek",
+ "jsonwebtoken",
  "pretty_assertions",
  "rand 0.9.3",
  "reqwest",
@@ -1852,12 +1853,15 @@ dependencies = [
  "codex-core-plugins",
  "codex-device-key",
  "codex-exec-server",
+ "codex-external-agent-migration",
+ "codex-external-agent-sessions",
  "codex-features",
  "codex-feedback",
  "codex-file-search",
  "codex-git-utils",
  "codex-login",
  "codex-mcp",
+ "codex-memories-write",
  "codex-model-provider",
  "codex-model-provider-info",
  "codex-models-manager",
@@ -1879,6 +1883,7 @@ dependencies = [
  "codex-utils-rustls-provider",
  "constant_time_eq 0.3.1",
  "core_test_support",
+ "flate2",
  "futures",
  "gethostname",
  "hmac",
@@ -1894,6 +1899,7 @@ dependencies = [
  "serial_test",
  "sha2",
  "shlex",
+ "tar",
  "tempfile",
  "thiserror 2.0.18",
  "time",
@@ -2099,7 +2105,6 @@ dependencies = [
  "assert_matches",
  "clap",
  "clap_complete",
- "codex-api",
  "codex-app-server",
  "codex-app-server-protocol",
  "codex-app-server-test-client",
@@ -2116,7 +2121,7 @@ dependencies = [
  "codex-login",
  "codex-mcp",
  "codex-mcp-server",
- "codex-model-provider",
+ "codex-memories-write",
  "codex-models-manager",
  "codex-protocol",
  "codex-responses-api-proxy",
@@ -2287,15 +2292,20 @@ version = "0.0.0"
 dependencies = [
  "anyhow",
  "async-trait",
+ "base64 0.22.1",
  "codex-app-server-protocol",
  "codex-execpolicy",
  "codex-features",
+ "codex-file-system",
+ "codex-git-utils",
  "codex-model-provider-info",
  "codex-network-proxy",
  "codex-protocol",
  "codex-utils-absolute-path",
  "codex-utils-path",
+ "core-foundation 0.9.4",
  "dns-lookup",
+ "dunce",
  "futures",
  "gethostname",
  "libc",
@@ -2319,6 +2329,7 @@ dependencies = [
  "tracing",
  "wildmatch",
  "winapi-util",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -2365,6 +2376,7 @@ dependencies = [
  "codex-hooks",
  "codex-login",
  "codex-mcp",
+ "codex-memories-read",
  "codex-model-provider",
  "codex-model-provider-info",
  "codex-models-manager",
@@ -2377,7 +2389,6 @@ dependencies = [
  "codex-rollout",
  "codex-rollout-trace",
  "codex-sandboxing",
- "codex-secrets",
  "codex-shell-command",
  "codex-shell-escalation",
  "codex-state",
@@ -2399,7 +2410,6 @@ dependencies = [
  "codex-utils-string",
  "codex-utils-template",
  "codex-windows-sandbox",
- "core-foundation 0.9.4",
  "core_test_support",
  "csv",
  "ctor 0.6.3",
@@ -2450,7 +2460,6 @@ dependencies = [
  "walkdir",
  "which 8.0.0",
  "whoami",
- "windows-sys 0.52.0",
  "wiremock",
  "zstd 0.13.3",
 ]
@@ -2474,11 +2483,13 @@ dependencies = [
  "codex-utils-absolute-path",
  "codex-utils-plugins",
  "dirs",
+ "flate2",
  "libc",
  "pretty_assertions",
  "reqwest",
  "serde",
  "serde_json",
+ "tar",
  "tempfile",
  "thiserror 2.0.18",
  "tokio",
@@ -2560,6 +2571,7 @@ dependencies = [
  "codex-apply-patch",
  "codex-arg0",
  "codex-cloud-requirements",
+ "codex-config",
  "codex-core",
  "codex-feedback",
  "codex-git-utils",
@@ -2603,7 +2615,7 @@ dependencies = [
  "bytes",
  "codex-app-server-protocol",
  "codex-client",
- "codex-config",
+ "codex-file-system",
  "codex-protocol",
  "codex-sandboxing",
  "codex-test-binary-support",
@@ -2672,6 +2684,32 @@ dependencies = [
  "syn 2.0.114",
 ]
 
+[[package]]
+name = "codex-external-agent-migration"
+version = "0.0.0"
+dependencies = [
+ "codex-hooks",
+ "pretty_assertions",
+ "serde_json",
+ "serde_yaml",
+ "tempfile",
+ "toml 0.9.11+spec-1.1.0",
+]
+
+[[package]]
+name = "codex-external-agent-sessions"
+version = "0.0.0"
+dependencies = [
+ "chrono",
+ "codex-app-server-protocol",
+ "codex-protocol",
+ "codex-utils-output-truncation",
+ "serde",
+ "serde_json",
+ "sha2",
+ "tempfile",
+]
+
 [[package]]
 name = "codex-features"
 version = "0.0.0"
@@ -2714,14 +2752,23 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "codex-file-system"
+version = "0.0.0"
+dependencies = [
+ "async-trait",
+ "codex-protocol",
+ "codex-utils-absolute-path",
+ "serde",
+]
+
 [[package]]
 name = "codex-git-utils"
 version = "0.0.0"
 dependencies = [
  "anyhow",
- "assert_matches",
  "chrono",
- "codex-exec-server",
+ "codex-file-system",
  "codex-protocol",
  "codex-utils-absolute-path",
  "futures",
@@ -2746,6 +2793,7 @@ dependencies = [
  "anyhow",
  "chrono",
  "codex-config",
+ "codex-plugin",
  "codex-protocol",
  "codex-utils-absolute-path",
  "futures",
@@ -2781,8 +2829,8 @@ version = "0.0.0"
 dependencies = [
  "cc",
  "clap",
- "codex-config",
  "codex-core",
+ "codex-process-hardening",
  "codex-protocol",
  "codex-sandboxing",
  "codex-utils-absolute-path",
@@ -2832,6 +2880,7 @@ dependencies = [
  "codex-terminal-detection",
  "codex-utils-template",
  "core_test_support",
+ "jsonwebtoken",
  "keyring",
  "once_cell",
  "os_info",
@@ -2870,7 +2919,6 @@ dependencies = [
  "codex-plugin",
  "codex-protocol",
  "codex-rmcp-client",
- "codex-utils-absolute-path",
  "codex-utils-plugins",
  "futures",
  "pretty_assertions",
@@ -2920,6 +2968,55 @@ dependencies = [
  "wiremock",
 ]
 
+[[package]]
+name = "codex-memories-read"
+version = "0.0.0"
+dependencies = [
+ "codex-protocol",
+ "codex-shell-command",
+ "codex-utils-absolute-path",
+ "codex-utils-output-truncation",
+ "codex-utils-template",
+ "pretty_assertions",
+ "tempfile",
+ "tokio",
+]
+
+[[package]]
+name = "codex-memories-write"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "chrono",
+ "codex-backend-client",
+ "codex-config",
+ "codex-core",
+ "codex-features",
+ "codex-git-utils",
+ "codex-login",
+ "codex-models-manager",
+ "codex-otel",
+ "codex-protocol",
+ "codex-rollout",
+ "codex-rollout-trace",
+ "codex-secrets",
+ "codex-state",
+ "codex-terminal-detection",
+ "codex-utils-absolute-path",
+ "codex-utils-output-truncation",
+ "codex-utils-template",
+ "core_test_support",
+ "futures",
+ "pretty_assertions",
+ "serde",
+ "serde_json",
+ "tempfile",
+ "tokio",
+ "tracing",
+ "uuid",
+ "wiremock",
+]
+
 [[package]]
 name = "codex-model-provider"
 version = "0.0.0"
@@ -3068,6 +3165,7 @@ dependencies = [
 name = "codex-plugin"
 version = "0.0.0"
 dependencies = [
+ "codex-config",
  "codex-utils-absolute-path",
  "codex-utils-plugins",
  "thiserror 2.0.18",
@@ -3119,6 +3217,7 @@ dependencies = [
  "tracing",
  "ts-rs",
  "uuid",
+ "wildmatch",
 ]
 
 [[package]]
@@ -3378,6 +3477,27 @@ dependencies = [
  "tempfile",
 ]
 
+[[package]]
+name = "codex-thread-manager-sample"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "codex-arg0",
+ "codex-config",
+ "codex-core",
+ "codex-exec-server",
+ "codex-features",
+ "codex-login",
+ "codex-model-provider-info",
+ "codex-models-manager",
+ "codex-protocol",
+ "codex-rollout",
+ "codex-thread-store",
+ "codex-utils-absolute-path",
+ "tracing",
+]
+
 [[package]]
 name = "codex-thread-store"
 version = "0.0.0"
@@ -4011,6 +4131,7 @@ dependencies = [
  "assert_cmd",
  "base64 0.22.1",
  "codex-arg0",
+ "codex-config",
  "codex-core",
  "codex-exec-server",
  "codex-features",
@@ -12230,6 +12351,16 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
 
+[[package]]
+name = "tar"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
+dependencies = [
+ "filetime",
+ "libc",
+]
+
 [[package]]
 name = "target-lexicon"
 version = "0.13.3"

codex-rs/Cargo.toml

@@ -36,9 +36,12 @@ members = [
     "hooks",
     "secrets",
     "exec",
+    "file-system",
     "exec-server",
     "execpolicy",
     "execpolicy-legacy",
+    "external-agent-migration",
+    "external-agent-sessions",
     "keyring-store",
     "file-search",
     "linux-sandbox",
@@ -46,6 +49,8 @@ members = [
     "login",
     "codex-mcp",
     "mcp-server",
+    "memories/read",
+    "memories/write",
     "model-provider-info",
     "models-manager",
     "network-proxy",
@@ -92,6 +97,7 @@ members = [
     "state",
     "terminal-detection",
     "test-binary-support",
+    "thread-manager-sample",
     "thread-store",
     "uds",
     "codex-experimental-api-macros",
@@ -140,8 +146,11 @@ codex-core-plugins = { path = "core-plugins" }
 codex-core-skills = { path = "core-skills" }
 codex-device-key = { path = "device-key" }
 codex-exec = { path = "exec" }
+codex-file-system = { path = "file-system" }
 codex-exec-server = { path = "exec-server" }
 codex-execpolicy = { path = "execpolicy" }
+codex-external-agent-migration = { path = "external-agent-migration" }
+codex-external-agent-sessions = { path = "external-agent-sessions" }
 codex-experimental-api-macros = { path = "codex-experimental-api-macros" }
 codex-features = { path = "features" }
 codex-feedback = { path = "feedback" }
@@ -153,6 +162,8 @@ codex-keyring-store = { path = "keyring-store" }
 codex-linux-sandbox = { path = "linux-sandbox" }
 codex-lmstudio = { path = "lmstudio" }
 codex-login = { path = "login" }
+codex-memories-read = { path = "memories/read" }
+codex-memories-write = { path = "memories/write" }
 codex-mcp = { path = "codex-mcp" }
 codex-mcp-server = { path = "mcp-server" }
 codex-model-provider-info = { path = "model-provider-info" }
@@ -254,6 +265,7 @@ encoding_rs = "0.8.35"
 env-flags = "0.1.1"
 env_logger = "0.11.9"
 eventsource-stream = "0.2.3"
+flate2 = "1.1.8"
 futures = { version = "0.3", default-features = false }
 gethostname = "1.1.0"
 gix = { version = "0.81.0", default-features = false, features = ["sha1"] }
@@ -346,6 +358,7 @@ strum_macros = "0.28.0"
 supports-color = "3.0.2"
 syntect = "5"
 sys-locale = "0.3.2"
+tar = { version = "=0.4.45", default-features = false }
 tempfile = "3.23.0"
 test-log = "0.2.19"
 textwrap = "0.16.2"

codex-rs/README.md

@@ -59,19 +59,22 @@ To test to see what happens when a command is run under the sandbox provided by
 
 ```
 # macOS
-codex sandbox macos [--full-auto] [--log-denials] [COMMAND]...
+codex sandbox macos [--log-denials] [COMMAND]...
 
 # Linux
-codex sandbox linux [--full-auto] [COMMAND]...
+codex sandbox linux [COMMAND]...
 
 # Windows
-codex sandbox windows [--full-auto] [COMMAND]...
+codex sandbox windows [COMMAND]...
 
 # Legacy aliases
-codex debug seatbelt [--full-auto] [--log-denials] [COMMAND]...
-codex debug landlock [--full-auto] [COMMAND]...
+codex debug seatbelt [--log-denials] [COMMAND]...
+codex debug landlock [COMMAND]...
 ```
 
+To try a writable legacy sandbox mode with these commands, pass an explicit config override such
+as `-c 'sandbox_mode="workspace-write"'`.
+
 ### Selecting a sandbox policy via `--sandbox`
 
 The Rust CLI exposes a dedicated `--sandbox` (`-s`) flag that lets you pick the sandbox policy **without** having to reach for the generic `-c/--config` option:

codex-rs/agent-identity/Cargo.toml

@@ -19,6 +19,7 @@ chrono = { workspace = true }
 codex-protocol = { workspace = true }
 crypto_box = { workspace = true }
 ed25519-dalek = { workspace = true }
+jsonwebtoken = { workspace = true }
 rand = { workspace = true }
 reqwest = { workspace = true, features = ["json"] }
 serde = { workspace = true, features = ["derive"] }

codex-rs/agent-identity/src/lib.rs

@@ -8,6 +8,7 @@ use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
 use base64::engine::general_purpose::URL_SAFE_NO_PAD;
 use chrono::SecondsFormat;
 use chrono::Utc;
+use codex_protocol::auth::PlanType as AuthPlanType;
 use codex_protocol::protocol::SessionSource;
 use crypto_box::SecretKey as Curve25519SecretKey;
 use ed25519_dalek::Signer as _;
@@ -15,14 +16,24 @@ use ed25519_dalek::SigningKey;
 use ed25519_dalek::VerifyingKey;
 use ed25519_dalek::pkcs8::DecodePrivateKey;
 use ed25519_dalek::pkcs8::EncodePrivateKey;
+use jsonwebtoken::Algorithm;
+use jsonwebtoken::DecodingKey;
+use jsonwebtoken::Validation;
+use jsonwebtoken::decode;
+use jsonwebtoken::decode_header;
+use jsonwebtoken::jwk::JwkSet;
 use rand::TryRngCore;
 use rand::rngs::OsRng;
 use serde::Deserialize;
 use serde::Serialize;
+use serde::de::DeserializeOwned;
 use sha2::Digest as _;
 use sha2::Sha512;
 
 const AGENT_TASK_REGISTRATION_TIMEOUT: Duration = Duration::from_secs(30);
+const AGENT_IDENTITY_JWKS_TIMEOUT: Duration = Duration::from_secs(10);
+const AGENT_IDENTITY_JWT_AUDIENCE: &str = "codex-app-server";
+const AGENT_IDENTITY_JWT_ISSUER: &str = "https://chatgpt.com/codex-backend/agent-identity";
 
 /// Stored key material for a registered agent identity.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -50,6 +61,22 @@ pub struct GeneratedAgentKeyMaterial {
     pub public_key_ssh: String,
 }
 
+/// Claims carried by an Agent Identity JWT.
+#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
+pub struct AgentIdentityJwtClaims {
+    pub iss: String,
+    pub aud: String,
+    pub iat: usize,
+    pub exp: usize,
+    pub agent_runtime_id: String,
+    pub agent_private_key: String,
+    pub account_id: String,
+    pub chatgpt_user_id: String,
+    pub email: String,
+    pub plan_type: AuthPlanType,
+    pub chatgpt_account_is_fedramp: bool,
+}
+
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 struct AgentAssertionEnvelope {
     agent_runtime_id: String,
@@ -98,6 +125,65 @@ pub fn authorization_header_for_agent_task(
     Ok(format!("AgentAssertion {serialized_assertion}"))
 }
 
+pub async fn fetch_agent_identity_jwks(
+    client: &reqwest::Client,
+    chatgpt_base_url: &str,
+) -> Result<JwkSet> {
+    let response = client
+        .get(agent_identity_jwks_url(chatgpt_base_url))
+        .timeout(AGENT_IDENTITY_JWKS_TIMEOUT)
+        .send()
+        .await
+        .context("failed to request agent identity JWKS")?
+        .error_for_status()
+        .context("agent identity JWKS endpoint returned an error")?;
+
+    response
+        .json()
+        .await
+        .context("failed to decode agent identity JWKS")
+}
+
+pub fn decode_agent_identity_jwt(
+    jwt: &str,
+    jwks: Option<&JwkSet>,
+) -> Result<AgentIdentityJwtClaims> {
+    let Some(jwks) = jwks else {
+        return decode_agent_identity_jwt_payload(jwt);
+    };
+
+    let header = decode_header(jwt).context("failed to decode agent identity JWT header")?;
+    let kid = header
+        .kid
+        .context("agent identity JWT header does not include a kid")?;
+    let jwk = jwks
+        .find(&kid)
+        .with_context(|| format!("agent identity JWT kid {kid} is not trusted"))?;
+    let decoding_key = DecodingKey::from_jwk(jwk).context("failed to build JWT decoding key")?;
+    let mut validation = Validation::new(Algorithm::RS256);
+    validation.set_audience(&[AGENT_IDENTITY_JWT_AUDIENCE]);
+    validation.set_issuer(&[AGENT_IDENTITY_JWT_ISSUER]);
+    validation.required_spec_claims.insert("iss".to_string());
+    validation.required_spec_claims.insert("aud".to_string());
+    decode::<AgentIdentityJwtClaims>(jwt, &decoding_key, &validation)
+        .map(|data| data.claims)
+        .context("failed to verify agent identity JWT")
+}
+
+fn decode_agent_identity_jwt_payload<T: DeserializeOwned>(jwt: &str) -> Result<T> {
+    let mut parts = jwt.split('.');
+    let (_header_b64, payload_b64, _sig_b64) = match (parts.next(), parts.next(), parts.next()) {
+        (Some(h), Some(p), Some(s)) if !h.is_empty() && !p.is_empty() && !s.is_empty() => (h, p, s),
+        _ => anyhow::bail!("invalid agent identity JWT format"),
+    };
+    anyhow::ensure!(parts.next().is_none(), "invalid agent identity JWT format");
+
+    let payload_bytes = URL_SAFE_NO_PAD
+        .decode(payload_b64)
+        .context("agent identity JWT payload is not valid base64url")?;
+    serde_json::from_slice(&payload_bytes).context("agent identity JWT payload is not valid JSON")
+}
+
 pub fn sign_task_registration_payload(
     key: AgentIdentityKey<'_>,
     timestamp: &str,
@@ -117,19 +203,27 @@ pub async fn register_agent_task(
         signature: sign_task_registration_payload(key, &timestamp)?,
         timestamp,
     };
+    let url = agent_task_registration_url(chatgpt_base_url, key.agent_runtime_id);
 
     let response = client
-        .post(agent_task_registration_url(
-            chatgpt_base_url,
-            key.agent_runtime_id,
-        ))
+        .post(url)
         .timeout(AGENT_TASK_REGISTRATION_TIMEOUT)
         .json(&request)
         .send()
         .await
-        .context("failed to register agent task")?
-        .error_for_status()
-        .context("failed to register agent task")?
+        .context("failed to register agent task")?;
+    if !response.status().is_success() {
+        let status = response.status();
+        let body = response.text().await.unwrap_or_default();
+        let body = if body.len() > 512 {
+            format!("{}...", body.chars().take(512).collect::<String>())
+        } else {
+            body
+        };
+        anyhow::bail!("failed to register agent task with status {status}: {body}");
+    }
+
+    let response = response
         .json()
         .await
         .context("failed to decode agent task registration response")?;
@@ -217,6 +311,15 @@ pub fn agent_identity_biscuit_url(chatgpt_base_url: &str) -> String {
     format!("{trimmed}/authenticate_app_v2")
 }
 
+pub fn agent_identity_jwks_url(chatgpt_base_url: &str) -> String {
+    let trimmed = chatgpt_base_url.trim_end_matches('/');
+    if trimmed.contains("/backend-api") {
+        format!("{trimmed}/wham/agent-identities/jwks")
+    } else {
+        format!("{trimmed}/agent-identities/jwks")
+    }
+}
+
 pub fn agent_identity_request_id() -> Result<String> {
     let mut request_id_bytes = [0u8; 16];
     OsRng
@@ -228,29 +331,6 @@ pub fn agent_identity_request_id() -> Result<String> {
     ))
 }
 
-pub fn normalize_chatgpt_base_url(chatgpt_base_url: &str) -> String {
-    let mut base_url = chatgpt_base_url.trim_end_matches('/').to_string();
-    for suffix in [
-        "/wham/remote/control/server/enroll",
-        "/wham/remote/control/server",
-    ] {
-        if let Some(stripped) = base_url.strip_suffix(suffix) {
-            base_url = stripped.to_string();
-            break;
-        }
-    }
-    if let Some(stripped) = base_url.strip_suffix("/codex") {
-        base_url = stripped.to_string();
-    }
-    if (base_url.starts_with("https://chatgpt.com")
-        || base_url.starts_with("https://chat.openai.com"))
-        && !base_url.contains("/backend-api")
-    {
-        base_url = format!("{base_url}/backend-api");
-    }
-    base_url
-}
-
 pub fn build_abom(session_source: SessionSource) -> AgentBillOfMaterials {
     AgentBillOfMaterials {
         agent_version: env!("CARGO_PKG_VERSION").to_string(),
@@ -260,6 +340,7 @@ pub fn build_abom(session_source: SessionSource) -> AgentBillOfMaterials {
             | SessionSource::Exec
             | SessionSource::Mcp
             | SessionSource::Custom(_)
+            | SessionSource::Internal(_)
             | SessionSource::SubAgent(_)
             | SessionSource::Unknown => "codex-cli".to_string(),
         },
@@ -323,8 +404,12 @@ mod tests {
     use base64::Engine as _;
     use ed25519_dalek::Signature;
     use ed25519_dalek::Verifier as _;
+    use jsonwebtoken::EncodingKey;
+    use jsonwebtoken::Header;
     use pretty_assertions::assert_eq;
 
+    use codex_protocol::auth::KnownPlan;
+
     use super::*;
 
     #[test]
@@ -405,10 +490,248 @@ mod tests {
     }
 
     #[test]
-    fn normalize_chatgpt_base_url_strips_codex_before_backend_api() {
+    fn decode_agent_identity_jwt_reads_claims() {
+        let jwt = jwt_with_payload(serde_json::json!({
+            "iss": AGENT_IDENTITY_JWT_ISSUER,
+            "aud": AGENT_IDENTITY_JWT_AUDIENCE,
+            "iat": 1_700_000_000usize,
+            "exp": 4_000_000_000usize,
+            "agent_runtime_id": "agent-runtime-id",
+            "agent_private_key": "private-key",
+            "account_id": "account-id",
+            "chatgpt_user_id": "user-id",
+            "email": "user@example.com",
+            "plan_type": "pro",
+            "chatgpt_account_is_fedramp": false,
+        }));
+
+        let claims = decode_agent_identity_jwt(&jwt, /*jwks*/ None).expect("JWT should decode");
+
         assert_eq!(
-            normalize_chatgpt_base_url("https://chatgpt.com/codex"),
-            "https://chatgpt.com/backend-api"
+            claims,
+            AgentIdentityJwtClaims {
+                iss: AGENT_IDENTITY_JWT_ISSUER.to_string(),
+                aud: AGENT_IDENTITY_JWT_AUDIENCE.to_string(),
+                iat: 1_700_000_000,
+                exp: 4_000_000_000,
+                agent_runtime_id: "agent-runtime-id".to_string(),
+                agent_private_key: "private-key".to_string(),
+                account_id: "account-id".to_string(),
+                chatgpt_user_id: "user-id".to_string(),
+                email: "user@example.com".to_string(),
+                plan_type: AuthPlanType::Known(KnownPlan::Pro),
+                chatgpt_account_is_fedramp: false,
+            }
         );
     }
+
+    #[test]
+    fn decode_agent_identity_jwt_maps_raw_plan_aliases() {
+        let jwt = jwt_with_payload(serde_json::json!({
+            "iss": AGENT_IDENTITY_JWT_ISSUER,
+            "aud": AGENT_IDENTITY_JWT_AUDIENCE,
+            "iat": 1_700_000_000usize,
+            "exp": 4_000_000_000usize,
+            "agent_runtime_id": "agent-runtime-id",
+            "agent_private_key": "private-key",
+            "account_id": "account-id",
+            "chatgpt_user_id": "user-id",
+            "email": "user@example.com",
+            "plan_type": "hc",
+            "chatgpt_account_is_fedramp": false,
+        }));
+
+        let claims = decode_agent_identity_jwt(&jwt, /*jwks*/ None).expect("JWT should decode");
+
+        assert_eq!(claims.plan_type, AuthPlanType::Known(KnownPlan::Enterprise));
+    }
+
+    #[test]
+    fn decode_agent_identity_jwt_verifies_when_jwks_is_present() {
+        let jwks = test_jwks("test-key");
+        let claims = AgentIdentityJwtClaims {
+            iss: AGENT_IDENTITY_JWT_ISSUER.to_string(),
+            aud: AGENT_IDENTITY_JWT_AUDIENCE.to_string(),
+            iat: 1_700_000_000,
+            exp: 4_000_000_000,
+            agent_runtime_id: "agent-runtime-id".to_string(),
+            agent_private_key: "private-key".to_string(),
+            account_id: "account-id".to_string(),
+            chatgpt_user_id: "user-id".to_string(),
+            email: "user@example.com".to_string(),
+            plan_type: AuthPlanType::Known(KnownPlan::Pro),
+            chatgpt_account_is_fedramp: false,
+        };
+        let jwt = jsonwebtoken::encode(
+            &test_jwt_header("test-key"),
+            &serde_json::json!({
+                "iss": claims.iss,
+                "aud": claims.aud,
+                "iat": claims.iat,
+                "exp": claims.exp,
+                "agent_runtime_id": claims.agent_runtime_id,
+                "agent_private_key": claims.agent_private_key,
+                "account_id": claims.account_id,
+                "chatgpt_user_id": claims.chatgpt_user_id,
+                "email": claims.email,
+                "plan_type": "pro",
+                "chatgpt_account_is_fedramp": claims.chatgpt_account_is_fedramp,
+            }),
+            &test_rsa_encoding_key(),
+        )
+        .expect("JWT should encode");
+
+        let expected_claims = AgentIdentityJwtClaims {
+            iss: AGENT_IDENTITY_JWT_ISSUER.to_string(),
+            aud: AGENT_IDENTITY_JWT_AUDIENCE.to_string(),
+            iat: 1_700_000_000,
+            exp: 4_000_000_000,
+            agent_runtime_id: "agent-runtime-id".to_string(),
+            agent_private_key: "private-key".to_string(),
+            account_id: "account-id".to_string(),
+            chatgpt_user_id: "user-id".to_string(),
+            email: "user@example.com".to_string(),
+            plan_type: AuthPlanType::Known(KnownPlan::Pro),
+            chatgpt_account_is_fedramp: false,
+        };
+        assert_eq!(
+            decode_agent_identity_jwt(&jwt, Some(&jwks)).expect("JWT should verify"),
+            expected_claims
+        );
+    }
+
+    #[test]
+    fn decode_agent_identity_jwt_rejects_untrusted_kid() {
+        let jwks = test_jwks("other-key");
+
+        let jwt = jsonwebtoken::encode(
+            &test_jwt_header("test-key"),
+            &serde_json::json!({
+                "iss": AGENT_IDENTITY_JWT_ISSUER,
+                "aud": AGENT_IDENTITY_JWT_AUDIENCE,
+                "iat": 1_700_000_000,
+                "exp": 4_000_000_000usize,
+                "agent_runtime_id": "agent-runtime-id",
+                "agent_private_key": "private-key",
+                "account_id": "account-id",
+                "chatgpt_user_id": "user-id",
+                "email": "user@example.com",
+                "plan_type": "pro",
+                "chatgpt_account_is_fedramp": false,
+            }),
+            &test_rsa_encoding_key(),
+        )
+        .expect("JWT should encode");
+
+        decode_agent_identity_jwt(&jwt, Some(&jwks)).expect_err("JWT should not verify");
+    }
+
+    #[test]
+    fn decode_agent_identity_jwt_requires_issuer_and_audience() {
+        let jwks = test_jwks("test-key");
+        let jwt = jsonwebtoken::encode(
+            &test_jwt_header("test-key"),
+            &serde_json::json!({
+                "iat": 1_700_000_000,
+                "exp": 4_000_000_000usize,
+                "agent_runtime_id": "agent-runtime-id",
+                "agent_private_key": "private-key",
+                "account_id": "account-id",
+                "chatgpt_user_id": "user-id",
+                "email": "user@example.com",
+                "plan_type": "pro",
+                "chatgpt_account_is_fedramp": false,
+            }),
+            &test_rsa_encoding_key(),
+        )
+        .expect("JWT should encode");
+
+        decode_agent_identity_jwt(&jwt, Some(&jwks)).expect_err("JWT should not verify");
+    }
+
+    fn test_jwt_header(kid: &str) -> Header {
+        let mut header = Header::new(Algorithm::RS256);
+        header.kid = Some(kid.to_string());
+        header
+    }
+
+    fn test_rsa_encoding_key() -> EncodingKey {
+        EncodingKey::from_rsa_pem(
+            br#"-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDWpAXYypOsYAwO
+bvBduMk/mxaoYDze0AZSzaSzLuIlcsl2EKDgC3AabhIWXh/qTGEJLOU3VB1e5mO9
+FPbBlmIZSL3FQTbyt/hYutPFKfCou5PLmScw/TzILS3/RhT8UY9kxxZvXiEbTki9
+mvxRuZFpVqDFJHwfitIjKZGhXDCYVKurPTrxetYZJg0h8sQBLKjkZ0BqqaTUkAsg
+0eBgZAlXEzG3By8PGhUqYLt6W1Q3KYw0FmGy/gTyzH1g0ukGgSJvOd8SkNT8MbOs
+zl5kKxDNqpuEE6UZ3jbuJ+5382d31w+rOAJRzbf7QVdI9+luCSwJcDACYPQ4WNBa
+uCpV0ovpAgMBAAECggEAVu84LwZdqYN9XpswX8VoPYrjMm9IODapWQBRpQFoNyK2
+1ksF3bjEPvA2Azk8U/l7k+vLKw22l6lY3EyRZPcz5GnB8xLm3ogE3mtNOp4yCyVu
+RxhQ91aaN7mU17/a4BdorLi2LYVCg3zBmYociD1Q2AluNGsCmwPu+K7tfR2J0Sg8
+NjqiTbDG1XDpR/icwgC9t6vh8lZpCHDhF4tbQfLLVLeA/OdcuzXDyMCXbmdVIdBQ
+rm4aIFmr2e1/2ctTbCg85S6AGFTH+pSLjrwTzyvf+F6NW5uNjLQAQLFj+EznBDxj
+Xdx90cySrjsKK6PVWQF4RiTvkSW8eWL7R6B2FZbGwQKBgQDuVQRj72hWloR7mbEL
+aUEEv3pIXTMXWEsoMBNczos/1L1RnAN1AI44TurznasPZAWvQj+kVbLDR+TAeZrL
+iA8HIWswQUI18hFmgKzSkwIXGtubcKVrgsKeS4lMDKCM/Ef6WAYdeq6ronoY5lCN
+YrJFmGp81W5zcV7lyiycgbSiGwKBgQDmjWYf6pZjrK7Z+OJ3X1AZfi2vss15SCvL
+3fPgzIDbViztpGyQhc3DQZIsBNIu0xZp/veGce9TEeTds2ro9NfdJFeou8+fC7Pq
+sOsM3amGFFi+ZW/9BWyjZEM88bgWWAjqLHbpfHDxjAf5CSxddqxgHlbP0Ytyb1Vg
+gmPDn9YKSwKBgQDbTi3hC35WFuDHn0/zcSHcDZmnFuOZeqyFyV83yfMGhGrEuqvP
+sPgtRikajJ3IZsB4WZyYSidZXEFY/0z6NjOl2xF38MTNQPbT/FmK1q1Yt2UWrlv5
+BvSwlk87RG9D7C0LZo4R+D7cPoDdgqjiwMvMEIkEX5zn641oI1ZTmWKuuwKBgQCD
+KF+3unnRvHRAVoFnTZbA2fJdqMeRvogD04GhGlYX8V9f1hFY6nXTJaNlXVzA/J8c
+r8ra9kgjJuPfZ+ljG58OFFW2DRohLcQtuHYPfK6rMzoFHqnl9EcIcMp7ijuionR3
+29HOJFgQYgxLFXfit9d6WugiE+BTupiEbckZif13HwKBgE/lAlkVHP6YahOO2Ljc
+J1bwkqKZTB5dHolX9A58e/xXnfZ5P8f3Z83+Izap3FwqQulk7b1WO1MQcHuVg2NN
+5da0D4h2rYOXnbYIg0BVu4spQbaM6ewsp66b8+MzLOBvj8SzWdt1Oyw0q/MRyQAR
+8U4M2TSWCKUY/A6sT4W8+mT9
+-----END PRIVATE KEY-----"#,
+        )
+        .expect("test RSA key should parse")
+    }
+
+    fn test_jwks(kid: &str) -> jsonwebtoken::jwk::JwkSet {
+        serde_json::from_value(serde_json::json!({
+            "keys": [{
+                "kty": "RSA",
+                "kid": kid,
+                "use": "sig",
+                "alg": "RS256",
+                "n": "1qQF2MqTrGAMDm7wXbjJP5sWqGA83tAGUs2ksy7iJXLJdhCg4AtwGm4SFl4f6kxhCSzlN1QdXuZjvRT2wZZiGUi9xUE28rf4WLrTxSnwqLuTy5knMP08yC0t_0YU_FGPZMcWb14hG05IvZr8UbmRaVagxSR8H4rSIymRoVwwmFSrqz068XrWGSYNIfLEASyo5GdAaqmk1JALINHgYGQJVxMxtwcvDxoVKmC7eltUNymMNBZhsv4E8sx9YNLpBoEibznfEpDU_DGzrM5eZCsQzaqbhBOlGd427ifud_Nnd9cPqzgCUc23-0FXSPfpbgksCXAwAmD0OFjQWrgqVdKL6Q",
+                "e": "AQAB",
+            }]
+        }))
+        .expect("test JWKS should parse")
+    }
+
+    #[test]
+    fn agent_identity_jwks_url_uses_backend_api_base_url() {
+        assert_eq!(
+            agent_identity_jwks_url("https://chatgpt.com/backend-api"),
+            "https://chatgpt.com/backend-api/wham/agent-identities/jwks"
+        );
+        assert_eq!(
+            agent_identity_jwks_url("https://chatgpt.com/backend-api/"),
+            "https://chatgpt.com/backend-api/wham/agent-identities/jwks"
+        );
+    }
+
+    #[test]
+    fn agent_identity_jwks_url_uses_codex_api_base_url() {
+        assert_eq!(
+            agent_identity_jwks_url("http://localhost:8080/api/codex"),
+            "http://localhost:8080/api/codex/agent-identities/jwks"
+        );
+        assert_eq!(
+            agent_identity_jwks_url("http://localhost:8080/api/codex/"),
+            "http://localhost:8080/api/codex/agent-identities/jwks"
+        );
+    }
+
+    fn jwt_with_payload(payload: serde_json::Value) -> String {
+        let encode = |bytes: &[u8]| URL_SAFE_NO_PAD.encode(bytes);
+        let header_b64 = encode(br#"{"alg":"none","typ":"JWT"}"#);
+        let payload_b64 = encode(&serde_json::to_vec(&payload).expect("payload should serialize"));
+        let signature_b64 = encode(b"sig");
+        format!("{header_b64}.{payload_b64}.{signature_b64}")
+    }
 }

codex-rs/analytics/src/analytics_client_tests.rs

@@ -161,7 +161,7 @@ fn sample_thread_start_response(thread_id: &str, ephemeral: bool, model: &str) -
 }
 
 fn sample_permission_profile() -> AppServerPermissionProfile {
-    CorePermissionProfile::from_legacy_sandbox_policy(&SandboxPolicy::DangerFullAccess).into()
+    CorePermissionProfile::Disabled.into()
 }
 
 fn sample_app_server_client_metadata() -> CodexAppServerClientMetadata {
@@ -315,7 +315,10 @@ fn sample_turn_resolved_config(turn_id: &str) -> TurnResolvedConfigFact {
         session_source: SessionSource::Exec,
         model: "gpt-5".to_string(),
         model_provider: "openai".to_string(),
-        sandbox_policy: SandboxPolicy::new_read_only_policy(),
+        permission_profile: CorePermissionProfile::from_legacy_sandbox_policy(
+            &SandboxPolicy::new_read_only_policy(),
+        ),
+        permission_profile_cwd: PathBuf::from("/tmp"),
         reasoning_effort: None,
         reasoning_summary: None,
         service_tier: None,
@@ -423,7 +426,7 @@ async fn ingest_rejected_turn_steer(
     .await;
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(4),
                 request: Box::new(sample_turn_steer_request(
@@ -483,7 +486,7 @@ async fn ingest_turn_prerequisites(
         ingest_initialize(reducer, out).await;
         reducer
             .ingest(
-                AnalyticsFact::Response {
+                AnalyticsFact::ClientResponse {
                     connection_id: 7,
                     response: Box::new(sample_thread_start_response(
                         "thread-2", /*ephemeral*/ false, "gpt-5",
@@ -497,7 +500,7 @@ async fn ingest_turn_prerequisites(
 
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(3),
                 request: Box::new(sample_turn_start_request("thread-2", /*request_id*/ 3)),
@@ -507,7 +510,7 @@ async fn ingest_turn_prerequisites(
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_turn_start_response("turn-2", /*request_id*/ 3)),
             },
@@ -859,7 +862,7 @@ async fn initialize_caches_client_and_thread_lifecycle_publishes_once_initialize
 
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_thread_start_response(
                     "thread-no-client",
@@ -903,7 +906,7 @@ async fn initialize_caches_client_and_thread_lifecycle_publishes_once_initialize
 
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_thread_resume_response(
                     "thread-1", /*ephemeral*/ true, "gpt-5",
@@ -983,7 +986,7 @@ async fn compaction_event_ingests_custom_fact() {
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_thread_resume_response_with_source(
                     "thread-1",
@@ -1094,7 +1097,7 @@ async fn guardian_review_event_ingests_custom_fact_with_optional_target_item() {
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_thread_start_response(
                     "thread-guardian",
@@ -1864,7 +1867,7 @@ async fn accepted_turn_steer_emits_expected_event() {
     .await;
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(4),
                 request: Box::new(sample_turn_steer_request(
@@ -1876,7 +1879,7 @@ async fn accepted_turn_steer_emits_expected_event() {
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_turn_steer_response("turn-2", /*request_id*/ 4)),
             },
@@ -2018,7 +2021,7 @@ async fn turn_start_error_response_discards_pending_start_request() {
     ingest_initialize(&mut reducer, &mut out).await;
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(3),
                 request: Box::new(sample_turn_start_request("thread-2", /*request_id*/ 3)),
@@ -2042,7 +2045,7 @@ async fn turn_start_error_response_discards_pending_start_request() {
     // failed turn/start request and attach request-scoped connection metadata.
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_turn_start_response("turn-2", /*request_id*/ 3)),
             },
@@ -2159,7 +2162,7 @@ async fn accepted_steers_increment_turn_steer_count() {
 
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(4),
                 request: Box::new(sample_turn_steer_request(
@@ -2171,7 +2174,7 @@ async fn accepted_steers_increment_turn_steer_count() {
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_turn_steer_response("turn-2", /*request_id*/ 4)),
             },
@@ -2181,7 +2184,7 @@ async fn accepted_steers_increment_turn_steer_count() {
 
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(5),
                 request: Box::new(sample_turn_steer_request(
@@ -2205,7 +2208,7 @@ async fn accepted_steers_increment_turn_steer_count() {
 
     reducer
         .ingest(
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id: 7,
                 request_id: RequestId::Integer(6),
                 request: Box::new(sample_turn_steer_request(
@@ -2217,7 +2220,7 @@ async fn accepted_steers_increment_turn_steer_count() {
         .await;
     reducer
         .ingest(
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id: 7,
                 response: Box::new(sample_turn_steer_response("turn-2", /*request_id*/ 6)),
             },

codex-rs/analytics/src/client.rs

@@ -27,6 +27,8 @@ use codex_app_server_protocol::InitializeParams;
 use codex_app_server_protocol::JSONRPCErrorError;
 use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::ServerNotification;
+use codex_app_server_protocol::ServerRequest;
+use codex_app_server_protocol::ServerResponse;
 use codex_login::AuthManager;
 use codex_login::default_client::create_client;
 use codex_plugin::PluginTelemetryMetadata;
@@ -49,8 +51,7 @@ pub(crate) struct AnalyticsEventsQueue {
 
 #[derive(Clone)]
 pub struct AnalyticsEventsClient {
-    queue: AnalyticsEventsQueue,
-    analytics_enabled: Option<bool>,
+    queue: Option<AnalyticsEventsQueue>,
 }
 
 impl AnalyticsEventsQueue {
@@ -119,11 +120,15 @@ impl AnalyticsEventsClient {
         analytics_enabled: Option<bool>,
     ) -> Self {
         Self {
-            queue: AnalyticsEventsQueue::new(Arc::clone(&auth_manager), base_url),
-            analytics_enabled,
+            queue: (analytics_enabled != Some(false))
+                .then(|| AnalyticsEventsQueue::new(Arc::clone(&auth_manager), base_url)),
         }
     }
 
+    pub fn disabled() -> Self {
+        Self { queue: None }
+    }
+
     pub fn track_skill_invocations(
         &self,
         tracking: TrackEventsContext,
@@ -181,16 +186,30 @@ impl AnalyticsEventsClient {
         )));
     }
 
-    pub fn track_request(&self, connection_id: u64, request_id: RequestId, request: ClientRequest) {
-        self.record_fact(AnalyticsFact::Request {
+    pub fn track_request(
+        &self,
+        connection_id: u64,
+        request_id: RequestId,
+        request: &ClientRequest,
+    ) {
+        if !matches!(
+            request,
+            ClientRequest::TurnStart { .. } | ClientRequest::TurnSteer { .. }
+        ) {
+            return;
+        }
+        self.record_fact(AnalyticsFact::ClientRequest {
             connection_id,
             request_id,
-            request: Box::new(request),
+            request: Box::new(request.clone()),
         });
     }
 
     pub fn track_app_used(&self, tracking: TrackEventsContext, app: AppInvocation) {
-        if !self.queue.should_enqueue_app_used(&tracking, &app) {
+        let Some(queue) = self.queue.as_ref() else {
+            return;
+        };
+        if !queue.should_enqueue_app_used(&tracking, &app) {
             return;
         }
         self.record_fact(AnalyticsFact::Custom(CustomAnalyticsFact::AppUsed(
@@ -205,7 +224,10 @@ impl AnalyticsEventsClient {
     }
 
     pub fn track_plugin_used(&self, tracking: TrackEventsContext, plugin: PluginTelemetryMetadata) {
-        if !self.queue.should_enqueue_plugin_used(&tracking, &plugin) {
+        let Some(queue) = self.queue.as_ref() else {
+            return;
+        };
+        if !queue.should_enqueue_plugin_used(&tracking, &plugin) {
             return;
         }
         self.record_fact(AnalyticsFact::Custom(CustomAnalyticsFact::PluginUsed(
@@ -268,14 +290,13 @@ impl AnalyticsEventsClient {
     }
 
     pub(crate) fn record_fact(&self, input: AnalyticsFact) {
-        if self.analytics_enabled == Some(false) {
-            return;
+        if let Some(queue) = self.queue.as_ref() {
+            queue.try_send(input);
         }
-        self.queue.try_send(input);
     }
 
     pub fn track_response(&self, connection_id: u64, response: ClientResponse) {
-        self.record_fact(AnalyticsFact::Response {
+        self.record_fact(AnalyticsFact::ClientResponse {
             connection_id,
             response: Box::new(response),
         });
@@ -299,8 +320,25 @@ impl AnalyticsEventsClient {
     pub fn track_notification(&self, notification: ServerNotification) {
         self.record_fact(AnalyticsFact::Notification(Box::new(notification)));
     }
+
+    pub fn track_server_request(&self, connection_id: u64, request: ServerRequest) {
+        self.record_fact(AnalyticsFact::ServerRequest {
+            connection_id,
+            request: Box::new(request),
+        });
+    }
+
+    pub fn track_server_response(&self, response: ServerResponse) {
+        self.record_fact(AnalyticsFact::ServerResponse {
+            response: Box::new(response),
+        });
+    }
 }
 
+#[cfg(test)]
+#[path = "client_tests.rs"]
+mod tests;
+
 async fn send_track_events(
     auth_manager: &AuthManager,
     base_url: &str,

codex-rs/analytics/src/client_tests.rs

@@ -0,0 +1,79 @@
+use super::AnalyticsEventsClient;
+use super::AnalyticsEventsQueue;
+use crate::facts::AnalyticsFact;
+use codex_app_server_protocol::ClientRequest;
+use codex_app_server_protocol::RequestId;
+use codex_app_server_protocol::ThreadArchiveParams;
+use codex_app_server_protocol::TurnStartParams;
+use codex_app_server_protocol::TurnSteerParams;
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::sync::Mutex;
+use tokio::sync::mpsc;
+use tokio::sync::mpsc::error::TryRecvError;
+
+fn client_with_receiver() -> (AnalyticsEventsClient, mpsc::Receiver<AnalyticsFact>) {
+    let (sender, receiver) = mpsc::channel(4);
+    let queue = AnalyticsEventsQueue {
+        sender,
+        app_used_emitted_keys: Arc::new(Mutex::new(HashSet::new())),
+        plugin_used_emitted_keys: Arc::new(Mutex::new(HashSet::new())),
+    };
+    (AnalyticsEventsClient { queue: Some(queue) }, receiver)
+}
+
+fn sample_turn_start_request() -> ClientRequest {
+    ClientRequest::TurnStart {
+        request_id: RequestId::Integer(1),
+        params: TurnStartParams {
+            thread_id: "thread-1".to_string(),
+            input: Vec::new(),
+            ..Default::default()
+        },
+    }
+}
+
+fn sample_turn_steer_request() -> ClientRequest {
+    ClientRequest::TurnSteer {
+        request_id: RequestId::Integer(2),
+        params: TurnSteerParams {
+            thread_id: "thread-1".to_string(),
+            expected_turn_id: "turn-1".to_string(),
+            input: Vec::new(),
+            responsesapi_client_metadata: None,
+        },
+    }
+}
+
+fn sample_thread_archive_request() -> ClientRequest {
+    ClientRequest::ThreadArchive {
+        request_id: RequestId::Integer(3),
+        params: ThreadArchiveParams {
+            thread_id: "thread-1".to_string(),
+        },
+    }
+}
+
+#[test]
+fn track_request_only_enqueues_analytics_relevant_requests() {
+    let (client, mut receiver) = client_with_receiver();
+
+    for (request_id, request) in [
+        (RequestId::Integer(1), sample_turn_start_request()),
+        (RequestId::Integer(2), sample_turn_steer_request()),
+    ] {
+        client.track_request(/*connection_id*/ 7, request_id, &request);
+        assert!(matches!(
+            receiver.try_recv(),
+            Ok(AnalyticsFact::ClientRequest { .. })
+        ));
+    }
+
+    let ignored_request = sample_thread_archive_request();
+    client.track_request(
+        /*connection_id*/ 7,
+        RequestId::Integer(3),
+        &ignored_request,
+    );
+    assert!(matches!(receiver.try_recv(), Err(TryRecvError::Empty)));
+}

codex-rs/analytics/src/events.rs

@@ -684,6 +684,7 @@ fn analytics_hook_source(source: HookSource) -> &'static str {
         HookSource::Project => "project",
         HookSource::Mdm => "mdm",
         HookSource::SessionFlags => "session_flags",
+        HookSource::Plugin => "plugin",
         HookSource::LegacyManagedConfigFile => "legacy_managed_config_file",
         HookSource::LegacyManagedConfigMdm => "legacy_managed_config_mdm",
         HookSource::Unknown => "unknown",

codex-rs/analytics/src/facts.rs

@@ -7,18 +7,20 @@ use codex_app_server_protocol::InitializeParams;
 use codex_app_server_protocol::JSONRPCErrorError;
 use codex_app_server_protocol::RequestId;
 use codex_app_server_protocol::ServerNotification;
+use codex_app_server_protocol::ServerRequest;
+use codex_app_server_protocol::ServerResponse;
 use codex_plugin::PluginTelemetryMetadata;
 use codex_protocol::config_types::ApprovalsReviewer;
 use codex_protocol::config_types::ModeKind;
 use codex_protocol::config_types::Personality;
 use codex_protocol::config_types::ReasoningSummary;
 use codex_protocol::config_types::ServiceTier;
+use codex_protocol::models::PermissionProfile;
 use codex_protocol::openai_models::ReasoningEffort;
 use codex_protocol::protocol::AskForApproval;
 use codex_protocol::protocol::HookEventName;
 use codex_protocol::protocol::HookRunStatus;
 use codex_protocol::protocol::HookSource;
-use codex_protocol::protocol::SandboxPolicy;
 use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::SkillScope;
 use codex_protocol::protocol::SubAgentSource;
@@ -62,7 +64,8 @@ pub struct TurnResolvedConfigFact {
     pub session_source: SessionSource,
     pub model: String,
     pub model_provider: String,
-    pub sandbox_policy: SandboxPolicy,
+    pub permission_profile: PermissionProfile,
+    pub permission_profile_cwd: PathBuf,
     pub reasoning_effort: Option<ReasoningEffort>,
     pub reasoning_summary: Option<ReasoningSummary>,
     pub service_tier: Option<ServiceTier>,
@@ -271,12 +274,12 @@ pub(crate) enum AnalyticsFact {
         runtime: CodexRuntimeMetadata,
         rpc_transport: AppServerRpcTransport,
     },
-    Request {
+    ClientRequest {
         connection_id: u64,
         request_id: RequestId,
         request: Box<ClientRequest>,
     },
-    Response {
+    ClientResponse {
         connection_id: u64,
         response: Box<ClientResponse>,
     },
@@ -286,6 +289,13 @@ pub(crate) enum AnalyticsFact {
         error: JSONRPCErrorError,
         error_type: Option<AnalyticsJsonRpcError>,
     },
+    ServerRequest {
+        connection_id: u64,
+        request: Box<ServerRequest>,
+    },
+    ServerResponse {
+        response: Box<ServerResponse>,
+    },
     Notification(Box<ServerNotification>),
     // Facts that do not naturally exist on the app-server protocol surface, or
     // would require non-trivial protocol reshaping on this branch.

codex-rs/analytics/src/reducer.rs

@@ -61,7 +61,7 @@ use codex_login::default_client::originator;
 use codex_protocol::config_types::ModeKind;
 use codex_protocol::config_types::Personality;
 use codex_protocol::config_types::ReasoningSummary;
-use codex_protocol::protocol::SandboxPolicy;
+use codex_protocol::models::PermissionProfile;
 use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::SkillScope;
 use codex_protocol::protocol::TokenUsage;
@@ -106,6 +106,7 @@ impl ThreadMetadataState {
             | SessionSource::Exec
             | SessionSource::Mcp
             | SessionSource::Custom(_)
+            | SessionSource::Internal(_)
             | SessionSource::Unknown => (None, None),
         };
         Self {
@@ -171,14 +172,14 @@ impl AnalyticsReducer {
                     rpc_transport,
                 );
             }
-            AnalyticsFact::Request {
+            AnalyticsFact::ClientRequest {
                 connection_id,
                 request_id,
                 request,
             } => {
                 self.ingest_request(connection_id, request_id, *request);
             }
-            AnalyticsFact::Response {
+            AnalyticsFact::ClientResponse {
                 connection_id,
                 response,
             } => {
@@ -195,6 +196,13 @@ impl AnalyticsReducer {
             AnalyticsFact::Notification(notification) => {
                 self.ingest_notification(*notification, out);
             }
+            AnalyticsFact::ServerRequest {
+                connection_id: _connection_id,
+                request: _request,
+            } => {}
+            AnalyticsFact::ServerResponse {
+                response: _response,
+            } => {}
             AnalyticsFact::Custom(input) => match input {
                 CustomAnalyticsFact::SubAgentThreadStarted(input) => {
                     self.ingest_subagent_thread_started(input, out);
@@ -884,7 +892,8 @@ fn codex_turn_event_params(
         session_source: _session_source,
         model,
         model_provider,
-        sandbox_policy,
+        permission_profile,
+        permission_profile_cwd,
         reasoning_effort,
         reasoning_summary,
         service_tier,
@@ -909,7 +918,10 @@ fn codex_turn_event_params(
         parent_thread_id: thread_metadata.parent_thread_id.clone(),
         model: Some(model),
         model_provider,
-        sandbox_policy: Some(sandbox_policy_mode(&sandbox_policy)),
+        sandbox_policy: Some(sandbox_policy_mode(
+            &permission_profile,
+            permission_profile_cwd.as_path(),
+        )),
         reasoning_effort: reasoning_effort.map(|value| value.to_string()),
         reasoning_summary: reasoning_summary_mode(reasoning_summary),
         service_tier: service_tier
@@ -954,12 +966,27 @@ fn codex_turn_event_params(
     }
 }
 
-fn sandbox_policy_mode(sandbox_policy: &SandboxPolicy) -> &'static str {
-    match sandbox_policy {
-        SandboxPolicy::DangerFullAccess => "full_access",
-        SandboxPolicy::ReadOnly { .. } => "read_only",
-        SandboxPolicy::WorkspaceWrite { .. } => "workspace_write",
-        SandboxPolicy::ExternalSandbox { .. } => "external_sandbox",
+fn sandbox_policy_mode(permission_profile: &PermissionProfile, cwd: &Path) -> &'static str {
+    match permission_profile {
+        PermissionProfile::Disabled => "full_access",
+        PermissionProfile::External { .. } => "external_sandbox",
+        PermissionProfile::Managed { .. } => {
+            let file_system_policy = permission_profile.file_system_sandbox_policy();
+            if file_system_policy.has_full_disk_write_access() {
+                if permission_profile.network_sandbox_policy().is_enabled() {
+                    "full_access"
+                } else {
+                    "external_sandbox"
+                }
+            } else if file_system_policy
+                .get_writable_roots_with_cwd(cwd)
+                .is_empty()
+            {
+                "read_only"
+            } else {
+                "workspace_write"
+            }
+        }
     }
 }
 
@@ -1050,3 +1077,25 @@ pub(crate) fn normalize_path_for_skill_id(
         _ => resolved_path.to_string_lossy().replace('\\', "/"),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use codex_protocol::models::SandboxEnforcement;
+    use codex_protocol::permissions::FileSystemSandboxPolicy;
+    use codex_protocol::permissions::NetworkSandboxPolicy;
+
+    #[test]
+    fn managed_full_disk_with_restricted_network_reports_external_sandbox() {
+        let permission_profile = PermissionProfile::from_runtime_permissions_with_enforcement(
+            SandboxEnforcement::Managed,
+            &FileSystemSandboxPolicy::unrestricted(),
+            NetworkSandboxPolicy::Restricted,
+        );
+
+        assert_eq!(
+            sandbox_policy_mode(&permission_profile, Path::new("/")),
+            "external_sandbox"
+        );
+    }
+}

codex-rs/app-server-client/src/lib.rs

@@ -41,12 +41,12 @@ use codex_app_server_protocol::Result as JsonRpcResult;
 use codex_app_server_protocol::ServerNotification;
 use codex_app_server_protocol::ServerRequest;
 use codex_arg0::Arg0DispatchPaths;
+use codex_config::CloudRequirementsLoader;
+use codex_config::LoaderOverrides;
 use codex_config::NoopThreadConfigLoader;
 use codex_config::RemoteThreadConfigLoader;
 use codex_config::ThreadConfigLoader;
 use codex_core::config::Config;
-use codex_core::config_loader::CloudRequirementsLoader;
-use codex_core::config_loader::LoaderOverrides;
 pub use codex_exec_server::EnvironmentManager;
 pub use codex_exec_server::EnvironmentManagerArgs;
 pub use codex_exec_server::ExecServerRuntimePaths;
@@ -1396,6 +1396,55 @@ mod tests {
         client.shutdown().await.expect("shutdown should complete");
     }
 
+    #[tokio::test]
+    async fn remote_typed_request_accepts_large_single_frame_response() {
+        let padding = "x".repeat((17 << 20) + 1024);
+        let websocket_url = start_test_remote_server(move |mut websocket| async move {
+            expect_remote_initialize(&mut websocket).await;
+            let JSONRPCMessage::Request(request) = read_websocket_message(&mut websocket).await
+            else {
+                panic!("expected account/read request");
+            };
+            assert_eq!(request.method, "account/read");
+            write_websocket_message(
+                &mut websocket,
+                JSONRPCMessage::Response(JSONRPCResponse {
+                    id: request.id,
+                    result: serde_json::json!({
+                        "account": null,
+                        "requiresOpenaiAuth": false,
+                        "padding": padding,
+                    }),
+                }),
+            )
+            .await;
+            websocket.close(None).await.expect("close should succeed");
+        })
+        .await;
+        let client = RemoteAppServerClient::connect(test_remote_connect_args(websocket_url))
+            .await
+            .expect("remote client should connect");
+
+        let response: GetAccountResponse = client
+            .request_typed(ClientRequest::GetAccount {
+                request_id: RequestId::Integer(1),
+                params: codex_app_server_protocol::GetAccountParams {
+                    refresh_token: false,
+                },
+            })
+            .await
+            .expect("large typed request should succeed");
+        assert_eq!(
+            response,
+            GetAccountResponse {
+                account: None,
+                requires_openai_auth: false,
+            }
+        );
+
+        client.shutdown().await.expect("shutdown should complete");
+    }
+
     #[tokio::test]
     async fn remote_connect_includes_auth_header_when_configured() {
         let auth_token = "remote-bearer-token".to_string();
@@ -1980,14 +2029,17 @@ mod tests {
     #[tokio::test]
     async fn runtime_start_args_forward_environment_manager() {
         let config = Arc::new(build_test_config().await);
-        let environment_manager = Arc::new(EnvironmentManager::new(EnvironmentManagerArgs {
-            exec_server_url: Some("ws://127.0.0.1:8765".to_string()),
-            local_runtime_paths: ExecServerRuntimePaths::new(
-                std::env::current_exe().expect("current exe"),
-                /*codex_linux_sandbox_exe*/ None,
+        let environment_manager = Arc::new(
+            EnvironmentManager::create_for_tests(
+                Some("ws://127.0.0.1:8765".to_string()),
+                ExecServerRuntimePaths::new(
+                    std::env::current_exe().expect("current exe"),
+                    /*codex_linux_sandbox_exe*/ None,
+                )
+                .expect("runtime paths"),
             )
-            .expect("runtime paths"),
-        }));
+            .await,
+        );
 
         let runtime_args = InProcessClientStartArgs {
             arg0_paths: Arg0DispatchPaths::default(),

codex-rs/app-server-client/src/remote.rs

@@ -45,16 +45,18 @@ use tokio::sync::oneshot;
 use tokio::time::timeout;
 use tokio_tungstenite::MaybeTlsStream;
 use tokio_tungstenite::WebSocketStream;
-use tokio_tungstenite::connect_async;
+use tokio_tungstenite::connect_async_with_config;
 use tokio_tungstenite::tungstenite::Message;
 use tokio_tungstenite::tungstenite::client::IntoClientRequest;
 use tokio_tungstenite::tungstenite::http::HeaderValue;
 use tokio_tungstenite::tungstenite::http::header::AUTHORIZATION;
+use tokio_tungstenite::tungstenite::protocol::WebSocketConfig;
 use tracing::warn;
 use url::Url;
 
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
 const INITIALIZE_TIMEOUT: Duration = Duration::from_secs(10);
+const REMOTE_APP_SERVER_MAX_WEBSOCKET_MESSAGE_SIZE: usize = 128 << 20;
 
 #[derive(Debug, Clone)]
 pub struct RemoteAppServerConnectArgs {
@@ -170,20 +172,32 @@ impl RemoteAppServerClient {
             request.headers_mut().insert(AUTHORIZATION, header_value);
         }
         ensure_rustls_crypto_provider();
-        let stream = timeout(CONNECT_TIMEOUT, connect_async(request))
-            .await
-            .map_err(|_| {
-                IoError::new(
-                    ErrorKind::TimedOut,
-                    format!("timed out connecting to remote app server at `{websocket_url}`"),
-                )
-            })?
-            .map(|(stream, _response)| stream)
-            .map_err(|err| {
-                IoError::other(format!(
-                    "failed to connect to remote app server at `{websocket_url}`: {err}"
-                ))
-            })?;
+        // Remote resume responses can legitimately carry large thread histories.
+        // Keep a bounded cap, but raise it above tungstenite's 16 MiB frame default.
+        let websocket_config = WebSocketConfig::default()
+            .max_frame_size(Some(REMOTE_APP_SERVER_MAX_WEBSOCKET_MESSAGE_SIZE))
+            .max_message_size(Some(REMOTE_APP_SERVER_MAX_WEBSOCKET_MESSAGE_SIZE));
+        let stream = timeout(
+            CONNECT_TIMEOUT,
+            connect_async_with_config(
+                request,
+                Some(websocket_config),
+                /*disable_nagle*/ false,
+            ),
+        )
+        .await
+        .map_err(|_| {
+            IoError::new(
+                ErrorKind::TimedOut,
+                format!("timed out connecting to remote app server at `{websocket_url}`"),
+            )
+        })?
+        .map(|(stream, _response)| stream)
+        .map_err(|err| {
+            IoError::other(format!(
+                "failed to connect to remote app server at `{websocket_url}`: {err}"
+            ))
+        })?;
         let mut stream = stream;
         let pending_events = initialize_remote_connection(
             &mut stream,
@@ -198,6 +212,7 @@ impl RemoteAppServerClient {
         let worker_handle = tokio::spawn(async move {
             let mut pending_requests =
                 HashMap::<RequestId, oneshot::Sender<IoResult<RequestResult>>>::new();
+            let mut worker_exit_error: Option<(ErrorKind, String)> = None;
             loop {
                 tokio::select! {
                     command = command_rx.recv() => {
@@ -224,17 +239,19 @@ impl RemoteAppServerClient {
                                 .await
                                 {
                                     let err_message = err.to_string();
+                                    let message = format!(
+                                        "remote app server at `{websocket_url}` write failed: {err_message}"
+                                    );
                                     if let Some(response_tx) = pending_requests.remove(&request_id) {
                                         let _ = response_tx.send(Err(err));
                                     }
                                     let _ = deliver_event(
                                         &event_tx,
                                         AppServerEvent::Disconnected {
-                                            message: format!(
-                                                "remote app server at `{websocket_url}` write failed: {err_message}"
-                                            ),
+                                            message: message.clone(),
                                         },
                                     );
+                                    worker_exit_error = Some((ErrorKind::BrokenPipe, message));
                                     break;
                                 }
                             }
@@ -351,28 +368,34 @@ impl RemoteAppServerClient {
                                                 .await
                                                 {
                                                     let err_message = reject_err.to_string();
+                                                    let message = format!(
+                                                        "remote app server at `{websocket_url}` write failed: {err_message}"
+                                                    );
                                                     let _ = deliver_event(
                                                         &event_tx,
                                                         AppServerEvent::Disconnected {
-                                                            message: format!(
-                                                                "remote app server at `{websocket_url}` write failed: {err_message}"
-                                                            ),
+                                                            message: message.clone(),
                                                         },
                                                     );
+                                                    worker_exit_error =
+                                                        Some((ErrorKind::BrokenPipe, message));
                                                     break;
                                                 }
                                             }
                                         }
                                     }
                                     Err(err) => {
+                                        let message = format!(
+                                            "remote app server at `{websocket_url}` sent invalid JSON-RPC: {err}"
+                                        );
                                         let _ = deliver_event(
                                             &event_tx,
                                             AppServerEvent::Disconnected {
-                                                message: format!(
-                                                    "remote app server at `{websocket_url}` sent invalid JSON-RPC: {err}"
-                                                ),
+                                                message: message.clone(),
                                             },
                                         );
+                                        worker_exit_error =
+                                            Some((ErrorKind::InvalidData, message));
                                         break;
                                     }
                                 }
@@ -383,14 +406,19 @@ impl RemoteAppServerClient {
                                     .map(|frame| frame.reason.to_string())
                                     .filter(|reason| !reason.is_empty())
                                     .unwrap_or_else(|| "connection closed".to_string());
+                                let message = format!(
+                                    "remote app server at `{websocket_url}` disconnected: {reason}"
+                                );
                                 let _ = deliver_event(
                                     &event_tx,
                                     AppServerEvent::Disconnected {
-                                        message: format!(
-                                            "remote app server at `{websocket_url}` disconnected: {reason}"
-                                        ),
+                                        message: message.clone(),
                                     },
                                 );
+                                worker_exit_error = Some((
+                                    ErrorKind::ConnectionAborted,
+                                    message,
+                                ));
                                 break;
                             }
                             Some(Ok(Message::Binary(_)))
@@ -398,25 +426,29 @@ impl RemoteAppServerClient {
                             | Some(Ok(Message::Pong(_)))
                             | Some(Ok(Message::Frame(_))) => {}
                             Some(Err(err)) => {
+                                let message = format!(
+                                    "remote app server at `{websocket_url}` transport failed: {err}"
+                                );
                                 let _ = deliver_event(
                                     &event_tx,
                                     AppServerEvent::Disconnected {
-                                        message: format!(
-                                            "remote app server at `{websocket_url}` transport failed: {err}"
-                                        ),
+                                        message: message.clone(),
                                     },
                                 );
+                                worker_exit_error = Some((ErrorKind::InvalidData, message));
                                 break;
                             }
                             None => {
+                                let message = format!(
+                                    "remote app server at `{websocket_url}` closed the connection"
+                                );
                                 let _ = deliver_event(
                                     &event_tx,
                                     AppServerEvent::Disconnected {
-                                        message: format!(
-                                            "remote app server at `{websocket_url}` closed the connection"
-                                        ),
+                                        message: message.clone(),
                                     },
                                 );
+                                worker_exit_error = Some((ErrorKind::UnexpectedEof, message));
                                 break;
                             }
                         }
@@ -424,12 +456,14 @@ impl RemoteAppServerClient {
                 }
             }
 
-            let err = IoError::new(
-                ErrorKind::BrokenPipe,
-                "remote app-server worker channel is closed",
-            );
+            let (err_kind, err_message) = worker_exit_error.unwrap_or_else(|| {
+                (
+                    ErrorKind::BrokenPipe,
+                    "remote app-server worker channel is closed".to_string(),
+                )
+            });
             for (_, response_tx) in pending_requests {
-                let _ = response_tx.send(Err(IoError::new(err.kind(), err.to_string())));
+                let _ = response_tx.send(Err(IoError::new(err_kind, err_message.clone())));
             }
         });
 

codex-rs/app-server-protocol/schema/json/ClientRequest.json

@@ -218,17 +218,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Optional full permissions profile for this command.\n\nDefaults to the user's configured permissions when omitted. Cannot be combined with `sandboxPolicy`."
-        },
         "processId": {
           "description": "Optional client-supplied, connection-scoped process id.\n\nRequired for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up `command/exec/write`, `command/exec/resize`, and `command/exec/terminate` calls. When omitted, buffered execution gets an internal id that is not exposed to the client.",
           "type": [
@@ -365,6 +354,17 @@
       ],
       "type": "object"
     },
+    "CommandMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "ConfigBatchWriteParams": {
       "properties": {
         "edits": {
@@ -860,7 +860,11 @@
         "CONFIG",
         "SKILLS",
         "PLUGINS",
-        "MCP_SERVER_CONFIG"
+        "MCP_SERVER_CONFIG",
+        "SUBAGENTS",
+        "HOOKS",
+        "COMMANDS",
+        "SESSIONS"
       ],
       "type": "string"
     },
@@ -1028,21 +1032,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -1415,35 +1404,14 @@
       },
       "type": "object"
     },
-    "GhostCommit": {
-      "description": "Details of a ghost commit created from a repository state.",
+    "HookMigration": {
       "properties": {
-        "id": {
+        "name": {
           "type": "string"
-        },
-        "parent": {
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "preexisting_untracked_dirs": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        },
-        "preexisting_untracked_files": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
         }
       },
       "required": [
-        "id",
-        "preexisting_untracked_dirs",
-        "preexisting_untracked_files"
+        "name"
       ],
       "type": "object"
     },
@@ -1753,6 +1721,17 @@
       ],
       "type": "object"
     },
+    "McpServerMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "McpServerOauthLoginParams": {
       "properties": {
         "name": {
@@ -1836,16 +1815,49 @@
     },
     "MigrationDetails": {
       "properties": {
+        "commands": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/CommandMigration"
+          },
+          "type": "array"
+        },
+        "hooks": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/HookMigration"
+          },
+          "type": "array"
+        },
+        "mcpServers": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/McpServerMigration"
+          },
+          "type": "array"
+        },
         "plugins": {
+          "default": [],
           "items": {
             "$ref": "#/definitions/PluginsMigration"
           },
           "type": "array"
+        },
+        "sessions": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SessionMigration"
+          },
+          "type": "array"
+        },
+        "subagents": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SubagentMigration"
+          },
+          "type": "array"
         }
       },
-      "required": [
-        "plugins"
-      ],
       "type": "object"
     },
     "ModeKind": {
@@ -1884,6 +1896,9 @@
       },
       "type": "object"
     },
+    "ModelProviderCapabilitiesReadParams": {
+      "type": "object"
+    },
     "NetworkAccess": {
       "enum": [
         "restricted",
@@ -2292,12 +2307,6 @@
               },
               "type": "array"
             },
-            "end_turn": {
-              "type": [
-                "boolean",
-                "null"
-              ]
-            },
             "id": {
               "type": [
                 "string",
@@ -2697,26 +2706,6 @@
           "title": "ImageGenerationCallResponseItem",
           "type": "object"
         },
-        {
-          "properties": {
-            "ghost_commit": {
-              "$ref": "#/definitions/GhostCommit"
-            },
-            "type": {
-              "enum": [
-                "ghost_snapshot"
-              ],
-              "title": "GhostSnapshotResponseItemType",
-              "type": "string"
-            }
-          },
-          "required": [
-            "ghost_commit",
-            "type"
-          ],
-          "title": "GhostSnapshotResponseItem",
-          "type": "object"
-        },
         {
           "properties": {
             "encrypted_content": {
@@ -3106,6 +3095,27 @@
       ],
       "type": "string"
     },
+    "SessionMigration": {
+      "properties": {
+        "cwd": {
+          "type": "string"
+        },
+        "path": {
+          "type": "string"
+        },
+        "title": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "cwd",
+        "path"
+      ],
+      "type": "object"
+    },
     "Settings": {
       "description": "Settings for a collaboration mode.",
       "properties": {
@@ -3215,6 +3225,17 @@
       ],
       "type": "string"
     },
+    "SubagentMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "TextElement": {
       "properties": {
         "byteRange": {
@@ -3344,17 +3365,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for the forked thread. Cannot be combined with `sandbox`."
-        },
         "sandbox": {
           "anyOf": [
             {
@@ -3760,17 +3770,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for the resumed thread. Cannot be combined with `sandbox`."
-        },
         "personality": {
           "anyOf": [
             {
@@ -3954,17 +3953,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for this thread. Cannot be combined with `sandbox`."
-        },
         "personality": {
           "anyOf": [
             {
@@ -4176,17 +4164,6 @@
         "outputSchema": {
           "description": "Optional JSON Schema used to constrain the final assistant message for this turn."
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Override the full permissions profile for this turn and subsequent turns. Cannot be combined with `sandboxPolicy`."
-        },
         "personality": {
           "anyOf": [
             {
@@ -5504,6 +5481,30 @@
       "title": "Model/listRequest",
       "type": "object"
     },
+    {
+      "properties": {
+        "id": {
+          "$ref": "#/definitions/RequestId"
+        },
+        "method": {
+          "enum": [
+            "modelProvider/capabilities/read"
+          ],
+          "title": "ModelProvider/capabilities/readRequestMethod",
+          "type": "string"
+        },
+        "params": {
+          "$ref": "#/definitions/ModelProviderCapabilitiesReadParams"
+        }
+      },
+      "required": [
+        "id",
+        "method",
+        "params"
+      ],
+      "title": "ModelProvider/capabilities/readRequest",
+      "type": "object"
+    },
     {
       "properties": {
         "id": {

codex-rs/app-server-protocol/schema/json/CommandExecutionRequestApprovalParams.json

@@ -392,21 +392,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalParams.json

@@ -177,21 +177,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/PermissionsRequestApprovalResponse.json

@@ -177,21 +177,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/ServerNotification.json

@@ -1199,21 +1199,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -1915,6 +1900,7 @@
         "project",
         "mdm",
         "sessionFlags",
+        "plugin",
         "legacyManagedConfigFile",
         "legacyManagedConfigMdm",
         "unknown"
@@ -2617,6 +2603,33 @@
       ],
       "type": "object"
     },
+    "RemoteControlConnectionStatus": {
+      "enum": [
+        "disabled",
+        "connecting",
+        "connected",
+        "errored"
+      ],
+      "type": "string"
+    },
+    "RemoteControlStatusChangedNotification": {
+      "description": "Current remote-control connection status and environment id exposed to clients.",
+      "properties": {
+        "environmentId": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "status": {
+          "$ref": "#/definitions/RemoteControlConnectionStatus"
+        }
+      },
+      "required": [
+        "status"
+      ],
+      "type": "object"
+    },
     "RequestId": {
       "anyOf": [
         {
@@ -3299,6 +3312,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -3341,6 +3362,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -3371,9 +3400,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -3397,6 +3450,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -3437,6 +3498,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -3465,6 +3534,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -3491,6 +3568,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -3530,6 +3615,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -3570,6 +3671,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -3618,12 +3727,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -3666,6 +3799,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -3688,6 +3837,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },
@@ -5356,6 +5513,26 @@
       "title": "App/list/updatedNotification",
       "type": "object"
     },
+    {
+      "properties": {
+        "method": {
+          "enum": [
+            "remoteControl/status/changed"
+          ],
+          "title": "RemoteControl/status/changedNotificationMethod",
+          "type": "string"
+        },
+        "params": {
+          "$ref": "#/definitions/RemoteControlStatusChangedNotification"
+        }
+      },
+      "required": [
+        "method",
+        "params"
+      ],
+      "title": "RemoteControl/status/changedNotification",
+      "type": "object"
+    },
     {
       "properties": {
         "method": {

codex-rs/app-server-protocol/schema/json/ServerRequest.json

@@ -731,21 +731,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.schemas.json

@@ -1266,6 +1266,30 @@
           "title": "Model/listRequest",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "$ref": "#/definitions/v2/RequestId"
+            },
+            "method": {
+              "enum": [
+                "modelProvider/capabilities/read"
+              ],
+              "title": "ModelProvider/capabilities/readRequestMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/v2/ModelProviderCapabilitiesReadParams"
+            }
+          },
+          "required": [
+            "id",
+            "method",
+            "params"
+          ],
+          "title": "ModelProvider/capabilities/readRequest",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -4348,6 +4372,26 @@
           "title": "App/list/updatedNotification",
           "type": "object"
         },
+        {
+          "properties": {
+            "method": {
+              "enum": [
+                "remoteControl/status/changed"
+              ],
+              "title": "RemoteControl/status/changedNotificationMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/v2/RemoteControlStatusChangedNotification"
+            }
+          },
+          "required": [
+            "method",
+            "params"
+          ],
+          "title": "RemoteControl/status/changedNotification",
+          "type": "object"
+        },
         {
           "properties": {
             "method": {
@@ -6536,17 +6580,6 @@
               "null"
             ]
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "description": "Optional full permissions profile for this command.\n\nDefaults to the user's configured permissions when omitted. Cannot be combined with `sandboxPolicy`."
-          },
           "processId": {
             "description": "Optional client-supplied, connection-scoped process id.\n\nRequired for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up `command/exec/write`, `command/exec/resize`, and `command/exec/terminate` calls. When omitted, buffered execution gets an internal id that is not exposed to the client.",
             "type": [
@@ -6777,6 +6810,17 @@
         ],
         "type": "string"
       },
+      "CommandMigration": {
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "type": "object"
+      },
       "Config": {
         "additionalProperties": true,
         "properties": {
@@ -8337,7 +8381,11 @@
           "CONFIG",
           "SKILLS",
           "PLUGINS",
-          "MCP_SERVER_CONFIG"
+          "MCP_SERVER_CONFIG",
+          "SUBAGENTS",
+          "HOOKS",
+          "COMMANDS",
+          "SESSIONS"
         ],
         "type": "string"
       },
@@ -8573,21 +8621,6 @@
             "title": "MinimalFileSystemSpecialPath",
             "type": "object"
           },
-          {
-            "properties": {
-              "kind": {
-                "enum": [
-                  "current_working_directory"
-                ],
-                "type": "string"
-              }
-            },
-            "required": [
-              "kind"
-            ],
-            "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-            "type": "object"
-          },
           {
             "properties": {
               "kind": {
@@ -9198,38 +9231,6 @@
         "title": "GetAccountResponse",
         "type": "object"
       },
-      "GhostCommit": {
-        "description": "Details of a ghost commit created from a repository state.",
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "parent": {
-            "type": [
-              "string",
-              "null"
-            ]
-          },
-          "preexisting_untracked_dirs": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          },
-          "preexisting_untracked_files": {
-            "items": {
-              "type": "string"
-            },
-            "type": "array"
-          }
-        },
-        "required": [
-          "id",
-          "preexisting_untracked_dirs",
-          "preexisting_untracked_files"
-        ],
-        "type": "object"
-      },
       "GitInfo": {
         "properties": {
           "branch": {
@@ -9593,6 +9594,17 @@
         ],
         "type": "string"
       },
+      "HookMigration": {
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "type": "object"
+      },
       "HookOutputEntry": {
         "properties": {
           "kind": {
@@ -9737,6 +9749,7 @@
           "project",
           "mdm",
           "sessionFlags",
+          "plugin",
           "legacyManagedConfigFile",
           "legacyManagedConfigMdm",
           "unknown"
@@ -10505,6 +10518,17 @@
         "title": "McpResourceReadResponse",
         "type": "object"
       },
+      "McpServerMigration": {
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "type": "object"
+      },
       "McpServerOauthLoginCompletedNotification": {
         "$schema": "http://json-schema.org/draft-07/schema#",
         "properties": {
@@ -10829,16 +10853,49 @@
       },
       "MigrationDetails": {
         "properties": {
+          "commands": {
+            "default": [],
+            "items": {
+              "$ref": "#/definitions/v2/CommandMigration"
+            },
+            "type": "array"
+          },
+          "hooks": {
+            "default": [],
+            "items": {
+              "$ref": "#/definitions/v2/HookMigration"
+            },
+            "type": "array"
+          },
+          "mcpServers": {
+            "default": [],
+            "items": {
+              "$ref": "#/definitions/v2/McpServerMigration"
+            },
+            "type": "array"
+          },
           "plugins": {
+            "default": [],
             "items": {
               "$ref": "#/definitions/v2/PluginsMigration"
             },
             "type": "array"
+          },
+          "sessions": {
+            "default": [],
+            "items": {
+              "$ref": "#/definitions/v2/SessionMigration"
+            },
+            "type": "array"
+          },
+          "subagents": {
+            "default": [],
+            "items": {
+              "$ref": "#/definitions/v2/SubagentMigration"
+            },
+            "type": "array"
           }
         },
-        "required": [
-          "plugins"
-        ],
         "type": "object"
       },
       "ModeKind": {
@@ -11002,6 +11059,32 @@
         "title": "ModelListResponse",
         "type": "object"
       },
+      "ModelProviderCapabilitiesReadParams": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "title": "ModelProviderCapabilitiesReadParams",
+        "type": "object"
+      },
+      "ModelProviderCapabilitiesReadResponse": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "properties": {
+          "imageGeneration": {
+            "type": "boolean"
+          },
+          "namespaceTools": {
+            "type": "boolean"
+          },
+          "webSearch": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "imageGeneration",
+          "namespaceTools",
+          "webSearch"
+        ],
+        "title": "ModelProviderCapabilitiesReadResponse",
+        "type": "object"
+      },
       "ModelRerouteReason": {
         "enum": [
           "highRiskCyberActivity"
@@ -12550,6 +12633,35 @@
         ],
         "type": "string"
       },
+      "RemoteControlConnectionStatus": {
+        "enum": [
+          "disabled",
+          "connecting",
+          "connected",
+          "errored"
+        ],
+        "type": "string"
+      },
+      "RemoteControlStatusChangedNotification": {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "description": "Current remote-control connection status and environment id exposed to clients.",
+        "properties": {
+          "environmentId": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "status": {
+            "$ref": "#/definitions/v2/RemoteControlConnectionStatus"
+          }
+        },
+        "required": [
+          "status"
+        ],
+        "title": "RemoteControlStatusChangedNotification",
+        "type": "object"
+      },
       "RequestId": {
         "anyOf": [
           {
@@ -12739,12 +12851,6 @@
                 },
                 "type": "array"
               },
-              "end_turn": {
-                "type": [
-                  "boolean",
-                  "null"
-                ]
-              },
               "id": {
                 "type": [
                   "string",
@@ -13144,26 +13250,6 @@
             "title": "ImageGenerationCallResponseItem",
             "type": "object"
           },
-          {
-            "properties": {
-              "ghost_commit": {
-                "$ref": "#/definitions/v2/GhostCommit"
-              },
-              "type": {
-                "enum": [
-                  "ghost_snapshot"
-                ],
-                "title": "GhostSnapshotResponseItemType",
-                "type": "string"
-              }
-            },
-            "required": [
-              "ghost_commit",
-              "type"
-            ],
-            "title": "GhostSnapshotResponseItem",
-            "type": "object"
-          },
           {
             "properties": {
               "encrypted_content": {
@@ -13629,6 +13715,27 @@
         ],
         "type": "string"
       },
+      "SessionMigration": {
+        "properties": {
+          "cwd": {
+            "type": "string"
+          },
+          "path": {
+            "type": "string"
+          },
+          "title": {
+            "type": [
+              "string",
+              "null"
+            ]
+          }
+        },
+        "required": [
+          "cwd",
+          "path"
+        ],
+        "type": "object"
+      },
       "SessionSource": {
         "oneOf": [
           {
@@ -14143,6 +14250,17 @@
           }
         ]
       },
+      "SubagentMigration": {
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "type": "object"
+      },
       "TerminalInteractionNotification": {
         "$schema": "http://json-schema.org/draft-07/schema#",
         "properties": {
@@ -14516,17 +14634,6 @@
               "null"
             ]
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "description": "Full permissions override for the forked thread. Cannot be combined with `sandbox`."
-          },
           "sandbox": {
             "anyOf": [
               {
@@ -14595,18 +14702,6 @@
           "modelProvider": {
             "type": "string"
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "description": "Canonical active permissions view for this thread."
-          },
           "reasoningEffort": {
             "anyOf": [
               {
@@ -14950,6 +15045,14 @@
                 },
                 "type": "array"
               },
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "cwd": {
                 "allOf": [
                   {
@@ -14992,6 +15095,14 @@
                 ],
                 "default": "agent"
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "$ref": "#/definitions/v2/CommandExecutionStatus"
               },
@@ -15022,9 +15133,33 @@
                 },
                 "type": "array"
               },
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "durationMs": {
+                "description": "The duration of patch application in milliseconds.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "id": {
                 "type": "string"
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "$ref": "#/definitions/v2/PatchApplyStatus"
               },
@@ -15048,6 +15183,14 @@
           {
             "properties": {
               "arguments": true,
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "durationMs": {
                 "description": "The duration of the MCP tool call in milliseconds.",
                 "format": "int64",
@@ -15088,6 +15231,14 @@
               "server": {
                 "type": "string"
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "$ref": "#/definitions/v2/McpToolCallStatus"
               },
@@ -15116,6 +15267,14 @@
           {
             "properties": {
               "arguments": true,
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "contentItems": {
                 "items": {
                   "$ref": "#/definitions/v2/DynamicToolCallOutputContentItem"
@@ -15142,6 +15301,14 @@
                   "null"
                 ]
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "$ref": "#/definitions/v2/DynamicToolCallStatus"
               },
@@ -15181,6 +15348,22 @@
                 "description": "Last known status of the target agents, when available.",
                 "type": "object"
               },
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "durationMs": {
+                "description": "The duration of the collab tool execution in milliseconds.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "id": {
                 "description": "Unique identifier for this collab tool call.",
                 "type": "string"
@@ -15221,6 +15404,14 @@
                 "description": "Thread ID of the agent issuing the collab request.",
                 "type": "string"
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "allOf": [
                   {
@@ -15269,12 +15460,36 @@
                   }
                 ]
               },
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "durationMs": {
+                "description": "The duration of the web search execution in milliseconds.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "id": {
                 "type": "string"
               },
               "query": {
                 "type": "string"
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "type": {
                 "enum": [
                   "webSearch"
@@ -15317,6 +15532,22 @@
           },
           {
             "properties": {
+              "completedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
+              "durationMs": {
+                "description": "The duration of image generation in milliseconds.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "id": {
                 "type": "string"
               },
@@ -15339,6 +15570,14 @@
                   }
                 ]
               },
+              "startedAtMs": {
+                "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+                "format": "int64",
+                "type": [
+                  "integer",
+                  "null"
+                ]
+              },
               "status": {
                 "type": "string"
               },
@@ -16040,17 +16279,6 @@
               "null"
             ]
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "description": "Full permissions override for the resumed thread. Cannot be combined with `sandbox`."
-          },
           "personality": {
             "anyOf": [
               {
@@ -16129,18 +16357,6 @@
           "modelProvider": {
             "type": "string"
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "description": "Canonical active permissions view for this thread."
-          },
           "reasoningEffort": {
             "anyOf": [
               {
@@ -16357,17 +16573,6 @@
               "null"
             ]
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "description": "Full permissions override for this thread. Cannot be combined with `sandbox`."
-          },
           "personality": {
             "anyOf": [
               {
@@ -16456,18 +16661,6 @@
           "modelProvider": {
             "type": "string"
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "default": null,
-            "description": "Canonical active permissions view for this thread."
-          },
           "reasoningEffort": {
             "anyOf": [
               {
@@ -17173,17 +17366,6 @@
           "outputSchema": {
             "description": "Optional JSON Schema used to constrain the final assistant message for this turn."
           },
-          "permissionProfile": {
-            "anyOf": [
-              {
-                "$ref": "#/definitions/v2/PermissionProfile"
-              },
-              {
-                "type": "null"
-              }
-            ],
-            "description": "Override the full permissions profile for this turn and subsequent turns. Cannot be combined with `sandboxPolicy`."
-          },
           "personality": {
             "anyOf": [
               {

codex-rs/app-server-protocol/schema/json/codex_app_server_protocol.v2.schemas.json

@@ -1972,6 +1972,30 @@
           "title": "Model/listRequest",
           "type": "object"
         },
+        {
+          "properties": {
+            "id": {
+              "$ref": "#/definitions/RequestId"
+            },
+            "method": {
+              "enum": [
+                "modelProvider/capabilities/read"
+              ],
+              "title": "ModelProvider/capabilities/readRequestMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/ModelProviderCapabilitiesReadParams"
+            }
+          },
+          "required": [
+            "id",
+            "method",
+            "params"
+          ],
+          "title": "ModelProvider/capabilities/readRequest",
+          "type": "object"
+        },
         {
           "properties": {
             "id": {
@@ -3055,17 +3079,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Optional full permissions profile for this command.\n\nDefaults to the user's configured permissions when omitted. Cannot be combined with `sandboxPolicy`."
-        },
         "processId": {
           "description": "Optional client-supplied, connection-scoped process id.\n\nRequired for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up `command/exec/write`, `command/exec/resize`, and `command/exec/terminate` calls. When omitted, buffered execution gets an internal id that is not exposed to the client.",
           "type": [
@@ -3296,6 +3309,17 @@
       ],
       "type": "string"
     },
+    "CommandMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "Config": {
       "additionalProperties": true,
       "properties": {
@@ -4856,7 +4880,11 @@
         "CONFIG",
         "SKILLS",
         "PLUGINS",
-        "MCP_SERVER_CONFIG"
+        "MCP_SERVER_CONFIG",
+        "SUBAGENTS",
+        "HOOKS",
+        "COMMANDS",
+        "SESSIONS"
       ],
       "type": "string"
     },
@@ -5092,21 +5120,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -5828,38 +5841,6 @@
       "title": "GetAccountResponse",
       "type": "object"
     },
-    "GhostCommit": {
-      "description": "Details of a ghost commit created from a repository state.",
-      "properties": {
-        "id": {
-          "type": "string"
-        },
-        "parent": {
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "preexisting_untracked_dirs": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        },
-        "preexisting_untracked_files": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        }
-      },
-      "required": [
-        "id",
-        "preexisting_untracked_dirs",
-        "preexisting_untracked_files"
-      ],
-      "type": "object"
-    },
     "GitInfo": {
       "properties": {
         "branch": {
@@ -6223,6 +6204,17 @@
       ],
       "type": "string"
     },
+    "HookMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "HookOutputEntry": {
       "properties": {
         "kind": {
@@ -6367,6 +6359,7 @@
         "project",
         "mdm",
         "sessionFlags",
+        "plugin",
         "legacyManagedConfigFile",
         "legacyManagedConfigMdm",
         "unknown"
@@ -7179,6 +7172,17 @@
       "title": "McpResourceReadResponse",
       "type": "object"
     },
+    "McpServerMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "McpServerOauthLoginCompletedNotification": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {
@@ -7503,16 +7507,49 @@
     },
     "MigrationDetails": {
       "properties": {
+        "commands": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/CommandMigration"
+          },
+          "type": "array"
+        },
+        "hooks": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/HookMigration"
+          },
+          "type": "array"
+        },
+        "mcpServers": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/McpServerMigration"
+          },
+          "type": "array"
+        },
         "plugins": {
+          "default": [],
           "items": {
             "$ref": "#/definitions/PluginsMigration"
           },
           "type": "array"
+        },
+        "sessions": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SessionMigration"
+          },
+          "type": "array"
+        },
+        "subagents": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SubagentMigration"
+          },
+          "type": "array"
         }
       },
-      "required": [
-        "plugins"
-      ],
       "type": "object"
     },
     "ModeKind": {
@@ -7676,6 +7713,32 @@
       "title": "ModelListResponse",
       "type": "object"
     },
+    "ModelProviderCapabilitiesReadParams": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "title": "ModelProviderCapabilitiesReadParams",
+      "type": "object"
+    },
+    "ModelProviderCapabilitiesReadResponse": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "properties": {
+        "imageGeneration": {
+          "type": "boolean"
+        },
+        "namespaceTools": {
+          "type": "boolean"
+        },
+        "webSearch": {
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "imageGeneration",
+        "namespaceTools",
+        "webSearch"
+      ],
+      "title": "ModelProviderCapabilitiesReadResponse",
+      "type": "object"
+    },
     "ModelRerouteReason": {
       "enum": [
         "highRiskCyberActivity"
@@ -9224,6 +9287,35 @@
       ],
       "type": "string"
     },
+    "RemoteControlConnectionStatus": {
+      "enum": [
+        "disabled",
+        "connecting",
+        "connected",
+        "errored"
+      ],
+      "type": "string"
+    },
+    "RemoteControlStatusChangedNotification": {
+      "$schema": "http://json-schema.org/draft-07/schema#",
+      "description": "Current remote-control connection status and environment id exposed to clients.",
+      "properties": {
+        "environmentId": {
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "status": {
+          "$ref": "#/definitions/RemoteControlConnectionStatus"
+        }
+      },
+      "required": [
+        "status"
+      ],
+      "title": "RemoteControlStatusChangedNotification",
+      "type": "object"
+    },
     "RequestId": {
       "anyOf": [
         {
@@ -9413,12 +9505,6 @@
               },
               "type": "array"
             },
-            "end_turn": {
-              "type": [
-                "boolean",
-                "null"
-              ]
-            },
             "id": {
               "type": [
                 "string",
@@ -9818,26 +9904,6 @@
           "title": "ImageGenerationCallResponseItem",
           "type": "object"
         },
-        {
-          "properties": {
-            "ghost_commit": {
-              "$ref": "#/definitions/GhostCommit"
-            },
-            "type": {
-              "enum": [
-                "ghost_snapshot"
-              ],
-              "title": "GhostSnapshotResponseItemType",
-              "type": "string"
-            }
-          },
-          "required": [
-            "ghost_commit",
-            "type"
-          ],
-          "title": "GhostSnapshotResponseItem",
-          "type": "object"
-        },
         {
           "properties": {
             "encrypted_content": {
@@ -10986,6 +11052,26 @@
           "title": "App/list/updatedNotification",
           "type": "object"
         },
+        {
+          "properties": {
+            "method": {
+              "enum": [
+                "remoteControl/status/changed"
+              ],
+              "title": "RemoteControl/status/changedNotificationMethod",
+              "type": "string"
+            },
+            "params": {
+              "$ref": "#/definitions/RemoteControlStatusChangedNotification"
+            }
+          },
+          "required": [
+            "method",
+            "params"
+          ],
+          "title": "RemoteControl/status/changedNotification",
+          "type": "object"
+        },
         {
           "properties": {
             "method": {
@@ -11515,6 +11601,27 @@
       ],
       "type": "string"
     },
+    "SessionMigration": {
+      "properties": {
+        "cwd": {
+          "type": "string"
+        },
+        "path": {
+          "type": "string"
+        },
+        "title": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "cwd",
+        "path"
+      ],
+      "type": "object"
+    },
     "SessionSource": {
       "oneOf": [
         {
@@ -12029,6 +12136,17 @@
         }
       ]
     },
+    "SubagentMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "TerminalInteractionNotification": {
       "$schema": "http://json-schema.org/draft-07/schema#",
       "properties": {
@@ -12402,17 +12520,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for the forked thread. Cannot be combined with `sandbox`."
-        },
         "sandbox": {
           "anyOf": [
             {
@@ -12481,18 +12588,6 @@
         "modelProvider": {
           "type": "string"
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Canonical active permissions view for this thread."
-        },
         "reasoningEffort": {
           "anyOf": [
             {
@@ -12836,6 +12931,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -12878,6 +12981,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -12908,9 +13019,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -12934,6 +13069,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -12974,6 +13117,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -13002,6 +13153,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -13028,6 +13187,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -13067,6 +13234,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -13107,6 +13290,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -13155,12 +13346,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -13203,6 +13418,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -13225,6 +13456,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },
@@ -13926,17 +14165,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for the resumed thread. Cannot be combined with `sandbox`."
-        },
         "personality": {
           "anyOf": [
             {
@@ -14015,18 +14243,6 @@
         "modelProvider": {
           "type": "string"
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Canonical active permissions view for this thread."
-        },
         "reasoningEffort": {
           "anyOf": [
             {
@@ -14243,17 +14459,6 @@
             "null"
           ]
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Full permissions override for this thread. Cannot be combined with `sandbox`."
-        },
         "personality": {
           "anyOf": [
             {
@@ -14342,18 +14547,6 @@
         "modelProvider": {
           "type": "string"
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "default": null,
-          "description": "Canonical active permissions view for this thread."
-        },
         "reasoningEffort": {
           "anyOf": [
             {
@@ -15059,17 +15252,6 @@
         "outputSchema": {
           "description": "Optional JSON Schema used to constrain the final assistant message for this turn."
         },
-        "permissionProfile": {
-          "anyOf": [
-            {
-              "$ref": "#/definitions/PermissionProfile"
-            },
-            {
-              "type": "null"
-            }
-          ],
-          "description": "Override the full permissions profile for this turn and subsequent turns. Cannot be combined with `sandboxPolicy`."
-        },
         "personality": {
           "anyOf": [
             {

codex-rs/app-server-protocol/schema/json/v2/CommandExecParams.json

@@ -146,21 +146,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -520,17 +505,6 @@
         "null"
       ]
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Optional full permissions profile for this command.\n\nDefaults to the user's configured permissions when omitted. Cannot be combined with `sandboxPolicy`."
-    },
     "processId": {
       "description": "Optional client-supplied, connection-scoped process id.\n\nRequired for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up `command/exec/write`, `command/exec/resize`, and `command/exec/terminate` calls. When omitted, buffered execution gets an internal id that is not exposed to the client.",
       "type": [

codex-rs/app-server-protocol/schema/json/v2/ExternalAgentConfigDetectResponse.json

@@ -1,6 +1,17 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "CommandMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "ExternalAgentConfigMigrationItem": {
       "properties": {
         "cwd": {
@@ -39,22 +50,81 @@
         "CONFIG",
         "SKILLS",
         "PLUGINS",
-        "MCP_SERVER_CONFIG"
+        "MCP_SERVER_CONFIG",
+        "SUBAGENTS",
+        "HOOKS",
+        "COMMANDS",
+        "SESSIONS"
       ],
       "type": "string"
     },
+    "HookMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
+    "McpServerMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "MigrationDetails": {
       "properties": {
+        "commands": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/CommandMigration"
+          },
+          "type": "array"
+        },
+        "hooks": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/HookMigration"
+          },
+          "type": "array"
+        },
+        "mcpServers": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/McpServerMigration"
+          },
+          "type": "array"
+        },
         "plugins": {
+          "default": [],
           "items": {
             "$ref": "#/definitions/PluginsMigration"
           },
           "type": "array"
+        },
+        "sessions": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SessionMigration"
+          },
+          "type": "array"
+        },
+        "subagents": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SubagentMigration"
+          },
+          "type": "array"
         }
       },
-      "required": [
-        "plugins"
-      ],
       "type": "object"
     },
     "PluginsMigration": {
@@ -74,6 +144,38 @@
         "pluginNames"
       ],
       "type": "object"
+    },
+    "SessionMigration": {
+      "properties": {
+        "cwd": {
+          "type": "string"
+        },
+        "path": {
+          "type": "string"
+        },
+        "title": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "cwd",
+        "path"
+      ],
+      "type": "object"
+    },
+    "SubagentMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
     }
   },
   "properties": {

codex-rs/app-server-protocol/schema/json/v2/ExternalAgentConfigImportParams.json

@@ -1,6 +1,17 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema#",
   "definitions": {
+    "CommandMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "ExternalAgentConfigMigrationItem": {
       "properties": {
         "cwd": {
@@ -39,22 +50,81 @@
         "CONFIG",
         "SKILLS",
         "PLUGINS",
-        "MCP_SERVER_CONFIG"
+        "MCP_SERVER_CONFIG",
+        "SUBAGENTS",
+        "HOOKS",
+        "COMMANDS",
+        "SESSIONS"
       ],
       "type": "string"
     },
+    "HookMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
+    "McpServerMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
+    },
     "MigrationDetails": {
       "properties": {
+        "commands": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/CommandMigration"
+          },
+          "type": "array"
+        },
+        "hooks": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/HookMigration"
+          },
+          "type": "array"
+        },
+        "mcpServers": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/McpServerMigration"
+          },
+          "type": "array"
+        },
         "plugins": {
+          "default": [],
           "items": {
             "$ref": "#/definitions/PluginsMigration"
           },
           "type": "array"
+        },
+        "sessions": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SessionMigration"
+          },
+          "type": "array"
+        },
+        "subagents": {
+          "default": [],
+          "items": {
+            "$ref": "#/definitions/SubagentMigration"
+          },
+          "type": "array"
         }
       },
-      "required": [
-        "plugins"
-      ],
       "type": "object"
     },
     "PluginsMigration": {
@@ -74,6 +144,38 @@
         "pluginNames"
       ],
       "type": "object"
+    },
+    "SessionMigration": {
+      "properties": {
+        "cwd": {
+          "type": "string"
+        },
+        "path": {
+          "type": "string"
+        },
+        "title": {
+          "type": [
+            "string",
+            "null"
+          ]
+        }
+      },
+      "required": [
+        "cwd",
+        "path"
+      ],
+      "type": "object"
+    },
+    "SubagentMigration": {
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      },
+      "required": [
+        "name"
+      ],
+      "type": "object"
     }
   },
   "properties": {

codex-rs/app-server-protocol/schema/json/v2/HookCompletedNotification.json

@@ -160,6 +160,7 @@
         "project",
         "mdm",
         "sessionFlags",
+        "plugin",
         "legacyManagedConfigFile",
         "legacyManagedConfigMdm",
         "unknown"

codex-rs/app-server-protocol/schema/json/v2/HookStartedNotification.json

@@ -160,6 +160,7 @@
         "project",
         "mdm",
         "sessionFlags",
+        "plugin",
         "legacyManagedConfigFile",
         "legacyManagedConfigMdm",
         "unknown"

codex-rs/app-server-protocol/schema/json/v2/ItemCompletedNotification.json

@@ -668,6 +668,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -710,6 +718,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -740,9 +756,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -766,6 +806,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -806,6 +854,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -834,6 +890,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -860,6 +924,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -899,6 +971,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -939,6 +1027,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -987,12 +1083,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1035,6 +1155,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1057,6 +1193,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewCompletedNotification.json

@@ -184,21 +184,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/v2/ItemGuardianApprovalReviewStartedNotification.json

@@ -177,21 +177,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {

codex-rs/app-server-protocol/schema/json/v2/ItemStartedNotification.json

@@ -668,6 +668,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -710,6 +718,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -740,9 +756,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -766,6 +806,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -806,6 +854,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -834,6 +890,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -860,6 +924,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -899,6 +971,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -939,6 +1027,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -987,12 +1083,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1035,6 +1155,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1057,6 +1193,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ModelProviderCapabilitiesReadParams.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "ModelProviderCapabilitiesReadParams",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/v2/ModelProviderCapabilitiesReadResponse.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "properties": {
+    "imageGeneration": {
+      "type": "boolean"
+    },
+    "namespaceTools": {
+      "type": "boolean"
+    },
+    "webSearch": {
+      "type": "boolean"
+    }
+  },
+  "required": [
+    "imageGeneration",
+    "namespaceTools",
+    "webSearch"
+  ],
+  "title": "ModelProviderCapabilitiesReadResponse",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/v2/RawResponseItemCompletedNotification.json

@@ -143,38 +143,6 @@
         }
       ]
     },
-    "GhostCommit": {
-      "description": "Details of a ghost commit created from a repository state.",
-      "properties": {
-        "id": {
-          "type": "string"
-        },
-        "parent": {
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "preexisting_untracked_dirs": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        },
-        "preexisting_untracked_files": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        }
-      },
-      "required": [
-        "id",
-        "preexisting_untracked_dirs",
-        "preexisting_untracked_files"
-      ],
-      "type": "object"
-    },
     "ImageDetail": {
       "enum": [
         "auto",
@@ -345,12 +313,6 @@
               },
               "type": "array"
             },
-            "end_turn": {
-              "type": [
-                "boolean",
-                "null"
-              ]
-            },
             "id": {
               "type": [
                 "string",
@@ -750,26 +712,6 @@
           "title": "ImageGenerationCallResponseItem",
           "type": "object"
         },
-        {
-          "properties": {
-            "ghost_commit": {
-              "$ref": "#/definitions/GhostCommit"
-            },
-            "type": {
-              "enum": [
-                "ghost_snapshot"
-              ],
-              "title": "GhostSnapshotResponseItemType",
-              "type": "string"
-            }
-          },
-          "required": [
-            "ghost_commit",
-            "type"
-          ],
-          "title": "GhostSnapshotResponseItem",
-          "type": "object"
-        },
         {
           "properties": {
             "encrypted_content": {

codex-rs/app-server-protocol/schema/json/v2/RemoteControlStatusChangedNotification.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "RemoteControlConnectionStatus": {
+      "enum": [
+        "disabled",
+        "connecting",
+        "connected",
+        "errored"
+      ],
+      "type": "string"
+    }
+  },
+  "description": "Current remote-control connection status and environment id exposed to clients.",
+  "properties": {
+    "environmentId": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "status": {
+      "$ref": "#/definitions/RemoteControlConnectionStatus"
+    }
+  },
+  "required": [
+    "status"
+  ],
+  "title": "RemoteControlStatusChangedNotification",
+  "type": "object"
+}

codex-rs/app-server-protocol/schema/json/v2/ReviewStartResponse.json

@@ -812,6 +812,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -854,6 +862,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -884,9 +900,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -910,6 +950,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -950,6 +998,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -978,6 +1034,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1004,6 +1068,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1043,6 +1115,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1083,6 +1171,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1131,12 +1227,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1179,6 +1299,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1201,6 +1337,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadForkParams.json

@@ -183,21 +183,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -488,17 +473,6 @@
         "null"
       ]
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Full permissions override for the forked thread. Cannot be combined with `sandbox`."
-    },
     "sandbox": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadForkResponse.json

@@ -569,21 +569,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -1600,6 +1585,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1642,6 +1635,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1672,9 +1673,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1698,6 +1723,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1738,6 +1771,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1766,6 +1807,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1792,6 +1841,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1831,6 +1888,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1871,6 +1944,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1919,12 +2000,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1967,6 +2072,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1989,6 +2110,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },
@@ -2500,18 +2629,6 @@
     "modelProvider": {
       "type": "string"
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "default": null,
-      "description": "Canonical active permissions view for this thread."
-    },
     "reasoningEffort": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadListResponse.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadMetadataUpdateResponse.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadReadResponse.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadResumeParams.json

@@ -257,21 +257,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -417,38 +402,6 @@
         }
       ]
     },
-    "GhostCommit": {
-      "description": "Details of a ghost commit created from a repository state.",
-      "properties": {
-        "id": {
-          "type": "string"
-        },
-        "parent": {
-          "type": [
-            "string",
-            "null"
-          ]
-        },
-        "preexisting_untracked_dirs": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        },
-        "preexisting_untracked_files": {
-          "items": {
-            "type": "string"
-          },
-          "type": "array"
-        }
-      },
-      "required": [
-        "id",
-        "preexisting_untracked_dirs",
-        "preexisting_untracked_files"
-      ],
-      "type": "object"
-    },
     "ImageDetail": {
       "enum": [
         "auto",
@@ -756,12 +709,6 @@
               },
               "type": "array"
             },
-            "end_turn": {
-              "type": [
-                "boolean",
-                "null"
-              ]
-            },
             "id": {
               "type": [
                 "string",
@@ -1161,26 +1108,6 @@
           "title": "ImageGenerationCallResponseItem",
           "type": "object"
         },
-        {
-          "properties": {
-            "ghost_commit": {
-              "$ref": "#/definitions/GhostCommit"
-            },
-            "type": {
-              "enum": [
-                "ghost_snapshot"
-              ],
-              "title": "GhostSnapshotResponseItemType",
-              "type": "string"
-            }
-          },
-          "required": [
-            "ghost_commit",
-            "type"
-          ],
-          "title": "GhostSnapshotResponseItem",
-          "type": "object"
-        },
         {
           "properties": {
             "encrypted_content": {
@@ -1401,17 +1328,6 @@
         "null"
       ]
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Full permissions override for the resumed thread. Cannot be combined with `sandbox`."
-    },
     "personality": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadResumeResponse.json

@@ -569,21 +569,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -1600,6 +1585,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1642,6 +1635,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1672,9 +1673,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1698,6 +1723,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1738,6 +1771,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1766,6 +1807,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1792,6 +1841,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1831,6 +1888,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1871,6 +1944,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1919,12 +2000,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1967,6 +2072,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1989,6 +2110,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },
@@ -2500,18 +2629,6 @@
     "modelProvider": {
       "type": "string"
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "default": null,
-      "description": "Canonical active permissions view for this thread."
-    },
     "reasoningEffort": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadRollbackResponse.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadStartParams.json

@@ -209,21 +209,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -541,17 +526,6 @@
         "null"
       ]
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Full permissions override for this thread. Cannot be combined with `sandbox`."
-    },
     "personality": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadStartResponse.json

@@ -569,21 +569,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -1600,6 +1585,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1642,6 +1635,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1672,9 +1673,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1698,6 +1723,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1738,6 +1771,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1766,6 +1807,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1792,6 +1841,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1831,6 +1888,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1871,6 +1944,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1919,12 +2000,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1967,6 +2072,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1989,6 +2110,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },
@@ -2500,18 +2629,6 @@
     "modelProvider": {
       "type": "string"
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "default": null,
-      "description": "Canonical active permissions view for this thread."
-    },
     "reasoningEffort": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/ThreadStartedNotification.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadTurnsListResponse.json

@@ -812,6 +812,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -854,6 +862,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -884,9 +900,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -910,6 +950,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -950,6 +998,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -978,6 +1034,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1004,6 +1068,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1043,6 +1115,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1083,6 +1171,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1131,12 +1227,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1179,6 +1299,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1201,6 +1337,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/ThreadUnarchiveResponse.json

@@ -1088,6 +1088,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -1130,6 +1138,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -1160,9 +1176,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -1186,6 +1226,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -1226,6 +1274,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -1254,6 +1310,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1280,6 +1344,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1319,6 +1391,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1359,6 +1447,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1407,12 +1503,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1455,6 +1575,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1477,6 +1613,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/TurnCompletedNotification.json

@@ -812,6 +812,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -854,6 +862,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -884,9 +900,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -910,6 +950,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -950,6 +998,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -978,6 +1034,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1004,6 +1068,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1043,6 +1115,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1083,6 +1171,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1131,12 +1227,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1179,6 +1299,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1201,6 +1337,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/TurnStartParams.json

@@ -218,21 +218,6 @@
           "title": "MinimalFileSystemSpecialPath",
           "type": "object"
         },
-        {
-          "properties": {
-            "kind": {
-              "enum": [
-                "current_working_directory"
-              ],
-              "type": "string"
-            }
-          },
-          "required": [
-            "kind"
-          ],
-          "title": "CurrentWorkingDirectoryFileSystemSpecialPath",
-          "type": "object"
-        },
         {
           "properties": {
             "kind": {
@@ -844,17 +829,6 @@
     "outputSchema": {
       "description": "Optional JSON Schema used to constrain the final assistant message for this turn."
     },
-    "permissionProfile": {
-      "anyOf": [
-        {
-          "$ref": "#/definitions/PermissionProfile"
-        },
-        {
-          "type": "null"
-        }
-      ],
-      "description": "Override the full permissions profile for this turn and subsequent turns. Cannot be combined with `sandboxPolicy`."
-    },
     "personality": {
       "anyOf": [
         {

codex-rs/app-server-protocol/schema/json/v2/TurnStartResponse.json

@@ -812,6 +812,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -854,6 +862,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -884,9 +900,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -910,6 +950,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -950,6 +998,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -978,6 +1034,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1004,6 +1068,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1043,6 +1115,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1083,6 +1171,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1131,12 +1227,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1179,6 +1299,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1201,6 +1337,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/json/v2/TurnStartedNotification.json

@@ -812,6 +812,14 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "cwd": {
               "allOf": [
                 {
@@ -854,6 +862,14 @@
               ],
               "default": "agent"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when command execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/CommandExecutionStatus"
             },
@@ -884,9 +900,33 @@
               },
               "type": "array"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of patch application in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when patch application started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/PatchApplyStatus"
             },
@@ -910,6 +950,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "durationMs": {
               "description": "The duration of the MCP tool call in milliseconds.",
               "format": "int64",
@@ -950,6 +998,14 @@
             "server": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when MCP tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/McpToolCallStatus"
             },
@@ -978,6 +1034,14 @@
         {
           "properties": {
             "arguments": true,
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "contentItems": {
               "items": {
                 "$ref": "#/definitions/DynamicToolCallOutputContentItem"
@@ -1004,6 +1068,14 @@
                 "null"
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when dynamic tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "$ref": "#/definitions/DynamicToolCallStatus"
             },
@@ -1043,6 +1115,22 @@
               "description": "Last known status of the target agents, when available.",
               "type": "object"
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the collab tool execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "description": "Unique identifier for this collab tool call.",
               "type": "string"
@@ -1083,6 +1171,14 @@
               "description": "Thread ID of the agent issuing the collab request.",
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when collab tool execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "allOf": [
                 {
@@ -1131,12 +1227,36 @@
                 }
               ]
             },
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of the web search execution in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
             "query": {
               "type": "string"
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when web search execution started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "type": {
               "enum": [
                 "webSearch"
@@ -1179,6 +1299,22 @@
         },
         {
           "properties": {
+            "completedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation completed, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
+            "durationMs": {
+              "description": "The duration of image generation in milliseconds.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "id": {
               "type": "string"
             },
@@ -1201,6 +1337,14 @@
                 }
               ]
             },
+            "startedAtMs": {
+              "description": "Unix timestamp (in milliseconds) when image generation started, if known.",
+              "format": "int64",
+              "type": [
+                "integer",
+                "null"
+              ]
+            },
             "status": {
               "type": "string"
             },

codex-rs/app-server-protocol/schema/typescript/GhostCommit.ts

@@ -1,8 +0,0 @@
-// GENERATED CODE! DO NOT MODIFY BY HAND!
-
-// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
-
-/**
- * Details of a ghost commit created from a repository state.
- */
-export type GhostCommit = { id: string, parent: string | null, preexisting_untracked_files: Array<string>, preexisting_untracked_dirs: Array<string>, };

codex-rs/app-server-protocol/schema/typescript/InternalSessionSource.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type InternalSessionSource = "memory_consolidation";

codex-rs/app-server-protocol/schema/typescript/ResponseItem.ts

@@ -3,7 +3,6 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { ContentItem } from "./ContentItem";
 import type { FunctionCallOutputBody } from "./FunctionCallOutputBody";
-import type { GhostCommit } from "./GhostCommit";
 import type { LocalShellAction } from "./LocalShellAction";
 import type { LocalShellStatus } from "./LocalShellStatus";
 import type { MessagePhase } from "./MessagePhase";
@@ -11,8 +10,8 @@ import type { ReasoningItemContent } from "./ReasoningItemContent";
 import type { ReasoningItemReasoningSummary } from "./ReasoningItemReasoningSummary";
 import type { WebSearchAction } from "./WebSearchAction";
 
-export type ResponseItem = { "type": "message", role: string, content: Array<ContentItem>, end_turn?: boolean, phase?: MessagePhase, } | { "type": "reasoning", summary: Array<ReasoningItemReasoningSummary>, content?: Array<ReasoningItemContent>, encrypted_content: string | null, } | { "type": "local_shell_call",
+export type ResponseItem = { "type": "message", role: string, content: Array<ContentItem>, phase?: MessagePhase, } | { "type": "reasoning", summary: Array<ReasoningItemReasoningSummary>, content?: Array<ReasoningItemContent>, encrypted_content: string | null, } | { "type": "local_shell_call",
 /**
  * Set when using the Responses API.
  */
-call_id: string | null, status: LocalShellStatus, action: LocalShellAction, } | { "type": "function_call", name: string, namespace?: string, arguments: string, call_id: string, } | { "type": "tool_search_call", call_id: string | null, status?: string, execution: string, arguments: unknown, } | { "type": "function_call_output", call_id: string, output: FunctionCallOutputBody, } | { "type": "custom_tool_call", status?: string, call_id: string, name: string, input: string, } | { "type": "custom_tool_call_output", call_id: string, name?: string, output: FunctionCallOutputBody, } | { "type": "tool_search_output", call_id: string | null, status: string, execution: string, tools: unknown[], } | { "type": "web_search_call", status?: string, action?: WebSearchAction, } | { "type": "image_generation_call", id: string, status: string, revised_prompt?: string, result: string, } | { "type": "ghost_snapshot", ghost_commit: GhostCommit, } | { "type": "compaction", encrypted_content: string, } | { "type": "other" };
+call_id: string | null, status: LocalShellStatus, action: LocalShellAction, } | { "type": "function_call", name: string, namespace?: string, arguments: string, call_id: string, } | { "type": "tool_search_call", call_id: string | null, status?: string, execution: string, arguments: unknown, } | { "type": "function_call_output", call_id: string, output: FunctionCallOutputBody, } | { "type": "custom_tool_call", status?: string, call_id: string, name: string, input: string, } | { "type": "custom_tool_call_output", call_id: string, name?: string, output: FunctionCallOutputBody, } | { "type": "tool_search_output", call_id: string | null, status: string, execution: string, tools: unknown[], } | { "type": "web_search_call", status?: string, action?: WebSearchAction, } | { "type": "image_generation_call", id: string, status: string, revised_prompt?: string, result: string, } | { "type": "compaction", encrypted_content: string, } | { "type": "other" };

codex-rs/app-server-protocol/schema/typescript/SessionSource.ts

@@ -1,6 +1,7 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { InternalSessionSource } from "./InternalSessionSource";
 import type { SubAgentSource } from "./SubAgentSource";
 
-export type SessionSource = "cli" | "vscode" | "exec" | "mcp" | { "custom": string } | { "subagent": SubAgentSource } | "unknown";
+export type SessionSource = "cli" | "vscode" | "exec" | "mcp" | { "custom": string } | { "internal": InternalSessionSource } | { "subagent": SubAgentSource } | "unknown";

codex-rs/app-server-protocol/schema/typescript/index.ts

@@ -29,7 +29,6 @@ export type { GetAuthStatusParams } from "./GetAuthStatusParams";
 export type { GetAuthStatusResponse } from "./GetAuthStatusResponse";
 export type { GetConversationSummaryParams } from "./GetConversationSummaryParams";
 export type { GetConversationSummaryResponse } from "./GetConversationSummaryResponse";
-export type { GhostCommit } from "./GhostCommit";
 export type { GitDiffToRemoteParams } from "./GitDiffToRemoteParams";
 export type { GitDiffToRemoteResponse } from "./GitDiffToRemoteResponse";
 export type { GitSha } from "./GitSha";
@@ -38,6 +37,7 @@ export type { InitializeCapabilities } from "./InitializeCapabilities";
 export type { InitializeParams } from "./InitializeParams";
 export type { InitializeResponse } from "./InitializeResponse";
 export type { InputModality } from "./InputModality";
+export type { InternalSessionSource } from "./InternalSessionSource";
 export type { LocalShellAction } from "./LocalShellAction";
 export type { LocalShellExecAction } from "./LocalShellExecAction";
 export type { LocalShellStatus } from "./LocalShellStatus";

codex-rs/app-server-protocol/schema/typescript/v2/CommandExecParams.ts

@@ -2,7 +2,6 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { CommandExecTerminalSize } from "./CommandExecTerminalSize";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxPolicy } from "./SandboxPolicy";
 
 /**
@@ -13,12 +12,10 @@ import type { SandboxPolicy } from "./SandboxPolicy";
  * sent only after all `command/exec/outputDelta` notifications for that
  * connection have been emitted.
  */
-export type CommandExecParams = {
-/**
+export type CommandExecParams = {/**
  * Command argv vector. Empty arrays are rejected.
  */
-command: Array<string>,
-/**
+command: Array<string>, /**
  * Optional client-supplied, connection-scoped process id.
  *
  * Required for `tty`, `streamStdin`, `streamStdoutStderr`, and follow-up
@@ -26,81 +23,63 @@ command: Array<string>,
  * `command/exec/terminate` calls. When omitted, buffered execution gets an
  * internal id that is not exposed to the client.
  */
-processId?: string | null,
-/**
+processId?: string | null, /**
  * Enable PTY mode.
  *
  * This implies `streamStdin` and `streamStdoutStderr`.
  */
-tty?: boolean,
-/**
+tty?: boolean, /**
  * Allow follow-up `command/exec/write` requests to write stdin bytes.
  *
  * Requires a client-supplied `processId`.
  */
-streamStdin?: boolean,
-/**
+streamStdin?: boolean, /**
  * Stream stdout/stderr via `command/exec/outputDelta` notifications.
  *
  * Streamed bytes are not duplicated into the final response and require a
  * client-supplied `processId`.
  */
-streamStdoutStderr?: boolean,
-/**
+streamStdoutStderr?: boolean, /**
  * Optional per-stream stdout/stderr capture cap in bytes.
  *
  * When omitted, the server default applies. Cannot be combined with
  * `disableOutputCap`.
  */
-outputBytesCap?: number | null,
-/**
+outputBytesCap?: number | null, /**
  * Disable stdout/stderr capture truncation for this request.
  *
  * Cannot be combined with `outputBytesCap`.
  */
-disableOutputCap?: boolean,
-/**
+disableOutputCap?: boolean, /**
  * Disable the timeout entirely for this request.
  *
  * Cannot be combined with `timeoutMs`.
  */
-disableTimeout?: boolean,
-/**
+disableTimeout?: boolean, /**
  * Optional timeout in milliseconds.
  *
  * When omitted, the server default applies. Cannot be combined with
  * `disableTimeout`.
  */
-timeoutMs?: number | null,
-/**
+timeoutMs?: number | null, /**
  * Optional working directory. Defaults to the server cwd.
  */
-cwd?: string | null,
-/**
+cwd?: string | null, /**
  * Optional environment overrides merged into the server-computed
  * environment.
  *
  * Matching names override inherited values. Set a key to `null` to unset
  * an inherited variable.
  */
-env?: { [key in string]?: string | null } | null,
-/**
+env?: { [key in string]?: string | null } | null, /**
  * Optional initial PTY size in character cells. Only valid when `tty` is
  * true.
  */
-size?: CommandExecTerminalSize | null,
-/**
+size?: CommandExecTerminalSize | null, /**
  * Optional sandbox policy for this command.
  *
  * Uses the same shape as thread/turn execution sandbox configuration and
  * defaults to the user's configured policy when omitted. Cannot be
  * combined with `permissionProfile`.
  */
-sandboxPolicy?: SandboxPolicy | null,
-/**
- * Optional full permissions profile for this command.
- *
- * Defaults to the user's configured permissions when omitted. Cannot be
- * combined with `sandboxPolicy`.
- */
-permissionProfile?: PermissionProfile | null, };
+sandboxPolicy?: SandboxPolicy | null};

codex-rs/app-server-protocol/schema/typescript/v2/CommandExecutionRequestApprovalParams.ts

@@ -2,15 +2,12 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { AbsolutePathBuf } from "../AbsolutePathBuf";
-import type { AdditionalPermissionProfile } from "./AdditionalPermissionProfile";
 import type { CommandAction } from "./CommandAction";
-import type { CommandExecutionApprovalDecision } from "./CommandExecutionApprovalDecision";
 import type { ExecPolicyAmendment } from "./ExecPolicyAmendment";
 import type { NetworkApprovalContext } from "./NetworkApprovalContext";
 import type { NetworkPolicyAmendment } from "./NetworkPolicyAmendment";
 
-export type CommandExecutionRequestApprovalParams = { threadId: string, turnId: string, itemId: string,
-/**
+export type CommandExecutionRequestApprovalParams = {threadId: string, turnId: string, itemId: string, /**
  * Unique identifier for this specific approval callback.
  *
  * For regular shell/unified_exec approvals, this is null.
@@ -19,40 +16,25 @@ export type CommandExecutionRequestApprovalParams = { threadId: string, turnId:
  * one parent `itemId`, so `approvalId` is a distinct opaque callback id
  * (a UUID) used to disambiguate routing.
  */
-approvalId?: string | null,
-/**
+approvalId?: string | null, /**
  * Optional explanatory reason (e.g. request for network access).
  */
-reason?: string | null,
-/**
+reason?: string | null, /**
  * Optional context for a managed-network approval prompt.
  */
-networkApprovalContext?: NetworkApprovalContext | null,
-/**
+networkApprovalContext?: NetworkApprovalContext | null, /**
  * The command to be executed.
  */
-command?: string | null,
-/**
+command?: string | null, /**
  * The command's working directory.
  */
-cwd?: AbsolutePathBuf | null,
-/**
+cwd?: AbsolutePathBuf | null, /**
  * Best-effort parsed command actions for friendly display.
  */
-commandActions?: Array<CommandAction> | null,
-/**
- * Optional additional permissions requested for this command.
- */
-additionalPermissions?: AdditionalPermissionProfile | null,
-/**
+commandActions?: Array<CommandAction> | null, /**
  * Optional proposed execpolicy amendment to allow similar commands without prompting.
  */
-proposedExecpolicyAmendment?: ExecPolicyAmendment | null,
-/**
+proposedExecpolicyAmendment?: ExecPolicyAmendment | null, /**
  * Optional proposed network policy amendments (allow/deny host) for future requests.
  */
-proposedNetworkPolicyAmendments?: Array<NetworkPolicyAmendment> | null,
-/**
- * Ordered list of decisions the client may present for this prompt.
- */
-availableDecisions?: Array<CommandExecutionApprovalDecision> | null, };
+proposedNetworkPolicyAmendments?: Array<NetworkPolicyAmendment> | null};

codex-rs/app-server-protocol/schema/typescript/v2/CommandMigration.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type CommandMigration = { name: string, };

codex-rs/app-server-protocol/schema/typescript/v2/ExternalAgentConfigMigrationItemType.ts

@@ -2,4 +2,4 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type ExternalAgentConfigMigrationItemType = "AGENTS_MD" | "CONFIG" | "SKILLS" | "PLUGINS" | "MCP_SERVER_CONFIG";
+export type ExternalAgentConfigMigrationItemType = "AGENTS_MD" | "CONFIG" | "SKILLS" | "PLUGINS" | "MCP_SERVER_CONFIG" | "SUBAGENTS" | "HOOKS" | "COMMANDS" | "SESSIONS";

codex-rs/app-server-protocol/schema/typescript/v2/FileSystemSpecialPath.ts

@@ -2,4 +2,4 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type FileSystemSpecialPath = { "kind": "root" } | { "kind": "minimal" } | { "kind": "current_working_directory" } | { "kind": "project_roots", subpath: string | null, } | { "kind": "tmpdir" } | { "kind": "slash_tmp" } | { "kind": "unknown", path: string, subpath: string | null, };
+export type FileSystemSpecialPath = { "kind": "root" } | { "kind": "minimal" } | { "kind": "project_roots", subpath: string | null, } | { "kind": "tmpdir" } | { "kind": "slash_tmp" } | { "kind": "unknown", path: string, subpath: string | null, };

codex-rs/app-server-protocol/schema/typescript/v2/HookMigration.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type HookMigration = { name: string, };

codex-rs/app-server-protocol/schema/typescript/v2/HookSource.ts

@@ -2,4 +2,4 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 
-export type HookSource = "system" | "user" | "project" | "mdm" | "sessionFlags" | "legacyManagedConfigFile" | "legacyManagedConfigMdm" | "unknown";
+export type HookSource = "system" | "user" | "project" | "mdm" | "sessionFlags" | "plugin" | "legacyManagedConfigFile" | "legacyManagedConfigMdm" | "unknown";

codex-rs/app-server-protocol/schema/typescript/v2/McpServerMigration.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type McpServerMigration = { name: string, };

codex-rs/app-server-protocol/schema/typescript/v2/MigrationDetails.ts

@@ -1,6 +1,11 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { CommandMigration } from "./CommandMigration";
+import type { HookMigration } from "./HookMigration";
+import type { McpServerMigration } from "./McpServerMigration";
 import type { PluginsMigration } from "./PluginsMigration";
+import type { SessionMigration } from "./SessionMigration";
+import type { SubagentMigration } from "./SubagentMigration";
 
-export type MigrationDetails = { plugins: Array<PluginsMigration>, };
+export type MigrationDetails = { plugins: Array<PluginsMigration>, sessions: Array<SessionMigration>, mcpServers: Array<McpServerMigration>, hooks: Array<HookMigration>, subagents: Array<SubagentMigration>, commands: Array<CommandMigration>, };

codex-rs/app-server-protocol/schema/typescript/v2/ModelProviderCapabilitiesReadParams.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ModelProviderCapabilitiesReadParams = Record<string, never>;

codex-rs/app-server-protocol/schema/typescript/v2/ModelProviderCapabilitiesReadResponse.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type ModelProviderCapabilitiesReadResponse = { namespaceTools: boolean, imageGeneration: boolean, webSearch: boolean, };

codex-rs/app-server-protocol/schema/typescript/v2/RemoteControlConnectionStatus.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type RemoteControlConnectionStatus = "disabled" | "connecting" | "connected" | "errored";

codex-rs/app-server-protocol/schema/typescript/v2/RemoteControlStatusChangedNotification.ts

@@ -0,0 +1,9 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+import type { RemoteControlConnectionStatus } from "./RemoteControlConnectionStatus";
+
+/**
+ * Current remote-control connection status and environment id exposed to clients.
+ */
+export type RemoteControlStatusChangedNotification = { status: RemoteControlConnectionStatus, environmentId: string | null, };

codex-rs/app-server-protocol/schema/typescript/v2/SessionMigration.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type SessionMigration = { path: string, cwd: string, title: string | null, };

codex-rs/app-server-protocol/schema/typescript/v2/SubagentMigration.ts

@@ -0,0 +1,5 @@
+// GENERATED CODE! DO NOT MODIFY BY HAND!
+
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type SubagentMigration = { name: string, };

codex-rs/app-server-protocol/schema/typescript/v2/ThreadForkParams.ts

@@ -5,7 +5,6 @@ import type { ServiceTier } from "../ServiceTier";
 import type { JsonValue } from "../serde_json/JsonValue";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxMode } from "./SandboxMode";
 
 /**
@@ -18,27 +17,15 @@ import type { SandboxMode } from "./SandboxMode";
  * Prefer using thread_id whenever possible.
  */
 export type ThreadForkParams = {threadId: string, /**
- * [UNSTABLE] Specify the rollout path to fork from.
- * If specified, the thread_id param will be ignored.
- */
-path?: string | null, /**
  * Configuration overrides for the forked thread, if any.
  */
 model?: string | null, modelProvider?: string | null, serviceTier?: ServiceTier | null | null, cwd?: string | null, approvalPolicy?: AskForApproval | null, /**
  * Override where approval requests are routed for review on this thread
  * and subsequent turns.
  */
-approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, /**
- * Full permissions override for the forked thread. Cannot be combined
- * with `sandbox`.
- */
-permissionProfile?: PermissionProfile | null, config?: { [key in string]?: JsonValue } | null, baseInstructions?: string | null, developerInstructions?: string | null, ephemeral?: boolean, /**
+approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, config?: { [key in string]?: JsonValue } | null, baseInstructions?: string | null, developerInstructions?: string | null, ephemeral?: boolean, /**
  * When true, return only thread metadata and live fork state without
  * populating `thread.turns`. This is useful when the client plans to call
  * `thread/turns/list` immediately after forking.
  */
-excludeTurns?: boolean, /**
- * If true, persist additional rollout EventMsg variants required to
- * reconstruct a richer thread history on subsequent resume/fork/read.
- */
-persistExtendedHistory: boolean};
+excludeTurns?: boolean};

codex-rs/app-server-protocol/schema/typescript/v2/ThreadForkResponse.ts

@@ -6,26 +6,18 @@ import type { ReasoningEffort } from "../ReasoningEffort";
 import type { ServiceTier } from "../ServiceTier";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxPolicy } from "./SandboxPolicy";
 import type { Thread } from "./Thread";
 
-export type ThreadForkResponse = { thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf,
-/**
+export type ThreadForkResponse = {thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf, /**
  * Instruction source files currently loaded for this thread.
  */
-instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval,
-/**
+instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval, /**
  * Reviewer currently used for approval requests on this thread.
  */
-approvalsReviewer: ApprovalsReviewer,
-/**
+approvalsReviewer: ApprovalsReviewer, /**
  * Legacy sandbox policy retained for compatibility. New clients should use
  * `permissionProfile` when present as the canonical active permissions
  * view.
  */
-sandbox: SandboxPolicy,
-/**
- * Canonical active permissions view for this thread.
- */
-permissionProfile: PermissionProfile | null, reasoningEffort: ReasoningEffort | null, };
+sandbox: SandboxPolicy, reasoningEffort: ReasoningEffort | null};

codex-rs/app-server-protocol/schema/typescript/v2/ThreadItem.ts

@@ -50,14 +50,50 @@ aggregatedOutput: string | null,
  * The command's exit code.
  */
 exitCode: number | null,
+/**
+ * Unix timestamp (in milliseconds) when command execution started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when command execution completed, if known.
+ */
+completedAtMs: number | null,
 /**
  * The duration of the command execution in milliseconds.
  */
-durationMs: number | null, } | { "type": "fileChange", id: string, changes: Array<FileUpdateChange>, status: PatchApplyStatus, } | { "type": "mcpToolCall", id: string, server: string, tool: string, status: McpToolCallStatus, arguments: JsonValue, mcpAppResourceUri?: string, result: McpToolCallResult | null, error: McpToolCallError | null,
+durationMs: number | null, } | { "type": "fileChange", id: string, changes: Array<FileUpdateChange>, status: PatchApplyStatus,
+/**
+ * Unix timestamp (in milliseconds) when patch application started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when patch application completed, if known.
+ */
+completedAtMs: number | null,
+/**
+ * The duration of patch application in milliseconds.
+ */
+durationMs: number | null, } | { "type": "mcpToolCall", id: string, server: string, tool: string, status: McpToolCallStatus, arguments: JsonValue, mcpAppResourceUri?: string, result: McpToolCallResult | null, error: McpToolCallError | null,
+/**
+ * Unix timestamp (in milliseconds) when MCP tool execution started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when MCP tool execution completed, if known.
+ */
+completedAtMs: number | null,
 /**
  * The duration of the MCP tool call in milliseconds.
  */
 durationMs: number | null, } | { "type": "dynamicToolCall", id: string, namespace: string | null, tool: string, arguments: JsonValue, status: DynamicToolCallStatus, contentItems: Array<DynamicToolCallOutputContentItem> | null, success: boolean | null,
+/**
+ * Unix timestamp (in milliseconds) when dynamic tool execution started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when dynamic tool execution completed, if known.
+ */
+completedAtMs: number | null,
 /**
  * The duration of the dynamic tool call in milliseconds.
  */
@@ -98,4 +134,40 @@ reasoningEffort: ReasoningEffort | null,
 /**
  * Last known status of the target agents, when available.
  */
-agentsStates: { [key in string]?: CollabAgentState }, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null, } | { "type": "imageView", id: string, path: AbsolutePathBuf, } | { "type": "imageGeneration", id: string, status: string, revisedPrompt: string | null, result: string, savedPath?: AbsolutePathBuf, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };
+agentsStates: { [key in string]?: CollabAgentState },
+/**
+ * Unix timestamp (in milliseconds) when collab tool execution started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when collab tool execution completed, if known.
+ */
+completedAtMs: number | null,
+/**
+ * The duration of the collab tool execution in milliseconds.
+ */
+durationMs: number | null, } | { "type": "webSearch", id: string, query: string, action: WebSearchAction | null,
+/**
+ * Unix timestamp (in milliseconds) when web search execution started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when web search execution completed, if known.
+ */
+completedAtMs: number | null,
+/**
+ * The duration of the web search execution in milliseconds.
+ */
+durationMs: number | null, } | { "type": "imageView", id: string, path: AbsolutePathBuf, } | { "type": "imageGeneration", id: string, status: string, revisedPrompt: string | null, result: string, savedPath?: AbsolutePathBuf,
+/**
+ * Unix timestamp (in milliseconds) when image generation started, if known.
+ */
+startedAtMs: number | null,
+/**
+ * Unix timestamp (in milliseconds) when image generation completed, if known.
+ */
+completedAtMs: number | null,
+/**
+ * The duration of image generation in milliseconds.
+ */
+durationMs: number | null, } | { "type": "enteredReviewMode", id: string, review: string, } | { "type": "exitedReviewMode", id: string, review: string, } | { "type": "contextCompaction", id: string, };

codex-rs/app-server-protocol/schema/typescript/v2/ThreadResumeParams.ts

@@ -2,12 +2,10 @@
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 import type { Personality } from "../Personality";
-import type { ResponseItem } from "../ResponseItem";
 import type { ServiceTier } from "../ServiceTier";
 import type { JsonValue } from "../serde_json/JsonValue";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxMode } from "./SandboxMode";
 
 /**
@@ -22,32 +20,15 @@ import type { SandboxMode } from "./SandboxMode";
  * Prefer using thread_id whenever possible.
  */
 export type ThreadResumeParams = {threadId: string, /**
- * [UNSTABLE] FOR CODEX CLOUD - DO NOT USE.
- * If specified, the thread will be resumed with the provided history
- * instead of loaded from disk.
- */
-history?: Array<ResponseItem> | null, /**
- * [UNSTABLE] Specify the rollout path to resume from.
- * If specified, the thread_id param will be ignored.
- */
-path?: string | null, /**
  * Configuration overrides for the resumed thread, if any.
  */
 model?: string | null, modelProvider?: string | null, serviceTier?: ServiceTier | null | null, cwd?: string | null, approvalPolicy?: AskForApproval | null, /**
  * Override where approval requests are routed for review on this thread
  * and subsequent turns.
  */
-approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, /**
- * Full permissions override for the resumed thread. Cannot be combined
- * with `sandbox`.
- */
-permissionProfile?: PermissionProfile | null, config?: { [key in string]?: JsonValue } | null, baseInstructions?: string | null, developerInstructions?: string | null, personality?: Personality | null, /**
+approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, config?: { [key in string]?: JsonValue } | null, baseInstructions?: string | null, developerInstructions?: string | null, personality?: Personality | null, /**
  * When true, return only thread metadata and live-resume state without
  * populating `thread.turns`. This is useful when the client plans to call
  * `thread/turns/list` immediately after resuming.
  */
-excludeTurns?: boolean, /**
- * If true, persist additional rollout EventMsg variants required to
- * reconstruct a richer thread history on subsequent resume/fork/read.
- */
-persistExtendedHistory: boolean};
+excludeTurns?: boolean};

codex-rs/app-server-protocol/schema/typescript/v2/ThreadResumeResponse.ts

@@ -6,26 +6,18 @@ import type { ReasoningEffort } from "../ReasoningEffort";
 import type { ServiceTier } from "../ServiceTier";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxPolicy } from "./SandboxPolicy";
 import type { Thread } from "./Thread";
 
-export type ThreadResumeResponse = { thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf,
-/**
+export type ThreadResumeResponse = {thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf, /**
  * Instruction source files currently loaded for this thread.
  */
-instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval,
-/**
+instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval, /**
  * Reviewer currently used for approval requests on this thread.
  */
-approvalsReviewer: ApprovalsReviewer,
-/**
+approvalsReviewer: ApprovalsReviewer, /**
  * Legacy sandbox policy retained for compatibility. New clients should use
  * `permissionProfile` when present as the canonical active permissions
  * view.
  */
-sandbox: SandboxPolicy,
-/**
- * Canonical active permissions view for this thread.
- */
-permissionProfile: PermissionProfile | null, reasoningEffort: ReasoningEffort | null, };
+sandbox: SandboxPolicy, reasoningEffort: ReasoningEffort | null};

codex-rs/app-server-protocol/schema/typescript/v2/ThreadStartParams.ts

@@ -6,7 +6,6 @@ import type { ServiceTier } from "../ServiceTier";
 import type { JsonValue } from "../serde_json/JsonValue";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxMode } from "./SandboxMode";
 import type { ThreadStartSource } from "./ThreadStartSource";
 
@@ -14,16 +13,4 @@ export type ThreadStartParams = {model?: string | null, modelProvider?: string |
  * Override where approval requests are routed for review on this thread
  * and subsequent turns.
  */
-approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, /**
- * Full permissions override for this thread. Cannot be combined with
- * `sandbox`.
- */
-permissionProfile?: PermissionProfile | null, config?: { [key in string]?: JsonValue } | null, serviceName?: string | null, baseInstructions?: string | null, developerInstructions?: string | null, personality?: Personality | null, ephemeral?: boolean | null, sessionStartSource?: ThreadStartSource | null, /**
- * If true, opt into emitting raw Responses API items on the event stream.
- * This is for internal use only (e.g. Codex Cloud).
- */
-experimentalRawEvents: boolean, /**
- * If true, persist additional rollout EventMsg variants required to
- * reconstruct a richer thread history on resume/fork/read.
- */
-persistExtendedHistory: boolean};
+approvalsReviewer?: ApprovalsReviewer | null, sandbox?: SandboxMode | null, config?: { [key in string]?: JsonValue } | null, serviceName?: string | null, baseInstructions?: string | null, developerInstructions?: string | null, personality?: Personality | null, ephemeral?: boolean | null, sessionStartSource?: ThreadStartSource | null};

codex-rs/app-server-protocol/schema/typescript/v2/ThreadStartResponse.ts

@@ -6,26 +6,18 @@ import type { ReasoningEffort } from "../ReasoningEffort";
 import type { ServiceTier } from "../ServiceTier";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxPolicy } from "./SandboxPolicy";
 import type { Thread } from "./Thread";
 
-export type ThreadStartResponse = { thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf,
-/**
+export type ThreadStartResponse = {thread: Thread, model: string, modelProvider: string, serviceTier: ServiceTier | null, cwd: AbsolutePathBuf, /**
  * Instruction source files currently loaded for this thread.
  */
-instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval,
-/**
+instructionSources: Array<AbsolutePathBuf>, approvalPolicy: AskForApproval, /**
  * Reviewer currently used for approval requests on this thread.
  */
-approvalsReviewer: ApprovalsReviewer,
-/**
+approvalsReviewer: ApprovalsReviewer, /**
  * Legacy sandbox policy retained for compatibility. New clients should use
  * `permissionProfile` when present as the canonical active permissions
  * view.
  */
-sandbox: SandboxPolicy,
-/**
- * Canonical active permissions view for this thread.
- */
-permissionProfile: PermissionProfile | null, reasoningEffort: ReasoningEffort | null, };
+sandbox: SandboxPolicy, reasoningEffort: ReasoningEffort | null};

codex-rs/app-server-protocol/schema/typescript/v2/TurnStartParams.ts

@@ -1,7 +1,6 @@
 // GENERATED CODE! DO NOT MODIFY BY HAND!
 
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
-import type { CollaborationMode } from "../CollaborationMode";
 import type { Personality } from "../Personality";
 import type { ReasoningEffort } from "../ReasoningEffort";
 import type { ReasoningSummary } from "../ReasoningSummary";
@@ -9,7 +8,6 @@ import type { ServiceTier } from "../ServiceTier";
 import type { JsonValue } from "../serde_json/JsonValue";
 import type { ApprovalsReviewer } from "./ApprovalsReviewer";
 import type { AskForApproval } from "./AskForApproval";
-import type { PermissionProfile } from "./PermissionProfile";
 import type { SandboxPolicy } from "./SandboxPolicy";
 import type { UserInput } from "./UserInput";
 
@@ -27,10 +25,6 @@ approvalsReviewer?: ApprovalsReviewer | null, /**
  * Override the sandbox policy for this turn and subsequent turns.
  */
 sandboxPolicy?: SandboxPolicy | null, /**
- * Override the full permissions profile for this turn and subsequent
- * turns. Cannot be combined with `sandboxPolicy`.
- */
-permissionProfile?: PermissionProfile | null, /**
  * Override the model for this turn and subsequent turns.
  */
 model?: string | null, /**
@@ -49,11 +43,4 @@ personality?: Personality | null, /**
  * Optional JSON Schema used to constrain the final assistant message for
  * this turn.
  */
-outputSchema?: JsonValue | null, /**
- * EXPERIMENTAL - Set a pre-set collaboration mode.
- * Takes precedence over model, reasoning_effort, and developer instructions if set.
- *
- * For `collaboration_mode.settings.developer_instructions`, `null` means
- * "use the built-in instructions for the selected mode".
- */
-collaborationMode?: CollaborationMode | null};
+outputSchema?: JsonValue | null};

codex-rs/app-server-protocol/schema/typescript/v2/index.ts

@@ -58,6 +58,7 @@ export type { CommandExecutionRequestApprovalParams } from "./CommandExecutionRe
 export type { CommandExecutionRequestApprovalResponse } from "./CommandExecutionRequestApprovalResponse";
 export type { CommandExecutionSource } from "./CommandExecutionSource";
 export type { CommandExecutionStatus } from "./CommandExecutionStatus";
+export type { CommandMigration } from "./CommandMigration";
 export type { Config } from "./Config";
 export type { ConfigBatchWriteParams } from "./ConfigBatchWriteParams";
 export type { ConfigEdit } from "./ConfigEdit";
@@ -154,6 +155,7 @@ export type { HookCompletedNotification } from "./HookCompletedNotification";
 export type { HookEventName } from "./HookEventName";
 export type { HookExecutionMode } from "./HookExecutionMode";
 export type { HookHandlerType } from "./HookHandlerType";
+export type { HookMigration } from "./HookMigration";
 export type { HookOutputEntry } from "./HookOutputEntry";
 export type { HookOutputEntryKind } from "./HookOutputEntryKind";
 export type { HookPromptFragment } from "./HookPromptFragment";
@@ -209,6 +211,7 @@ export type { McpResourceReadResponse } from "./McpResourceReadResponse";
 export type { McpServerElicitationAction } from "./McpServerElicitationAction";
 export type { McpServerElicitationRequestParams } from "./McpServerElicitationRequestParams";
 export type { McpServerElicitationRequestResponse } from "./McpServerElicitationRequestResponse";
+export type { McpServerMigration } from "./McpServerMigration";
 export type { McpServerOauthLoginCompletedNotification } from "./McpServerOauthLoginCompletedNotification";
 export type { McpServerOauthLoginParams } from "./McpServerOauthLoginParams";
 export type { McpServerOauthLoginResponse } from "./McpServerOauthLoginResponse";
@@ -231,6 +234,8 @@ export type { Model } from "./Model";
 export type { ModelAvailabilityNux } from "./ModelAvailabilityNux";
 export type { ModelListParams } from "./ModelListParams";
 export type { ModelListResponse } from "./ModelListResponse";
+export type { ModelProviderCapabilitiesReadParams } from "./ModelProviderCapabilitiesReadParams";
+export type { ModelProviderCapabilitiesReadResponse } from "./ModelProviderCapabilitiesReadResponse";
 export type { ModelRerouteReason } from "./ModelRerouteReason";
 export type { ModelReroutedNotification } from "./ModelReroutedNotification";
 export type { ModelUpgradeInfo } from "./ModelUpgradeInfo";
@@ -282,6 +287,8 @@ export type { ReasoningSummaryTextDeltaNotification } from "./ReasoningSummaryTe
 export type { ReasoningTextDeltaNotification } from "./ReasoningTextDeltaNotification";
 export type { RemoteControlClientConnectionAudience } from "./RemoteControlClientConnectionAudience";
 export type { RemoteControlClientEnrollmentAudience } from "./RemoteControlClientEnrollmentAudience";
+export type { RemoteControlConnectionStatus } from "./RemoteControlConnectionStatus";
+export type { RemoteControlStatusChangedNotification } from "./RemoteControlStatusChangedNotification";
 export type { RequestPermissionProfile } from "./RequestPermissionProfile";
 export type { ResidencyRequirement } from "./ResidencyRequirement";
 export type { ReviewDelivery } from "./ReviewDelivery";
@@ -294,6 +301,7 @@ export type { SandboxWorkspaceWrite } from "./SandboxWorkspaceWrite";
 export type { SendAddCreditsNudgeEmailParams } from "./SendAddCreditsNudgeEmailParams";
 export type { SendAddCreditsNudgeEmailResponse } from "./SendAddCreditsNudgeEmailResponse";
 export type { ServerRequestResolvedNotification } from "./ServerRequestResolvedNotification";
+export type { SessionMigration } from "./SessionMigration";
 export type { SessionSource } from "./SessionSource";
 export type { SkillDependencies } from "./SkillDependencies";
 export type { SkillErrorInfo } from "./SkillErrorInfo";
@@ -310,6 +318,7 @@ export type { SkillsListExtraRootsForCwd } from "./SkillsListExtraRootsForCwd";
 export type { SkillsListParams } from "./SkillsListParams";
 export type { SkillsListResponse } from "./SkillsListResponse";
 export type { SortDirection } from "./SortDirection";
+export type { SubagentMigration } from "./SubagentMigration";
 export type { TerminalInteractionNotification } from "./TerminalInteractionNotification";
 export type { TextElement } from "./TextElement";
 export type { TextPosition } from "./TextPosition";

codex-rs/app-server-protocol/src/export.rs

@@ -736,11 +736,11 @@ fn find_top_level_brace_span(input: &str) -> Option<(usize, usize)> {
     let mut state = ScanState::default();
     let mut open_index = None;
     for (index, ch) in input.char_indices() {
-        if !state.in_string() && ch == '{' && state.depth.is_top_level() {
+        if !state.in_ignored_syntax() && ch == '{' && state.depth.is_top_level() {
             open_index = Some(index);
         }
         state.observe(ch);
-        if !state.in_string()
+        if !state.in_ignored_syntax()
             && ch == '}'
             && state.depth.is_top_level()
             && let Some(open) = open_index
@@ -760,7 +760,7 @@ fn split_top_level_multi(input: &str, delimiters: &[char]) -> Vec<String> {
     let mut start = 0usize;
     let mut parts = Vec::new();
     for (index, ch) in input.char_indices() {
-        if !state.in_string() && state.depth.is_top_level() && delimiters.contains(&ch) {
+        if !state.in_ignored_syntax() && state.depth.is_top_level() && delimiters.contains(&ch) {
             let part = input[start..index].trim();
             if !part.is_empty() {
                 parts.push(part.to_string());
@@ -882,22 +882,58 @@ struct ScanState {
     depth: Depth,
     string_delim: Option<char>,
     escape: bool,
+    block_comment: bool,
+    line_comment: bool,
+    previous_char: Option<char>,
 }
 
 impl ScanState {
     fn observe(&mut self, ch: char) {
+        if self.line_comment {
+            if ch == '\n' {
+                self.line_comment = false;
+            }
+            self.previous_char = Some(ch);
+            return;
+        }
+
+        if self.block_comment {
+            if self.previous_char == Some('*') && ch == '/' {
+                self.block_comment = false;
+                self.previous_char = None;
+            } else {
+                self.previous_char = Some(ch);
+            }
+            return;
+        }
+
         if let Some(delim) = self.string_delim {
             if self.escape {
                 self.escape = false;
+                self.previous_char = Some(ch);
                 return;
             }
             if ch == '\\' {
                 self.escape = true;
+                self.previous_char = Some(ch);
                 return;
             }
             if ch == delim {
                 self.string_delim = None;
             }
+            self.previous_char = Some(ch);
+            return;
+        }
+
+        if self.previous_char == Some('/') && ch == '/' {
+            self.line_comment = true;
+            self.previous_char = Some(ch);
+            return;
+        }
+
+        if self.previous_char == Some('/') && ch == '*' {
+            self.block_comment = true;
+            self.previous_char = Some(ch);
             return;
         }
 
@@ -919,10 +955,11 @@ impl ScanState {
             }
             _ => {}
         }
+        self.previous_char = Some(ch);
     }
 
-    fn in_string(&self) -> bool {
-        self.string_delim.is_some()
+    fn in_ignored_syntax(&self) -> bool {
+        self.string_delim.is_some() || self.block_comment || self.line_comment
     }
 }
 
@@ -2694,6 +2731,79 @@ export type Config = { stableField: Keep, unstableField: string | null } & ({ [k
         Ok(())
     }
 
+    #[test]
+    fn experimental_type_fields_ts_filter_handles_generated_command_params_shape() -> Result<()> {
+        let output_dir = std::env::temp_dir().join(format!("codex_ts_filter_{}", Uuid::now_v7()));
+        fs::create_dir_all(&output_dir)?;
+
+        struct TempDirGuard(PathBuf);
+
+        impl Drop for TempDirGuard {
+            fn drop(&mut self) {
+                let _ = fs::remove_dir_all(&self.0);
+            }
+        }
+
+        let _guard = TempDirGuard(output_dir.clone());
+        let path = output_dir.join("CommandExecParams.ts");
+        let content = r#"import type { CommandExecTerminalSize } from "./CommandExecTerminalSize";
+import type { PermissionProfile } from "./PermissionProfile";
+import type { SandboxPolicy } from "./SandboxPolicy";
+
+export type CommandExecParams = {/**
+ * Command argv vector. Empty arrays are rejected.
+ */
+command: Array<string>, /**
+ * Optional environment overrides merged into the server-computed
+ * environment.
+ */
+env?: { [key in string]?: string | null } | null, /**
+ * Optional initial PTY size in character cells. Only valid when `tty` is
+ * true.
+ */
+size?: CommandExecTerminalSize | null, /**
+ * Optional sandbox policy for this command.
+ *
+ * Uses the same shape as thread/turn execution sandbox configuration and
+ * defaults to the user's configured policy when omitted. Cannot be
+ * combined with `permissionProfile`.
+ */
+sandboxPolicy?: SandboxPolicy | null,
+/**
+ * Optional full permissions profile for this command.
+ *
+ * Defaults to the user's configured permissions when omitted. Cannot be
+ * combined with `sandboxPolicy`.
+ */
+permissionProfile?: PermissionProfile | null};
+"#;
+        fs::write(&path, content)?;
+
+        static CUSTOM_FIELD: crate::experimental_api::ExperimentalField =
+            crate::experimental_api::ExperimentalField {
+                type_name: "CommandExecParams",
+                field_name: "permissionProfile",
+                reason: "command/exec.permissionProfile",
+            };
+        filter_experimental_type_fields_ts(&output_dir, &[&CUSTOM_FIELD])?;
+
+        let filtered = fs::read_to_string(&path)?;
+        assert_eq!(
+            filtered.contains("permissionProfile?: PermissionProfile"),
+            false
+        );
+        assert_eq!(
+            filtered.contains(r#"import type { PermissionProfile } from "./PermissionProfile";"#),
+            false
+        );
+        assert_eq!(filtered.contains("sandboxPolicy?: SandboxPolicy"), true);
+        assert_eq!(
+            filtered.contains(r#"import type { SandboxPolicy } from "./SandboxPolicy";"#),
+            true
+        );
+        Ok(())
+    }
+
     #[test]
     fn stable_schema_filter_removes_mock_experimental_method() -> Result<()> {
         let output_dir = std::env::temp_dir().join(format!("codex_schema_{}", Uuid::now_v7()));

codex-rs/app-server-protocol/src/protocol/common_tests.rs

@@ -0,0 +1,44 @@
+use super::*;
+use anyhow::Result;
+use codex_protocol::protocol::TurnAbortReason;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+
+#[test]
+fn client_response_payload_returns_jsonrpc_parts_and_client_response() -> Result<()> {
+    let (request_id, result, payload) =
+        ClientResponsePayload::ThreadArchive(v2::ThreadArchiveResponse {})
+            .into_jsonrpc_parts_and_payload(RequestId::Integer(7))?;
+
+    assert_eq!(request_id, RequestId::Integer(7));
+    assert_eq!(result, json!({}));
+
+    let Some(ClientResponse::ThreadArchive {
+        request_id,
+        response: _,
+    }) = payload.and_then(|payload| payload.into_client_response(RequestId::Integer(7)))
+    else {
+        panic!("expected thread/archive client response");
+    };
+    assert_eq!(request_id, RequestId::Integer(7));
+    Ok(())
+}
+
+#[test]
+fn interrupt_conversation_payload_stays_jsonrpc_only() -> Result<()> {
+    let (request_id, result, payload) =
+        ClientResponsePayload::InterruptConversation(v1::InterruptConversationResponse {
+            abort_reason: TurnAbortReason::Interrupted,
+        })
+        .into_jsonrpc_parts_and_payload(RequestId::Integer(8))?;
+
+    assert_eq!(request_id, RequestId::Integer(8));
+    assert_eq!(
+        result,
+        json!({
+            "abortReason": "interrupted",
+        })
+    );
+    assert!(payload.is_none());
+    Ok(())
+}

codex-rs/app-server-protocol/src/protocol/item_builders.rs

@@ -45,6 +45,9 @@ pub fn build_file_change_approval_request_item(
         id: payload.call_id.clone(),
         changes: convert_patch_changes(&payload.changes),
         status: PatchApplyStatus::InProgress,
+        started_at_ms: None,
+        completed_at_ms: None,
+        duration_ms: None,
     }
 }
 
@@ -53,6 +56,9 @@ pub fn build_file_change_begin_item(payload: &PatchApplyBeginEvent) -> ThreadIte
         id: payload.call_id.clone(),
         changes: convert_patch_changes(&payload.changes),
         status: PatchApplyStatus::InProgress,
+        started_at_ms: payload.started_at_ms,
+        completed_at_ms: None,
+        duration_ms: None,
     }
 }
 
@@ -61,6 +67,9 @@ pub fn build_file_change_end_item(payload: &PatchApplyEndEvent) -> ThreadItem {
         id: payload.call_id.clone(),
         changes: convert_patch_changes(&payload.changes),
         status: (&payload.status).into(),
+        started_at_ms: payload.started_at_ms,
+        completed_at_ms: payload.completed_at_ms,
+        duration_ms: payload.duration_ms,
     }
 }
 
@@ -82,6 +91,8 @@ pub fn build_command_execution_approval_request_item(
             .collect(),
         aggregated_output: None,
         exit_code: None,
+        started_at_ms: None,
+        completed_at_ms: None,
         duration_ms: None,
     }
 }
@@ -102,6 +113,8 @@ pub fn build_command_execution_begin_item(payload: &ExecCommandBeginEvent) -> Th
             .collect(),
         aggregated_output: None,
         exit_code: None,
+        started_at_ms: payload.started_at_ms,
+        completed_at_ms: None,
         duration_ms: None,
     }
 }
@@ -129,6 +142,8 @@ pub fn build_command_execution_end_item(payload: &ExecCommandEndEvent) -> Thread
             .collect(),
         aggregated_output,
         exit_code: Some(payload.exit_code),
+        started_at_ms: payload.started_at_ms,
+        completed_at_ms: payload.completed_at_ms,
         duration_ms: Some(duration_ms),
     }
 }
@@ -158,6 +173,8 @@ pub fn build_item_from_guardian_event(
                 command_actions,
                 aggregated_output: None,
                 exit_code: None,
+                started_at_ms: None,
+                completed_at_ms: None,
                 duration_ms: None,
             })
         }
@@ -194,6 +211,8 @@ pub fn build_item_from_guardian_event(
                 command_actions,
                 aggregated_output: None,
                 exit_code: None,
+                started_at_ms: None,
+                completed_at_ms: None,
                 duration_ms: None,
             })
         }