Reliable ChatGPT shared-chat ingestion in Codex: preserve long conversations and report completeness

Summary

Please provide a supported way for Codex to ingest an explicitly supplied ChatGPT shared conversation, including long conversations, with a clear indication of whether the full transcript was retrieved.

Opening a share link and reading some visible messages is not enough: implementation work may depend on requirements, constraints, rejected approaches, and decisions spread across the entire conversation.

This is a renewed feature request following #17462. That issue was closed automatically for insufficient upvotes; the closing comment explicitly invited a new request with an updated title and description:
https://github.com/openai/codex/issues/17462#issuecomment-4857721794

Observed behavior

Observed on September 7, 2026, using Codex desktop on Windows 10 and a shared conversation originally created in ordinary ChatGPT Chat mode, not Work mode. The exact desktop build was not captured.

1. I supplied a valid ChatGPT share URL and asked whether Codex could read the complete conversation.
2. The web-reading tool failed to fetch the URL with DisabledError. This is an observed tool result, not evidence of a specific root cause.
3. Codex could open the same URL through its in-app browser.
4. The rendered/accessibility view initially exposed the later exchanges. A navigation index listed 15 user prompts, but the initial text extraction did not include all of those exchanges.
5. Navigating to the first prompt made the opening exchange available.

Browser navigation therefore provided partial access, but did not by itself establish that the full conversation had been ingested. The agent correctly disclosed that it had not read everything; I would like the product to make this distinction reliable and explicit.

These are two separate concerns: direct-fetch availability and completeness of browser-based extraction. I have not established that they share a root cause, or that the same behavior occurs on every Codex surface.

The original share URL and conversation content are intentionally omitted because they contain project-specific context.

Reproduction

1. Create a long ordinary ChatGPT conversation with many user/assistant exchanges. Place a distinct test requirement near the beginning, another in the middle, and another at the end.
2. Generate a share link.
3. In a Codex task, provide the link and request the complete transcript or a requirements review based on the whole conversation.
4. Check whether the direct reader can access it.
5. If browser fallback is used, compare the retrieved messages against the full conversation, rather than just the currently rendered portion.
6. Verify whether all three test requirements are present and whether Codex clearly reports any missing sections.

The synthetic markers above are a proposed reproducible test, not a test I have already run.

Why this matters

A common workflow is to explore a problem extensively in ChatGPT, then move to Codex to implement it. The conversation is the specification: the latest response often relies on earlier constraints and corrections.

Incomplete ingestion can lead to:

• implementation based on superseded decisions;
• missed constraints or acceptance criteria;
• repetition of approaches already rejected;
• extra manual copying, verification, and tool usage;
• reduced trust in claims that a linked conversation has been read.

Long conversations are precisely where manual copy/paste and checking every exchange become least practical. A summary is useful after ingestion, but should not silently substitute for the original source.

Requested behavior / acceptance criteria

• Support an explicit, user-authorized shared-chat import/read flow. This does not require granting access to unrelated account history.
• Preserve the ordered user and assistant transcript, including code blocks and links, independently of which messages are currently rendered.
• Return useful source metadata and a completeness result: complete, partial, or unavailable. Include message counts when known and identify omissions when detectable.
• Distinguish tool/access failures from partial extraction; do not present a partial transcript as a complete read.
• For content larger than one tool response or context window, provide stable chunks or a local Markdown/JSON artifact that Codex can read and reference incrementally.
• Clearly identify attachments or other content that could not be included.
• Validate with a long-conversation regression test containing known content at the beginning, middle, and end.

A supported transcript-export/import contract would also be a useful solution; the exact implementation is less important than reliable completeness and provenance.

Existing community workarounds

Community projects demonstrate demand for structured extraction rather than relying solely on visible page text:

• https://github.com/schneiderjoseph/chatgpt-share-md — shared-link to Markdown/JSON extraction.
• https://github.com/pencil311/chat-share-reader — CLI/MCP transcript extraction and metadata.

I reviewed their documentation but have not validated these tools against my conversation. They are references for possible approaches, not verified fixes or a request to adopt their code. A first-party solution would avoid making users depend on parsers tied to undocumented page formats.

Relationship to the previous request

#17462 focused on basic access to shared conversations and was reported against Codex Cloud. This request adds a desktop observation, a separate long-conversation completeness concern, a concrete Chat-to-Codex workflow, and measurable acceptance criteria.

If this is already covered by active work elsewhere, please link the tracking issue or implementation so users can follow the supported path.

Start by tracing the direct URL reader and Codex in-app browser paths described in the issue; no repository files or existing tests are named. Use the proposed long-conversation regression scenario with markers at the beginning, middle, and end, and verify ordered transcript preservation, completeness status, omissions, and chunked or artifact-based access.