CCCC v0.4.34 Release Notes

v0.4.34 is CCCC's largest platform update since v0.4.33. It introduces an experimental native Rust implementation inside the same CCCC product, adds an experimental GPT Pro delivery mode for ChatGPT Web Model actors, and strengthens the shared state, delivery, browser, terminal, and release boundaries that let Python and Rust operate against one collaboration system.

Python remains the stable default. Rust is an explicit opt-in for users who want to evaluate faster startup, lower runtime overhead, and native distribution. Both implementations share the same public command, product version, Web UI, daemon contract, and CCCC_HOME, but complete Rust feature and integration parity is not yet promised.

One CCCC Product, Two Implementations

The recommended cccc-pair installation now carries both implementations on supported native platforms. Linux x86-64, Intel and Apple Silicon macOS, and Windows x86-64 wheels include a private, version-matched Rust executable behind the normal cccc launcher. The portable wheel remains a Python-only fallback for other platforms.

Python stays selected for a fresh installation. Users can opt into Rust and return to Python without installing competing public commands:

cccc status          # Show selected, running, and available implementations
cccc rust            # Select experimental Rust and launch CCCC
cccc python          # Return to stable Python and launch CCCC
cccc rust doctor     # Select Rust and run one command

Implementation switching is a real lifecycle operation. CCCC validates that the payload matches the installed product version, stops the active Web and daemon pair, and never silently falls back to another engine. Existing runtime MCP configurations continue to point at the public cccc launcher, so they follow a later implementation switch automatically.

Both engines use the same Working Groups, append-only ledgers, active selection, actor definitions, settings, tasks, automation, integrations, browser targets, and connector credentials. Cross-engine migrations and write paths were hardened so that switching implementations does not revive revoked state, lose actor generation boundaries, reinterpret inbox order, or create a second durable authority.

An optional standalone Rust preview is also available through the hosted installer for users who want to evaluate a native-only deployment without Python. This channel remains experimental, contains no Python fallback, and does not support implementation switching. The pip distribution remains the stable, recommended product path.

Experimental GPT Pro Delivery for ChatGPT Web Model

ChatGPT Web Model actors now offer two per-actor delivery modes:

• Standard remains the default and sends text only.
• GPT Pro is an experimental compatibility mode that attaches one deterministic 32×32 blank PNG before submitting each delivered batch.

The GPT Pro mode exists for accounts where attaching an image makes the CCCC third-party MCP connector available to a GPT Pro conversation. CCCC uses the browser file input directly rather than the operating-system clipboard, treats the attachment and prompt as one submission transaction, and leaves the message uncommitted when attachment fails before Send.

This is a browser-transport workaround, not a ChatGPT model API. CCCC does not select or change the model, cannot guarantee that the connector will be exposed, and cannot promise that the behavior will survive future ChatGPT changes. The mode is therefore explicit, visibly experimental, and stored per actor across daemon restarts and Python/Rust switches.

The broader ChatGPT Web Model path received a substantial reliability pass:

• A saved conversation is now the delivery authority, and new-chat delivery binds the final /c/... URL before later work is accepted.
• Session bootstrap content is injected once per bound conversation rather than being repeated after completion reconciliation.
• CCCC targets the visible editable composer and its local Send control, never a hidden compatibility textarea or the Stop button.
• Pre-click deferrals remain retryable, while post-click uncertainty follows an at-most-once policy instead of risking a duplicate prompt.
• One failed or blocked batch no longer permanently poisons later unread work.
• Delivery health, evidence, target state, receipts, and recovery status are projected consistently by Python and Rust.
• The embedded Page surface provides direct browser interaction, with a Browser viewer fallback where appropriate. Pointer-targeted scrolling, persistent profiles, Linux Xvfb isolation, and conversation reopening were aligned across the shared browser stack.

Better Runtime and Terminal Continuity

Cline is now a first-class PTY runtime. CCCC can discover the CLI, create actors with its supported TUI defaults, configure or repair the named cccc MCP server, and report its readiness consistently through CLI diagnostics and the Web actor editor.

Codex and Claude startup now preserve provider-session identity more reliably. Fenced hook events prevent stale launches from overwriting a newer session, and compatible actors can resume their exact provider thread after an ordinary stop, restart, daemon restart, or implementation switch. When a Codex version does not support the current hook contract—or a bounded probe fails—CCCC degrades to MCP-only launch instead of starting the actor without its collaboration tools.

Runtime recovery is also less noisy and more truthful. Fresh headless sessions receive one bounded unread summary instead of a replay of every historical message body. Paused or explicitly stopped Groups remain delivery-disabled, and failed deferred work releases or reschedules its reservation so a later message can continue independently.

The native terminal path now supports bounded raw-byte replay, exact reconnect cursors, ANSI screen snapshots, responsive input during backpressure, explicit viewer/controller ownership, and safe session replacement. Reopening a terminal restores its latest screen without replaying multi-megabyte histories or losing output produced during the attach boundary.

Stronger Shared State, Messaging, and Group Bridge

The Python and Rust engines now converge on the user-visible outcome of core collaboration operations rather than merely exposing similarly named routes.

• Inbox cursors, read status, attention obligations, and Web Model completion use append-only ledger order instead of wall-clock timestamps.
• High-level sends, replies, attachments, tracked messages, and cross-Group receipts preserve their source identity and remain idempotent across retries.
• Actor recreation establishes a durable generation boundary so an actor cannot inherit messages from an earlier incarnation.
• Active Group selection, Group scopes, runtime lifecycle state, and Web status remain coherent when the active implementation changes.
• Group Bridge route health reflects a connection that can actually deliver. Trust revocation closes live routes and cannot be resurrected from a legacy shadow record.
• Shared IM state preserves provider-native identifiers such as Slack thread timestamps while retaining compatibility with older stored records.
• Connector credentials, assistant state, voice leases, automation rules, and browser delivery preferences now use common durable authorities rather than engine-specific copies.

These changes also improve failure truth. A remote success cannot suppress its local receipt through peer-provided metadata, an offline retry reuses the existing source event, and a failed item does not silently advance a cursor or block unrelated later work.

Voice Secretary and NotebookLM

Voice Secretary now keeps one durable document and session model across Python and Rust. A recording stays attached to the Group and document captured when it started even if the user navigates elsewhere. Manual Ask, Instruction, and Optimize controls continue to target the currently selected Group, while background recording completion writes back to the frozen recording scope.

Long and silent recordings are safer. Native ASR releases accumulated streaming features at detected endpoints, segmented recognition reports partial failure instead of presenting incomplete text as complete, and speaker diarization uses bounded admission rather than an unbounded queue of large temporary recordings. Clearing transcripts, renewing recording leases, and reconnecting audio streams now preserve the expected authorization and generation boundaries.

The NotebookLM integration has been refreshed to the vendored notebooklm-py 0.8.0 provider boundary. Authentication, status detection, notebook binding, source operations, research, artifact generation, and download handling were updated together. The projected sign-in browser uses the same shared Page/Browser surface, while provider schema drift and expired authentication remain visible instead of being mistaken for a successful connection.

Security, Installation, and Release Integrity

Remote Web exposure now has one administrator-token boundary across the product. Group-scoped Web tokens receive routing notifications only for their authorized Groups, and the global SSE channel carries event identity and Group routing metadata rather than complete message content. Administrative capability and listener changes cannot be performed with a scoped token.

Installer and update behavior is more conservative across platforms. Unix and Windows installers validate an exact ownership marker before replacing a public cccc command, preserve rollback state, report PATH conflicts, and avoid overwriting another installation without explicit authorization. Windows builds use a static CRT boundary, tolerate bounded transient executable locks, and enable TLS 1.2 for the PowerShell download path.

Release publication now treats Python and Rust as one versioned product. The Python source distribution, portable wheel, four native wheels, native binaries, checksums, and installer candidates are verified as complete, version-matched sets. Cross-language persisted-state tests, installed-wheel smoke tests, native daemon/MCP checks, and supported-platform installer verification protect the engine-switch boundary before publication.

Web and Capability Experience

The Web composer now starts new users with Need Reply semantics while remembering the user's most recent delivery choice as a long-term preference. Delivery receipts and ChatGPT submission status are visible consistently across engines, without adding persistent explanatory clutter above the composer.

Capability discovery and installation now preserve qualification and support metadata. Blocked or unsupported records are not offered as autoload candidates, native installation updates slash-command visibility atomically, and reconnecting clients catch up without replacing the last known-good catalog with a stale response.

Additional Web polish includes implementation-aware startup banners, more stable chat scroll anchors, bounded terminal loading, iOS visual-viewport handling, mobile-only overflow actions, safer browser-surface sizing and scrolling, and consistent English, Chinese, and Japanese labels for new runtime states.

Upgrade Notes

• Upgrade the recommended distribution with python -m pip install -U cccc-pair or cccc update from an existing managed installation.
• Python 3.11 through 3.14 remain supported. Python is still the stable initial default after installation.
• Use cccc rust only when you explicitly want to evaluate the experimental implementation. Use cccc python to return to the stable engine.
• No Working Group, ledger, or settings migration is required. Both engines use the same CCCC_HOME, and legacy state is imported into canonical shared stores where necessary.
• GPT Pro delivery is opt-in per ChatGPT Web Model actor. It does not change the ChatGPT model and should be treated as a compatibility experiment.
• Existing custom Cline commands remain valid. Run cccc setup --runtime cline to install or repair the standard CCCC MCP entry for the Cline CLI.
• The standalone Rust installer has no Python fallback. Prefer the pip product for reliability-critical work and implementation switching.

Why Upgrade

Upgrade to v0.4.34 if you want to evaluate CCCC's native Rust engine without splitting your installation or data model, use ChatGPT GPT Pro through the new experimental attachment-assisted delivery mode, add Cline as a managed runtime, or benefit from the broader delivery, recovery, terminal, Voice Secretary, NotebookLM, Group Bridge, security, and cross-engine reliability work.

The product direction remains deliberate: one collaboration truth, Python and Rust optimized for different strengths, explicit maturity boundaries, and no silent fallback when the system cannot prove what happened.