Shared AI Conversations, Codex & a Rebuilt Engine

New

• Shared AI conversations everywhere — Every AI surface in Trinity is now a shared, multi-user conversation — onboarding, planning (Architect), alignment, audits, and the help assistant. Each one is a real-time thread your team works in together: see who's present, watch replies stream in, @agent to bring an assistant into the turn, and pick up a conversation someone else started.
• Multiple design drafts in Architect — Architect is now a list of design drafts instead of a single slot. Keep several plans in flight, and any teammate can open any draft to keep planning. "Implement" from an Audit or Align result opens a fresh, pre-filled draft instead of overwriting one you're working on.
• Saved Audit and Align sessions — Audits and alignment sweeps are now named sessions you and your team can revisit, re-run, and archive, with a Mine / All view to see what teammates are looking at. Each session keeps its full conversation, so you can ask follow-up questions about the results.
• Help chat with history — The in-app assistant keeps a history of conversations: start a new chat, revisit or delete past ones, and reach it — and Report a Bug — from the floating button in the bottom-right corner.
• OpenAI Codex as an engine — Codex joins Claude as an engine Trinity can run on, chosen from Settings → AI Models with the same low/medium/high/xhigh effort slider you already use on Claude. The engine you pick powers every AI action in Trinity — onboarding, planning, alignment, audits, the help assistant, and story runs alike — not just one surface; set defaults globally and override them per team or project. Pick GPT-5.5, GPT-5.4, or GPT-5.4 Mini, each surfaced with intelligence ratings and cost estimates next to the Claude models in the picker. Trinity launches Codex through its official CLI, so authentication uses your existing codex login (or a Trinity-managed OpenAI key if you'd rather keep it scoped to the app).
• Conversations sync across your devices — Open the help assistant on your laptop, keep going on your desktop. Your conversation is live, not a snapshot — open Trinity on a second machine and the same thread is already there, picking up wherever the other device left off.
• Multi-user onboarding — Project onboarding is no longer single-player. Invite your teammates into the onboarding flow and everyone in the project sees the same conversation, contributes turns, and watches replies arrive together. New projects with more than one member prompt you to choose: keep it private, or onboard as a team.
• Discuss, propose, and branch in onboarding — Inside team onboarding, each question can open a side discussion, the AI can propose an answer or a stack change you Apply or Dismiss, and a side question ("tangent") takes the whole team along and then returns to where you were — with every answer attributed to who gave it.
• The agent knows when to speak up — When you're the only person in a conversation, the assistant answers every message. As soon as a teammate joins, it steps back and waits to be addressed — type @agent and it picks up the turn and streams a reply. That keeps a busy team conversation from triggering a chorus of unwanted replies while still letting anyone pull the agent in, and you never have to flip a setting: it follows who's actually in the room.
• Type while the agent works — The message box never locks while a reply is streaming. Keep typing and anything you send is queued for the next turn, shown as a chip you can remove before it's picked up. A Stop button interrupts a reply in progress and clears the queue. Every AI surface — help chat, Architect, Align, Audit, and onboarding — works this way.
• Readable agent replies — The assistant's work now renders as cards you can scan: its reasoning, plans, file changes, and the commands and tools it ran, each as its own block. Tool steps collapse by default — expand one when you want the details — so a long turn stays easy to follow.
• See who's in the room — A row of avatars at the top of multi-user threads shows everyone who can see the conversation. Adds and removes propagate live; no refresh needed.
• Streaming replies survive a refresh — Refresh the page mid-stream and the conversation picks up where it left off — the most recent tokens replay from a short server-side buffer, then live streaming continues. No lost output, no stuck "thinking" indicator.
• Retry and diagnose failed stories — A story that can't get through — repeated failures, a merge conflict, or a PR that was closed out from under it — now lands in a clear Failed state instead of stalling. Open Diagnose to investigate what went wrong on that run in a read-only chat, then Retry to clear the failure and send the story back through.
• Architect removes stories safely — Architect can now delete a story along with whatever depends on it as a single, reviewed change. It shows a preview of everything a removal would ripple out to before you confirm, and refuses to apply one that would leave your plan half-finished — so your story graph is never left in a broken state.
• Stories that are already done get skipped — When Trinity finds a story's work already exists in your codebase, it marks the story Already Done and moves on instead of re-implementing it.
• Steer a story with comments — Leave a comment on a story and the agents read it when the story runs, treating any unresolved note as a constraint — "match the pattern in X", "don't use Y this time", "this needs to handle Z". It's the way to add a clarification after a story is written, including one that's already locked from editing; resolve the comment once it no longer applies and the agents stop following it.

Improved

• Streamlined onboarding — Setting up API keys and command-line tools moved out of the onboarding wizard, so onboarding is shorter and focused on planning your project. You configure keys and services afterward from Project Settings → Secrets, and Trinity prompts you for anything a run actually needs, when it needs it.
• Permission requests stay local, awareness is shared — When an agent asks to run a tool action, only the user whose agent it is gets the Allow / Deny dialog — your teammates never see it pop up on their machine. They do see a read-only chip in the thread saying that someone's tool action is waiting for approval (and then which way it was decided), so the whole room knows what's happening without anyone else being able to greenlight it. The raw tool input never leaves the originator's machine; only a short redacted summary travels with the awareness chip.
• Claude integration uses Anthropic's official SDK — Trinity now drives Claude Code through the @anthropic-ai/claude-agent-sdk instead of shelling out to the CLI for streaming runs. Cancellation is cleaner (closing a story actually kills the underlying process the moment you click stop), errors are classified more precisely (rate limit vs. context window vs. auth expired vs. network), and the MCP tools Trinity exposes to Claude (project state, knowledge lookups, etc.) now wire in through the SDK's native shape instead of a temp file written for each run.
• More precise token / cost reporting — Both Claude and Codex token counts now read directly from each provider's structured usage payload (input, output, cache reads, cache writes, reasoning tokens) instead of being inferred or summed in ways that double-counted cached input. Per-story spend and the AI Usage page reflect what each provider actually billed.
• Job dispatcher rebuilt for structured cancellation and recovery — The background loop that picks up runnable stories, launches workers, watches their health, and idles when there's nothing to do was rewritten end-to-end. Cancelling a run, stopping a release mid-flight, or shutting down the desktop app all tear down running workers cleanly through a single structured-cancellation path — no orphan processes, no stuck jobs. Scheduling is drift-free (intervals run on time even under load), and the scanner checks runnable stories and creates jobs in parallel batches instead of one-at-a-time, so larger backlogs clear faster.
• Drain reports progress during shutdown — When you stop the coordinator (or shut down the desktop app) while workers are still running, Trinity now emits status ticks during the drain so the Stop button and Live Execution panel show real progress instead of sitting on "stopping" until everything settles or the drain timeout fires.
• Health recovery fans out — The periodic recovery sweep that picks up jobs stuck on a stale handoff used to walk them one at a time; it now processes a batch in parallel, so a project with several stuck jobs recovers in roughly the same time as one stuck job did before.
• Watch a reply build, step by step — Replies stream live as they're written instead of appearing all at once, and in a shared thread everyone watching sees each step land as it finishes — the agent's reasoning, a file change, a command run, then the answer. A clearer "thinking" indicator sits at the bottom of the conversation until the first words arrive, so you always know the agent is working.
• Claude Opus 4.8 — Opus 4.8 joins the model picker and is the new default for the reasoning tier, with the full low-to-max effort range.

Fixed

• Stop kills in-flight workers without waiting on the next poll — Cancelling a story or stopping a release now interrupts the worker fiber immediately through structured cancellation, instead of relying on the next loop tick to notice the abort signal.
• Coordinator drain no longer strands stragglers — If a worker doesn't settle within the drain window, Trinity now explicitly marks the straggler job as cancelled with a clear reason instead of leaving it in a half-stopped state for the next health sweep to clean up.
• The help assistant opens instantly — Opening Help Chat no longer stalls or hangs: the conversation and its history load in one shot from the button, past messages no longer pop in a beat late, and a chat you open right after sending a message reliably gets a reply instead of going quiet.