Skip to content

CCCC v0.4.57 Release Notes ​

CCCC v0.4.57 makes the collaboration you already have run more smoothly and lets you shape quick replies to your own habits. A slow capability no longer holds up the rest of CCCC: enabling a capability or calling an external tool no longer makes other requests wait for the external service, in the same Group or another. Quick replies become one list for each signed-in user: up to 24 replies in your order, where the four default ones can be reworded, reordered or deleted like your own. ChatGPT Web members keep their conversation when it moves into a Project, MCP recipes with a command field that imported but failed to install now install, and an automation rule that owes a run says so. On Windows, background program launches share a no-console-window default, with CI checks to catch paths that bypass it. When Chet runs on OpenCode, a message sent while it is busy now waits its turn and goes to Chet's own session instead of through its terminal, where it could reach another session (#229).

This release adds no new runtime, and a daemon restart works as before: agents that CCCC started stop with the daemon, and a turn that was running does not continue when CCCC starts them again; sessions you started yourself keep running. What a daemon restart keeps has the details. The Windows fix has not yet been verified in the reported Codex and Windows Terminal setup, for managed Codex agents or for Codex sessions you started yourself; see Windows Background Programs. Part of the Chet report is not explained yet; see Chet on OpenCode. This release covers the changes since v0.4.56.

Before You Upgrade ​

Before upgrading, let sends and recordings finish. Restore or discard waiting sends, then send or copy every unsent draft, restored ones included, and save unsaved edits in Files: all of these live only in the open page. Check whether a message already arrived before sending it again.

Upgrade the CCCC executable, restart the daemon and Web the way you usually launch them, and reload open CCCC pages. The standalone installer behind cccc update stops a running daemon and starts it again from the new version. Before a pip upgrade, run cccc daemon stop and close any foreground CCCC so pip can replace the executable, especially on Windows. A daemon left running keeps the previous version. Runtime history stays in CCCC_HOME.

  • A new CCCC Web connected to a daemon that still runs v0.4.56 shows the capability page's Enabled count as 0 and offers no quick replies, the default ones included; CCCC Web also shows its notice that the Web server and daemon run different versions. Restarting the daemon fixes these.
  • An MCP command recipe whose record has a command or fallback_command field, or string candidates, that earlier versions ignored may report a changed recipe after the upgrade. Its installed command keeps running until you update the recipe explicitly.
  • An agent that reads a parent task through MCP gets the parent's full details and its subtasks as summary rows; it reads a subtask by its own ID for the subtask's notes and checklist. The daemon's task operations and CCCC Web are unchanged.
  • Programs that call the daemon directly:
    • capability_tool_call with a tool name returns the call's actual result with state_update_skipped: true and a state_update_skipped_reason when, while the call ran, the capability was disabled or its recipe or installation changed, the member's configuration or token changed, or the state could not be checked or saved; the call's state is then not written back. When the original caller is no longer valid, for example because the member was removed and added again, it returns permission_denied instead of the result. An error after the call was sent carries external_action_may_have_occurred: true and automatic_retry: false. Without a tool name, capability_tool_call still reads the capability record by its ID.
    • quick_reply_templates_get returns the caller's quick replies as one ordered replies list, the default ones included, and quick_reply_templates_set replaces that whole list over the revision last read. replies is required; a default reply left out of a save is deleted from the list.

Slow Capabilities No Longer Hold Up Other Work ​

Enabling a capability, for example a remote MCP server that is slow to answer, and calling an external tool now wait for the external service without making other CCCC requests wait. In isolated tests whose fixture held the external service until released, a Mail send, inbox reads and a health check from the same Group and from another Group returned while an enable was held. While a tool call was held, a Mail send and an inbox read in its Group and a health check from another Group returned, also with a global write waiting in line. In v0.4.56, a slow enable made such requests from another Group wait as long as the external service did, and a slow tool call held up its own Group.

  • Before CCCC records the outcome of a slow enable or call, it checks again that nothing it depends on changed in the meantime: the Group and the member, the member's configuration, the capability's recipe and installation, and whether the capability was disabled. A disable during a slow enable wins, and an old call cannot restore a changed installation.
  • A call that was already sent to the external service is never sent again automatically. If something fails after that point, the error says the action may have happened, so check before retrying.

Importing a capability that is enabled at once, updating a recipe, installing for a target and applying capabilities when an agent starts still work as before; see Known Limitations.

Quick Replies of Your Own ​

Settings › Quick Replies keeps one list of up to 24 quick replies, each with a name and a text that is sent exactly as written. The list starts with four default replies, and you can add, edit, reorder and delete any of them.

  • A default reply's name or text that you leave unchanged follows the interface language; one you change stays as written in every language. Restore default puts a changed default reply back, and a deleted one can be brought back at the end of the list, as its default, without changing the others. Changes apply once you save.
  • A message's quick reply menu lists your replies in your order. Choosing one sends it at once as a reply to that message, without touching your draft, attachments or the message you are replying to in the composer.
  • The Insert a template button under the composer, framed like the attachment button, lists the same replies. The list opens above the input without covering your draft: on a computer it starts near where you are typing, as the @ list does, and on a phone it spans the input. Each row shows the name and the first non-empty line of the text. Filter by name and choose with the keyboard or the mouse; the text goes in at the cursor, replacing selected text, and the rest of your draft stays, so you can edit it before sending. Manage templates opens the settings tab.
  • The daemon keeps one list per signed-in user, so other browsers and phones signed in as that user see the same replies. A browser on this computer that is not signed in has its own.

ChatGPT Web Members ​

  • A new ChatGPT chat whose address still carries a local-chatgpt: conversation ID, plain or percent-encoded, stays pending like one with a WEB: ID, until ChatGPT assigns the conversation's own ID. Contributed in #226.
  • A conversation moved into a Project (/g/<project>/c/<id>) keeps its binding and its delivery receipts; another conversation, another origin or a provisional ID still does not match. Contributed in #227.

MCP Command Recipes ​

A recipe that declares command as a string or an argv array, or a fallback command without a package identifier, imported but then failed to install. Such recipes now install as imported. A string names one executable and is never split by a shell; arguments need an argv array, kept as written. Malformed command fields are rejected before the catalog changes, a string that looks like a whole command line gets a hint to use an argv array, and the import tool's description tells agents the same.

Windows Background Programs ​

On Windows, the CCCC daemon runs without a console of its own, so a console program it started could get a new, visible console window. A managed Codex agent's background app-server opened a window that could not be closed without disconnecting the agent, and with Windows Terminal as the default terminal, each delivery to a Codex session you started yourself could leave an error window, although the message arrived. Reported in #228.

Background programs now use shared launch defaults without a console window. These cover the Codex app-server and native-session delivery helper, managed Claude launchers and version checks, local MCP servers, Reach's cloudflared and process checks, Git commands used when creating or attaching a Group, and other runtime preparation commands. Arguments, redirected streams, timeouts and process ownership keep their existing behavior. Interactive PTY/ConPTY terminals, foreground installers and CLI force-stop output, and the daemon's own detached startup retain their separate policies.

Production code is checked by Clippy for direct standard or Tokio process constructors that bypass these defaults. Foreground and detached exceptions carry explicit reasons, and checks also cover the standard production entry points and Windows-only code. These are CI checks; an ordinary build does not run them.

The runtime library and its Windows tests were checked for a Windows target on Linux. Windows-only branches in the daemon and CLI will first be compiled by Windows CI; this release has not been run locally on Windows. Windows CI is configured to check the launch policy and test the standard and Tokio constructors, owned process launch and finite capture, with redirected input and output, under a detached parent. A raw launch must first detect a console, so the test cannot pass merely because the runner cannot distinguish it. The standard constructor is tested directly so another wrapper cannot hide a missing flag. The reported Codex and Windows Terminal setup still needs verification with a Windows package; if a window remains, please comment on #228.

Chet on OpenCode ​

When Chet runs on OpenCode and is busy, a message you send it and a member's result reported to it now wait until the current turn ends and then go, one at a time, to the session Chet is bound to, each in its own turn, so that each result belongs to one input. Stop cancels the messages you sent that are still waiting, but it still cannot interrupt the running turn on OpenCode and reports an error. Before, CCCC typed such input into Chet's terminal, which is OpenCode's own interface. After /new in that terminal, the input went to the new session while CCCC kept waiting for it in Chet's session; that wait did not end when the turn finished, and Group messages to Chet waited behind it. Ordinary OpenCode members already received input through their session. Voice delegations during a call and other runtimes are unchanged.

A report in which replies finished in Chet's own session but no result appeared in CCCC is not explained yet; see Known Limitations (#229).

Other Fixes ​

  • Automation: a cron rule that already owes a run, for example one enabled again after missing its time, shows that run as its next time, labeled pending in CCCC Web, instead of the following occurrence. The owed run still fires once.
  • Capability page: the Enabled count covers all matches of the current search, like the Skills, MCP and Packs counts, instead of only the page on screen.
  • Web slash commands for capability tools pass their arguments to the tool. Before, the tool ran without them.
  • Chat composer: after you replace or delete selected text, Undo keeps the highlight of an @mention later in the draft. Who receives the message was not affected.
  • Documentation: the home page's getting-started button works when its link is opened directly, and the operations guide has a table of what a daemon restart keeps and what it does not, with a FAQ entry.
  • Agents: cccc_bootstrap includes when the Group brief was last updated (coordination_brief.updated_at), so an agent resuming work can see that a brief is old. It is left out when the brief has no recorded update time.

Known Limitations ​

  • Importing a capability that is enabled at once, updating a recipe, installing for a target and applying capabilities when an agent starts still make other requests, in other Groups too, wait until the external service answers or the download finishes. How long real servers and downloads take, and how often this happens, was not measured.
  • Quick replies saved in a browser on this computer that is not signed in do not move to a signed-in user's list.
  • After you sign in as another user in a different tab, reload the CCCC pages that were already open. Until then a page can still show the previous user's quick replies, and saving there can replace the new user's.
  • On Windows, the background launch policy covers CCCC's own background launch sites. It does not prevent a runtime or another program from opening its own further windows, and it does not change Windows Terminal. The reported Codex and Windows Terminal setup has not been verified, and Linux checks are not Windows evidence: the policy and its tests run in Windows CI, and the reported setup needs a check with a Windows package.
  • On OpenCode, replies that finished in Chet's own session without a result in CCCC have been reported and are not explained yet (#229); the reporter restored Chet with Save & restart in its settings. During a voice call, a delegation made while Chet is busy is still typed into Chet's terminal, so after /new there it can reach another session and hold up Chet's later input. Stop does not release that wait; restarting Chet can, but it does not recover missing results.

Validation Scope ​

Release preparation ran these checks on the final code, the Rust checks in isolated homes: rustfmt, clippy and the Rust tests in CI's three groups, so each of the 4,117 tests that are not ignored among the 4,127 listed ran once and passed; the Web check and the Web tests (5,065 tests in 673 files), run after the last change to the Web code; the repository's Python tests (128) and ruff; and git diff --check. After the last edit to these notes, git diff --check and the Python tests were run again.

The changes landed in five reviewed batches. Both maintainers reviewed each batch independently, and before each gate a fresh-context review followed the changed paths across CCCC's entry points. The issues it confirmed were fixed before release, except two Chet points described under Chet on OpenCode and Known Limitations; in the Windows launch changes it found no defect. Each batch was also checked when it landed, the Rust tests in isolated homes; the last batch's gate is the one above:

  • First batch (ChatGPT addresses, MCP command recipes, the automation display, the Enabled count and the documentation fixes): rustfmt, clippy and the Rust tests in CI's three groups, so each of the 4,081 tests that are not ignored among the 4,091 listed ran once and passed; the Web check, build and tests (5,019 tests in 668 files); the repository's Python tests (126). Four new regressions also ran on their own before the full gate.
  • Second batch (staged capability work, quick replies, task reads, the brief's update time): the first full gate failed. Three existing tests showed that the ID-only capability_tool_call read had been routed into the new staged path, and one test still expected the old waiting behavior that this release replaces. After the fixes, rustfmt, clippy and the Rust tests passed, each of the 4,106 tests that are not ignored among the 4,116 listed run once; the Web check and tests (5,041 tests in 672 files) and the Python tests (126) passed.
  • Capability work was checked with a debug build of that tree in isolated homes, with the fixture service held until released. While an enable was held, Mail sends, inbox reads, inbox summaries, pings and MCP catalog reads from the same Group and from another Group returned, and the same requests answered after the release. While a tool call was held, a Mail send and an inbox read in its Group and a ping from another Group returned, with and without a queued global write, and the call completed after the release.
  • Quick replies were checked when they landed, in headless Chrome at desktop and phone width against that batch's Web bundle: inserting a template at the cursor, replacing a selection, native Undo and Redo, Undo of a deletion and the fallback for browsers without insertText kept the draft and its later @mention; twenty templates scroll in the list, and Manage templates opens the settings tab. The Undo fix was checked against v0.4.56 on the same steps. Later batches changed where the template list opens and how it lists replies, not how a template is inserted.
  • Third batch (Windows background programs): rustfmt, clippy and the Rust tests in CI's three groups, each of the 4,106 tests that are not ignored among the 4,116 listed run once; the Web check and tests (5,041 tests in 672 files) and the Python tests (126) passed. The Windows code and test targets were type-checked for Windows rather than run there.
  • Fourth batch (editable default replies, which the fifth batch folds into one list): the fresh-context review confirmed two issues, one in Settings across interface languages and one in how an open page picks up changes saved elsewhere; both were fixed and covered by tests before the final checks. Review also caught a malformed save that could clear the saved changes; it is now refused, and a daemon test covers it.
  • Fifth batch (the rest of the Windows launch paths, the composer's template list, quick replies as one list, Chet on OpenCode):
    • Windows: the fresh-context review found no defect in the launch changes; it led to three documentation fixes and a clearer comment. The Windows-only crates and the runtime library were checked with clippy for a Windows target on Linux; the Windows tests first run in Windows CI.
    • Quick replies: the fresh-context review confirmed one issue, that saving the unchanged default list before a person's first save still wrote the file and advanced the revision; it was fixed with a daemon test. In headless Chrome in isolated homes, with a debug CLI built from the reviewed code: Settings, the message menu and the composer list showed the same mixed order in Chinese, Japanese and English at desktop and phone width; a changed default could be restored in place, a deleted default could be brought back at the end and saved, and unchanged names followed the interface language. A separate check saved a mixed order, field changes, a deletion, a restore and an added-back default with twenty replies of your own, whose IDs and texts were kept, and sent the two quick replies only to the intercepted browser request. Both entry points' names lined up, and the move and delete buttons kept one column.
    • The composer's template list opened near the insertion point on desktop and across the input on a phone, at the end of a draft, in an empty draft, inside a multi-line draft, over a selection that it replaced and in a short window; twenty-four replies scrolled, and filtering by name worked.
    • Chet on OpenCode: tests with a stand-in OpenCode server and terminal, without a model. In a run where Chet received three text inputs, the second while the first was still being admitted and the third after /new had switched the terminal to another chat during the first's turn, followed by a member's result and a Group message, all five went to Chet's own session in queue order; each text input got its own result, the Group message its own completion, and none of the five was typed into the terminal. After an admission with an unknown outcome, nothing was retried and the queued input behind it was not sent. Voice delegations still use the terminal, and ordinary OpenCode members still receive input through their session. These checks ran on Linux; real OpenCode and Windows were not tested. The fresh-context review confirmed that a voice delegation after /new can still hold up Chet's queue, already listed under Known Limitations, and that Stop cancels waiting messages while the running turn continues, now described under Chet on OpenCode; it also found that one test did not check that nothing was typed into the terminal, which it now checks.
    • Screenshots of these screens were checked by eye.

Thanks to chriscoveries for the two ChatGPT address fixes, to ZiLin-Lab for the detailed Windows report, to Hase12323 for the Chet report and its investigation, and to everyone who tested and reported issues.

Full source comparison

Released under the Apache-2.0 License.