Commit Graph
57 Commits
Author SHA1 Message Date
Brennan Benson 50ecb96893 Offer only the speeds the model lists (#40257)
A speed the chat reports that no model lists, in practice Flex from the
user's own Codex config, is no longer added to the Speed choices. It
still runs and is still sent. A chat with no model of its own keeps its
saved speed when some model lists it, so Standard can still turn it off.
2026-11-09 15:08:48 -08:00
Kelvin Amoaba acf3aead78 fix(agent-status): show Codex's mid-turn async question as waiting for the user (#39087)
* fix(agent-status): show Codex's mid-turn async question as waiting for the user

* fix(agent-status): keep Codex's async question waiting on paired hosts under its working title

The phone's PTY-title renewal turned the waiting row back into working, because Codex keeps its working title while the question waits.

* fix(agent-status): clear Codex's open async questions when the user sends a plain message

Orca's chat card answers an async question as a quoted message, not Codex's reply wrapper, so the pane stayed waiting until the turn ended.

* refactor(agent-status): move the legacy status test seed out of listener-state
2026-11-09 20:42:22 +00:00
Brennan Benson b602376e8b Show AskUserQuestion option previews on desktop and phone (#40109)
* Show AskUserQuestion option previews on desktop and phone

Claude can attach a preview (a mockup or snippet) to each option of a
single-select question. Orca dropped it, so users chose between bare labels.
Options now carry the preview through the journal, terminal asks and the
phone, and the question card shows the selected option's preview as plain
monospace text. Questions with previews confirm explicitly instead of
auto-advancing, so the preview stays readable.

* Keep phone previews bounded and digit focus on the named option

Phone previews get a capped height with their own vertical scroll, and
opening one never scrolls past its top. A digit always focuses its row
before the chosen-row check, so Enter confirms the option the user named.
Tighter preview line height, a stable phone row root, and a persistence
test whose expected previews come from the fixed input.

* Narrow the reopened question with a type guard instead of a cast
2026-11-09 12:31:52 -08:00
Kelvin Amoaba a086693d78 fix(native-chat): show newly installed skills in the Codex $ menu before the first message (#40012)
* fix(native-chat): show newly installed skills in the Codex $ menu before the first message

Resting Codex chats served the background probe's skills/list from a
5-minute cache, so a skill installed in that window showed "No matching
skills", even in a new chat. Each menu open now compares a cheap stamp
of Codex's skill folders and skill/plugin config with the one taken
before the last scan, and rescans only when it changed.

Probe requests always force a reload, and probe pools are keyed by the
catalog's launch generation instead of the whole env, whose 10 s refresh
started a second Codex on every rescan.

Fixes STA-14359

* fix(native-chat): keep the structured session hook within its line limit
2026-11-09 02:25:15 +00:00
Brennan Benson 1f5a5e155c /btw asks a side question in a fork beside the chat (#39268)
* feat(chat): /btw asks a side question in a fork beside the chat

In a Chat UI chat that can fork, /btw <question> (or /side) forks the chat
through its newest finished response, sends the question there, and moves the
fork beside the chat the way dragging it does. The source chat is untouched;
the draft clears only once the question went out. Agents that cannot fork keep
their own /btw.

* fix(chat): type-guard the side chat command names

* fix(chat): side chats own the screen from Send and never place an unsent question

- Placement starts at Send, retires for good on any other selection in the
  workspace or on leaving it, and looks only at the requesting workspace.
- A question that never went out leaves its fork in the background; an
  unconfirmed one says to check the side chat before asking again; a failure
  the new chat already reported is not repeated.
- The command menu shows "Available after the first reply" / "when this reply
  finishes" while it is open, using the drawn turn order.
- File pills count as attachments; picking /btw completes the row.

* fix(chat): /btw reads the newest response the drawn transcript offers Fork on

The menu reason and Send now follow the transcript's own Fork rule as drawn,
reported when it changes, instead of rebuilding turn membership in the composer.

* fix(chat): side chat failures always reach the source; watch window starts when the fork opens

- A failed side question toasts in the source even when the fork recorded it,
  since the fork stays in the background.
- The 60 s placement window starts once the fork exists, not at Send.
- The fork-point scan stops at a /clear and, for tip-only agents, at the
  newest turn; split placement looks only in the requesting workspace.

* fix(chat): /btw forgets a fork point the transcript no longer offers

- Send and the menu reason refuse a reported response that is no longer
  forkable, and an unmounted transcript reports nothing to fork.
- The fork-point scan skips subagent sections before its early stops.

* perf(chat): /btw steps over a running turn instead of walking its rows

The slot builder groups root responses by turn in its existing pass; the side
chat's fork point reads those groups newest first and skips a running turn
whole, so streamed replies add no per-row work.

* fix(chat): /btw looks past responses outside any turn and skips the scan when nothing is forkable

* perf(chat): find the /btw fork point while laying out the transcript

Per the review ruling: the slot builder keeps the newest row that offers Fork
in its existing pass, only when /btw listens, and returns one point; the
response groups and their second search are gone.

* test(chat): /btw fork point contract through the transcript and Send hooks

* refactor(chat): response rows and /btw share one Fork rule

* test(chat): /btw fork point ignores pending-only renders and an emptied conversation

* test(chat): /btw contract counts every eligibility lookup and covers an undrawn transcript

* fix(chat): /btw shows ahead of agent commands, sends on one Enter, and focuses the side chat

- Side-chat rows lead the slash menu, so a long agent catalog no longer
  pushes them past the menu's row limit.
- Enter on a fully typed /btw sends it instead of only completing the row.
- Placing the side chat also moves keyboard focus to its composer.

* fix(chat): picking /btw completes the row again, as the common pattern does

Sending a fully typed /btw from the menu bypassed a same-named skill's
release and sent on a mouse click; a pick now always leaves '/btw ' to
add a question to.

* fix(chat): on layout-owner builds the moved side chat keeps its composer focus

Main selects a tab it moved once its frame shows it there, so placement no
longer selects it first in the source pane; moveTabToNewPaneColumn reports
whether main or this window moved it, as moveTabToGroup does.

* fix(chat): side chat placement owns main-drawn moves through to the drawn result

Per the review ruling: the placement claim stays alive while main draws the
move, reads the side chat's own new pane and selection as its own, and selects
and focuses the side chat once the frame shows it moved, in place when main
refuses, and never after the user selected elsewhere. The owner command takes
an optional completion in place of its own moved-tab selection.

* fix(chat): selecting the side chat in the pane it is leaving still retires the claim

Only what main's move changes elsewhere (a new pane holding only the side
chat, another pane showing it) reads as the request's own; the selection
counter in the placement contract reads every pane's selection, and the move
helpers' completion is exercised through main's frame transport.

* fix(chat): a side chat main never moves is selected where Fork put it

When main neither draws nor answers the move before the watch ends, the
side chat is selected in place rather than left hidden; the owner command's
completion path (no moved-tab intent, hand-back asks first) is tested.

* fix(chat): a side chat this window moves keeps its focus request

The move's own changes count as the request's from before the move starts,
so a synchronous move no longer retires the claim before the side chat is
selected and focused.

* fix(chat): picking an unavailable /btw row does nothing, as the common pattern does

* refactor(native-chat): keep /btw hooks compilable by React Compiler

* fix(chat): say side chats aren't ready while a fork from the chat is opening

* test(chat): assert the opening-fork refusal without its copy

* fix(native-chat): share one latest-turn scan between /btw and transcript rows
2026-11-07 22:14:45 -08:00
OrcaWinandOrcaWin 9b98b38506 test: remove 137 low-value tests (#39522)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 07:20:11 -08:00
OrcaWinandOrcaWin 1e3eb5701c test: remove 186 low-value main, scripts and shared tests (#39404)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-07 00:54:22 -08:00
Brennan Benson c6f07596ad Phone chat: empty Cmd/Ctrl+Enter steers the first queued message, and holding Cmd/Ctrl shows what it will do (#39215)
* fix(mobile): Cmd/Ctrl+Enter on an empty chat composer steers the first queued message

Matches desktop (#38732) in the paired web page: with nothing typed, the
chord steers the head waiting card through that card's own Steer, only
where its other way is steer.

* fix(mobile): empty Cmd/Ctrl+Enter sends the first queued card after a Stop, as desktop does

Desktop's rule (#38877) also sends the head card when no turn runs, and
goal mode keeps the empty chord inert. The queue list's handle now runs the
head card's own Send when idle, and steers mid-turn only where the chord's
other way is steer.

* test(mobile): type the queued-card handle refusal cases

* feat(mobile): holding Cmd/Ctrl in the phone chat composer shows what Cmd/Ctrl+Enter will do, as desktop does

Desktop's held-modifier preview moves into src/shared so the phone web
composer runs the same rule: Send becomes Queue, Steer or Steer queued
and the head queued card lights while the chord's modifier is held
alone on a hardware keyboard. The queue's empty-chord rule is one
function the preview and the press both read.

* fix(mobile): build the held-chord preview with the phone's own React, and offer only presses that act

The shared hook now takes its React hooks from the caller, as the shared
attachment preview does: the phone bundle resolves a different React copy
than the repo root, so importing react from src/shared broke every phone
web composer (Invalid hook call).

The preview also matches what a press does: one pill press per hold (a
double-click can't send a card after the draft went), a picked /plan-style
skill counts as a message, a head card whose own action is on its way shows
no Steer queued, and the lit state lives in the tray so a chat switch keeps it.

* fix(mobile): held-chord pill takes one click like desktop, keeps busy state per chat, lights only the head row

- The pill ignores a click whose detail is above 1, as desktop does, so a
  deliberate later click in the same hold still acts.
- In-flight card ids are kept per chat with functional updates, so a chat
  settling after a switch can't clear the current chat's record.
- The lit state is a small store only the head row subscribes to, so a hold
  re-renders one row, not the whole queue.
- The desktop preview test moves back beside the desktop wrapper it drives.

* refactor(mobile): one owner for queued-card actions, read by both the list and the held-chord cue

The queue list owned its in-flight guard per mount and the tray mirrored it
for the composer's Steer queued cue; each mirror leaked (cross-chat and
same-chat remount overwrites, an all-chats copy per change). As desktop's
queued-messages controller does, the tray now owns one action store: pending
keys per chat, admitted synchronously, released per action, published by
copying only the changed chat. The list takes those actions as a prop (it
keeps its own only when mounted alone), and the empty chord presses the head
through the same run, so the cue and the press can't disagree. The list's
imperative handle goes away.

Also replaces a type assertion on the pill's click detail with an in guard.

* test(native-chat): desktop chord-preview wrapper re-exports the hold delay its test reads
2026-11-06 18:17:24 -08:00
Brennan Benson 969c5ddd3a Support native Plan mode in chat (#38286)
* Add session Build and Plan choices to native chat

* Refresh planning choices across connected composers

* Give composer catalog tests a complete transport fixture

* Preserve planning choices through fresh turns and older hosts

* Type planning delivery fixture choices explicitly

* Honor mode capability for retained queued command picks

* Update existing native mode contract expectations

* Keep proposed plans visible in completed chat turns

* Group chat mode with permissions and goal controls

* Keep chat composer controls accessible in narrow panes

* Preserve composer overflow ownership and editor focus

* Complete composer localization catalog and subscription checks

* Keep chat composer controls contained in narrow panes

* Use the button spacing for compact Save

* Place chat mode immediately before Goal

* Restore Plan status test dependencies after main sync

* Show an exit pill only while chat Plan mode is active

* Remove obsolete composer tooltip translations

* Remove unused Build toggle catalog entries

* Apply Plan commands immediately from composer picks

* Preserve picked skill origin in composer admission

* Supply phone platform to composer regression fixture

* Preserve mode picks until their writer admits them

* Narrow the phone mode command before its draft transform

* Document the option fixture mutation shape

* Match phone Plan controls to the composer mode pills

* Assert optimistic mode feedback in the phone fixture

* Retain the phone mode pick recovery regression proof

* Use the relocated observation imports after the main merge

* Restore the composer IME module import after merging

* Read the queue assertion helper from its relocated owner

* Point the mode fixture at the relocated selection controller

* Register the phone Plan pill localization keys
2026-11-06 12:42:48 -08:00
Brennan Benson 7033f778e8 Keep native chat responsive after reading older messages (#38920)
* Bound native chat history after returning to latest

* Keep reader return evidence aligned with measured content

* Correct transcript regression fixtures and type annotations

* Preserve reader gestures through smaller row measurements

* Keep transcript regression tests focused on behavior

* Pin transcript passthrough and send admission expectations

* Preserve source correspondence in transcript projection reuse

* Keep reader intent separate from observed scroll geometry

* Preserve pending reader movement through no-op pins
2026-11-06 10:20:16 -08:00
Brennan Benson 4cccf7b04a perf(native-chat): reuse unchanged phone transcript rows (#38956)
* perf(native-chat): reuse unchanged phone transcript rows

* fix(native-chat): narrow retained projection output reuse

* refactor(native-chat): isolate phone session status type

* Document source comparison key safety

* Use last-member array accessor

* test(native-chat): check phone captures across source boundaries

* ci(mobile): route recorded transcript decoder inputs
2026-11-06 10:14:07 -08:00
Kelvin Amoaba 7860261d18 feat(mobile): paste images and long text into the chat composer (#38591)
* feat(mobile): paste images and long text into the chat composer

* test(mobile): pin which composer pastes attach

* fix(mobile): keep a long paste as text when no upload can start

* fix(mobile): re-encode pasted images agents can't read as PNG

* test(mobile): pin composer paste routing at the composer field

* refactor(mobile): fold composer paste routing into its hook

* fix(mobile): read pasted images in the uploader so the composer needs no shell bridge

* test(mobile): stub the context ring in the composer paste test
2026-11-05 20:59:54 +00:00
Kelvin Amoaba a3f08b4075 feat(mobile): pin the agent's plan above the chat composer (#38359)
* feat(mobile): dock the chat's plan above the composer

Desktop docks the latest plan above the composer; the phone only drew it
inline in the transcript. Move desktop's docked-plan rule to src/shared and
draw it on the phone as a collapsible strip in the background-tasks box.

* perf(native-chat): keep the docked plan's identity until the plan changes

* refactor(native-chat): read the docked plan from the newest message back

* refactor(mobile): drop a cast in the docked plan's open memory

* test(mobile): pass the tray's new taskList in the recovery test
2026-11-05 20:31:10 +00:00
Kelvin Amoaba de7fa2addb feat(mobile): show background task rows in the chat transcript (#38264)
* feat(mobile): show background task rows in the chat transcript

* fix(mobile): truncate the task output path like desktop

* fix(mobile): scale and select task rows like the rest of the transcript

* fix(mobile): translate the task output line

* refactor(mobile): read task rows from the shared row content

* test(mobile): restore the text reader for task row tests
2026-11-05 20:16:34 +00:00
Brennan Benson 61c069aac0 Keep a Claude chat's effort changeable after its first reply (#38272)
* fix(native-chat): keep a Claude chat's effort changeable after its first turn

After its first turn a Claude chat saves the model id Claude reports it ran
(claude-opus-5-5), while the model list names that model only by its alias
(opus). Every capability lookup matched on the row id, so the chat's model
had no effort choices and effort turned into display-only text on desktop
and phone.

A listed row now describes a model id by its own id or by the model it
resolves to. The match supplies capabilities only; the chat keeps showing and
sending the exact model it ran, so it never drifts when the alias moves. The
host applies the same rule to the row it adds for the chat's model, for
clients that read the answer's models.

* test(native-chat): cover exact-row precedence for a described model id

* fix(native-chat): remember an after-reply effort without changing the new-chat model

An effort pick in a chat on the resolved id it ran is remembered under the
listed row that runs that model and leaves the new-chat model untouched, as
the common pattern keeps the sticky model and updates only its options. The
resolved id is never stored as a default.

* refactor(native-chat): move the remembered-pick model choice into its own module

* fix(native-chat): keep a held effort pick from adopting a new-chat model

* test(native-chat): run the held-effort case as a Claude launch

* revert(native-chat): drop the host-side capability copy no live answer can use

Claude's live session listing carries no resolvedModel, so the host never matched there, and phones draw the host-served chat bundle, so every client already runs the shared lookup.

* Key Claude's model rows by the model each one runs

Claude's listing named rows by alias (opus), while a chat saves the model
it ran (claude-opus-5-5) after its first turn, so equivalent chats held two
kinds of model value and a chat's effort could go read-only. Rows are now
keyed by the versioned model they run, the common pattern: a pick saves the
same id the CLI reports. Aliases stay as their own rows with their own
effort levels; the picker lists one only while the chat is on it or a
search matches it, and the phone list leaves them out. A saved alias is
kept as the user picked it. A configured alias default marks the versioned
row it runs, and an effort picked in an existing or resumed chat no longer
changes the model new chats start on, whatever ids the chat and listing use.

* test: give the delayed-report alias test's timeout its reason

* Remember a new chat's picks by its first turn, and keep aliases reachable everywhere

- A chat counts as existing once it has a turn or a send, or when it was
  opened rather than launched here, not once its launch published: an empty
  new chat's effort pick adopts its model for new chats again, and every
  agent's existing chat keeps the remembered new-chat model.
- Only a row that names itself as the model it runs covers an alias, so an
  older host's alias rows stay listed beside a chat's stand-in row.
- The phone lists an alias of a listed model behind a More models toggle.
- The terminal-chat and commit-message model lists carry each row's
  resolvedModel, so they list aliases the same way; an older remote that
  omits it keeps its full list.

* fix(mobile): keep the More models toggle's state without an effect reset

* Keep commit-message aliases selectable and their resolved model out of saved settings

The Source Control model Select has no search, so it lists alias rows after
the versioned ones instead of hiding them. Discovered models are saved
without an alias row's resolvedModel, and the refresh compares that same
saved shape, so the settings cache gains no field.

* Drop an unrelated audit-tools lockfile change; reset the phone's More models toggle when its drawer closes

* test: build the saved-models test's settings without a cast
2026-11-05 00:43:23 -08:00
Brennan Benson 974bb4a7ca Preserve chat inputs through uncertain delivery and Stop (#32267)
* Give unconfirmed chat messages explicit recovery actions

* Resolve receipt settlement code quality findings

* Complete recovery copy localization and callback types

* Align send lifecycle contracts with explicit recovery actions

* Include the unconfirmed opener in the restart fixture type

* fix(chat): preserve recovery ownership across lifecycle boundaries

* Preserve send ownership across context replacement and recovery

* Separate history ingestion from live send settlement

* Preserve original send truth and reconcile acquired history

* Use summary-shaped history responses in acquisition coverage

* Preserve queued image recovery for released readers

* Prove independent late receipt recovery across reopen

* Preserve queued image sources in bounded catch-up projection

* Keep queued input and explicit chat retries in their original domains

* Preserve reader lifetime across main session interfaces

* Fix static checks after main integration

* Migrate retained recovery Stop contracts to current lifecycle

* test: use typed access for journal population counters

* fix: consolidate history page bounds type imports

* test: exercise legacy snapshot reuse through selected handoff

* Fix attachment draft typing and document test boundary casts

* Repair current journal integration types and contract fixtures

* Keep uncertain send recovery in queue reorder reopen contract

* Repair mobile contract boundaries and exact queue lookup

* Align input finalization contracts with current Stop ordering

* Keep recovery copies independent of queued message barriers

* Reconcile Stop and replay contracts with current lifecycle

* Update recovery tests for current module and draft APIs

* Align Stop recovery contracts with independent queue policy

* Expose independent recoveries to current queue controls

* Cover sending-only queue Resume visibility

* Adapt recovery contracts to shared queue projection

* Use current history and failure-word contracts in recovery tests

* test: retain released reader source contracts through queue settlement

* Keep uncertain sends in ordinary history and preserve saved queue choices

* test: prove mobile draft leaf subscription isolation

* Use typed operation instrumentation in mobile recovery test

* Align lifecycle test boundary typing with static rules

* Repair test module typing and retained runtime copy catalog

* Remove unused chat delivery notice translations

* test(chat): retain legacy handback without uncertainty notice

* fix(chat): omit saved uncertainty card captions

* test: bind released readers to exact queue wire and proof

* Replace archived reader evaluator with exact recorded contracts

* Mark queued edit test hook import as type-only

* Isolate queued card tests from native inline composer imports

* Complete structured mobile resolution in queued edit test

* Align mobile attachment cleanup lifetime test with send outcomes

* fix: restore journal prototype delegation methods

* Keep uncertain sends as ordinary messages in memory

* Release notes admission after uncertain opening completes

* fix: end opening selection operations at uncertain completion

* fix: derive selection admission from live requests and repair integration tests

* test: consolidate send imports and use a supported locale

* Fix CI test types and synchronize retired delivery catalogs

* Type exported test fixture mocks through the public Vitest API

* test: align selection and journal verification contracts

* Reconcile acquired history before journal projection

* Preserve saved invocation facts during history catch-up

* Repair journal recovery consumers and CI contracts

* Keep failed legacy import displays serializable and bounded

* Preserve journal owner boundaries in CI import cleanup

* Fix typed test fixtures for session recovery contracts

* fix: align history and recovery contract types

* test: verify logical rewind across released chats

* Bound retained queue and status reads

* Bound Stop and delivery reads to relevant journal inputs

* Bound subscriber catch-up and stopped-history reads

* test: align journal read fixtures and operation counts

* Bound automatic chat reads to current input evidence

* fix: align journal reader contracts and test fixtures

* test: type historical dispatch rejection fixtures

* fix: restore merged session projection and fixture types

* fix: preserve resumed queues across logical fork rewind

* Preserve queue pause chronology across logical rewinds

Keep original Stop and Resume coordinates while retaining matching warm failure evidence in the journal owner. Keep historical fixture authoring separate from current production writes.

* End historical fixture authoring before current queue actions

* Keep answer operations separate from retained messages

* Fix resting chat attention context

* Fix attention regression fixture provenance

* Validate retained RPC test frame reads

* Fix retained attention and RPC contract fixtures

* Keep send observations on canonical delivery evidence
2026-11-04 02:40:10 -08:00
OrcaWinandOrcaWin 25994e0b94 test: remove 1460 low-value test declarations (#38082)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-04 00:25:44 -08:00
Brennan Benson 163c5de81e Add Ultracode to Claude chat effort (#38010)
* Add Ultracode to Claude chat effort

* Correct Ultracode test type annotations

* Keep Claude workflow effort observations consistent

* Make effort picker test follow async option contract

* Keep effort coverage at its owning behavior layer

* Exercise workflow readback with recorded native settings

* Preserve configured workflow during effort reapplication
2026-11-03 21:57:07 -08:00
Neil 926f8bad13 refactor: organize terminal and runtime contract owners (#38011) 2026-11-03 19:56:34 -08:00
Neil da96fadec3 refactor: organize source-control contract owners (#37990) 2026-11-03 19:12:25 -08:00
OrcaWinandOrcaWin a905a311c5 test: remove 72 low-value test declarations (#38002)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-03 17:38:41 -08:00
Neil 2c03c4b989 refactor: organize agent status and lifecycle owners (#37961) 2026-11-03 16:36:54 -08:00
Brennan Benson b9a22101da Keep question answers visible until delivery completes (#37883)
* Keep async question answers stable until delivery

* Cover pending answers with recorded question input

* Cancel delayed answers when question controls disable

* Scope pending question answers to their form and journal order

* Verify revised questions and handover ordering through production sources

* Use typed phone answer fixtures

* Reuse answer delivery evidence and skip unquoted queue matching

* Supply derived journal scope in the translator regression

* Use named type imports for mobile question contracts

* Exercise canonical pending rows and buffered phone read coverage

* Align phone controller assertions with optional send intent

* Supply transcript metadata for phone question test fixtures

* Fix question prompt test literal typing
2026-11-03 15:16:53 -08:00
Kelvin AmoabaandVyacheslav Scherbinin ac6fa4ef46 fix(claude): reflect fallback without changing saved models (#37958)
* fix(claude): reflect model fallback in chat and composer

* test(claude): reproduce fallback display before and after

* fix(i18n): ship the model fallback notice in the runtime catalog

* fix(mobile): ship the model fallback notice in the runtime catalog

* fix(claude): accept unnamed init models in response observations

* fix(claude): keep fallback observations display-only

Response model metadata must not satisfy delayed input evidence or
change saved launch preferences.

* test(claude): type fallback regression fixtures

* test(claude): expect init model display reports

---------

Co-authored-by: Vyacheslav Scherbinin <gentslava@mail.ru>
2026-11-03 23:15:51 +00:00
Neil d5f2a17cd2 refactor: group agent launch contracts under concrete owners (#37915) 2026-11-03 14:45:49 -08:00
OrcaWin 39d02ae0bc test: remove 49 low-value test declarations (#37856) 2026-11-03 09:25:28 -08:00
OrcaWin e7542a3ca1 test: remove 52 low-value test declarations (#37854) 2026-11-03 09:07:13 -08:00
OrcaWin e95b0ca056 test: remove 58 low-value test declarations (#37853) 2026-11-03 08:53:10 -08:00
Neil 51cb2f189c refactor: organize native chat input and transcript owners (#37334) 2026-11-02 03:14:58 -08:00
Kelvin Amoaba 8458e704c4 fix(native-chat): show a terminal's unsent input in the chat composer and replace it on send (#36493)
* fix(native-chat): show a terminal's unsent input in the chat composer and replace it on send

Switching a pane to chat view now seeds the composer with the text left unsent in Claude Code's or Codex's input box, and a chat send clears every line of it instead of one Ctrl+U. The clear is confirmed with the same typed-only read and kept under the 64-byte chunk Claude Code reads as a paste.

* test(native-chat): drop the removed screen-text clear check from the background-rows test

* fix(native-chat): clear a seeded multi-line draft before typing a Codex command from chat

* test(native-chat): expect the typed command's clear argument in composer tests

* fix(native-chat): confirm a seeded draft is cleared before typing a Codex command

* fix(native-chat): find Claude's closing frame past dim suggestion rows

A typed-only read stopped at the suggestion row, so a draft under Claude's hidden caret never reached chat.
2026-11-02 10:22:23 +00:00
Brennan BensonandClaude Opus 5.5 5bbbdebe6b Open the goal composer from /goal in Claude and Grok chats (#37212)
* Make goal command entry consistent across supported chat agents

* Keep the composer goal mode binding local

* Open the goal chip only for the provider's built-in /goal

Carry the provider's built-in marker on slash-command rows (Claude's
initialize descriptors report it) through to the picker, and enter goal
mode from a picked /goal only when the session has host goals or the row
is the provider's own built-in. A user command or skill named goal keeps
its normal invocation, and bare /goal without host goals is sent as
typed again. Host goal objectives resolve pasted text before the /goal
prefix is stripped, as before.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Mark Grok's built-in slash commands from its initialize response

Grok lists its own built-ins in the initialize response of each process.
Carry that onto the session command rows as the existing built-in marker,
so picking Grok's /goal opens the goal chip like Claude's. A row that
Grok tags as a skill or workflow never takes the marker, since a session
can close the built-in and let a same-named skill take its name.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Feed the Grok built-in command test a recorded initialize response

Replace the hand-trimmed initialize reply with Grok 1.0.70's recorded
initialize result, keeping its seven built-in command rows and removing
host-identifying metadata.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

* Type the composer send result as boolean in the IME composition test

The structured composer send now resolves to whether it was admitted.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-11-01 18:59:52 -08:00
OrcaWinandOrcaWin a29461bc15 test: remove 88 low-value test declarations (#37280)
Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-01 18:47:57 -08:00
Neil 89f9ce08de refactor(shared): organize session contracts and projections (#36979)
* refactor(shared): organize session contracts and projections

* chore: tighten dropped-path flaky pattern allowance

* docs: preserve current agent instructions with valid formatting
2026-11-01 03:14:46 -08:00
OrcaWinandOrcaWin 321574af87 fix(native-chat): steer async question answers instead of queuing duplicates (#36917)
* fix(native-chat): stop async question Submit from queuing duplicate answers

When the agent is mid-turn, answering a Codex async question queues the
answer as an ordinary message. The card stayed up until a transcript row
retired it, which a queued message never posts until the turn ends, so
every Submit queued another copy. Hide the occurrence once its answer is
queued, on desktop and phone.

* fix(native-chat): steer async question answers into the running turn

An answer to the agent's own mid-turn question belongs to that turn.
Queuing it behind the follow-up setting held it until the turn ended,
after the agent had already proceeded without it. Send it with the
steer intent whenever the follow-up resolver would queue a plain send,
on desktop and phone. Stop and a waiting command still queue, and the
queued fallback still hides the card.

* fix(native-chat): hold async questions while a queued answer waits

Replace the mount-scoped hide on a queued answer with one derived from
the queue: a question stays hidden while a queued card quotes it, across
remounts, and returns if that card is deleted or edited away. Lock
Submit until the send settles, and keep a returned answer out of the
composer draft.

* fix(native-chat): keep structured session under the line cap

---------

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-11-01 01:43:26 -08:00
Neil 7d76028a5c refactor: group agent session journal and request modules (#36882) 2026-10-31 22:33:23 -07:00
Neil 5913a1c663 refactor: group shared agent-session options and catalogs (#36878) 2026-10-31 20:45:48 -07:00
Neil b2842603e4 refactor: finish shared native-chat model and transcript organization (#36843) 2026-10-31 20:19:28 -07:00
Brennan Benson 12edee3ac6 Choose default models and effort for agents (#36210)
* Add host-owned model and effort defaults to agent settings

* Unify terminal defaults and raw argument precedence

* Keep agent model defaults typed through creation

* Preserve quick-create prompt through preparation

* fix: complete execution-host preference boundary and CI contracts

* Preserve raw options until a replacement is emitted

* Complete launch choice ownership and consumer contracts

* Align launch contracts with compiler boundaries and consolidate proof

* Name exported fixture mocks and verify ordered chip removal

* Preserve typed choices across compound legacy publication edits

* Preserve non-emitted composed launch choices through legacy edits

* Preserve rollback omissions and settle agent launches before success

* Carry terminal draft ownership through launch completion

* Keep inline draft delivery independent of terminal projection

* test: consolidate launch ownership contracts

* test: check web launch fixture array types

* test: align launch fixtures and conformity records

* test: import the shell-ready marker from its declaring module

* test: give caller routing the web host tab's completion contract
2026-10-30 15:17:52 -07:00
Brennan Benson bd82832a53 fix(native-chat): keep model picker choices stable during discovery (#36113)
* fix(native-chat): keep model picker choices stable during discovery

* Preserve unknown model inventory across session option reads

* Preserve explicit picker choices and discard refused opens

* Exercise recorded empty ACP inventory through host and picker

* test(chat): align mobile picker contracts with descriptive inventory

* perf(chat): skip effort fallback scans when already resolved

* test(native-chat): align synthetic model consumer expectations

* test: preserve accepted launch seed payload contracts
2026-10-30 12:35:02 -07:00
Brennan Benson 3881fbcda9 Keep pending questions through agent notices and undelivered replies (#36306)
* Keep pending blocking questions through non-answer rows

* Use a canonical delivered human row in blocking question tests

* Remove redundant live-status question test
2026-10-30 10:46:10 -07:00
Brennan Benson ca84c49b35 Keep cancelled async questions hidden and show new ones (#35870)
* fix(chat): show each repeated async question

* fix(chat): keep async question identity stable across readbacks

* test(chat): preserve async question fixture types

* Keep async question cancellation scoped to individual occurrences

* Use checked types in async question test fixtures

* Share sender-aware async question retirement across chat views
2026-10-30 00:36:11 -07:00
Brennan Benson f26fb1cfda Keep async question controls available after agent notices (#35758)
* fix(chat): keep async questions open across agent notices

* test(chat): cover answering async questions after agent notices
2026-10-29 22:33:23 -07:00
Neil 6c86dec334 fix(plugins): harden security dialogs, syntax literals and display names against data plugins (#36220)
- Pin dialog and floating surfaces inside .plugin-security-chrome so a theme's --popover can't wash out trust text
- Limit auto-closing pairs and comment markers to 1-8 printable single-line characters (validate:plugin refuses; hosts drop the entry)
- Strip control, bidi and zero-width characters from plugin names, titles and listing text (validate:plugin refuses; hosts and the plugin list strip)
2026-10-29 21:23:52 -07:00
Brennan Benson 2926b6e713 fix(native-chat): preserve models missing from provider listings (#35266)
* fix: separate chat option input from inventory observations

* fix: preserve scoped chat choices and publication ownership

* fix: complete scoped catalog and applied control ownership

* test: make catalog fixture dependency boundaries explicit

* test: request catalog discovery explicitly in demand contracts

* fix(chat): preserve option observations and operation boundaries

* fix(chat): finish pending option and catalog lifetimes

* fix(chat): project saved permissions without launch preparation

* fix(chat): correct option rejection and catalog retirement

* Preserve Claude effort validation advice through chat rejection

* test: align refresh mocks and preserve fixture type evidence

* fix: share catalog claims only across equivalent owners

* test: use typed catalog corpus instrumentation

* fix: consolidate structured launch imports

* Validate SDK queue regression envelopes without assertions

* fix: complete catalog runtime and fixture type contracts

* Align native option fixtures with explicit discovery and applied facts

* Keep initial compatibility catalog reads on held memory

* Complete the installed catalog fixture envelope

* Observe learned defaults after asynchronous projection settles

* Consolidate host fixture journal type imports

* test(native-chat): align goal and seed fixtures with applied inputs

* fix(codex): retain applied proof when goal settings skip a write

* test: load rejection wording before timed queue regression

* Fix catalog fixtures and queued option snapshot typing

* Align permission publication fixture with passive option reads

* Separate startup config from held turn permission fixture

* Align input lifecycle fixtures with sparse applied choices

* Simplify scoped catalog refresh ownership and coalesce cache snapshots

* Load catalog persistence real-module fixture during collection

* Compose catalog availability fixtures from valid session records

* Align catalog and startup fixtures with current option contracts

* Fix permission read types and separate catalog fixture preparation

* Align option and restart fixtures with current lifecycle owners

* test(mobile): retain reported model alongside discovery

* test(mobile): recalibrate the measured route script envelope

* fix(native-chat): preserve models missing from provider listings

* Preserve failure causes and correlate model rejection notices

* Cover catalog omissions and explicit model defaults in client hooks

* Keep ACP model refusals on the generic rejection path

* Include model failure copy in the runtime English catalog

* Align model retention tests and bound result correlation work

* Use checked array access in result correlation contract
2026-10-29 00:44:31 -07:00
Neil b9f3b2009f refactor: group native-chat reported skill handling (#35630) 2026-10-28 20:53:10 -07:00
Brennan Benson 78ad9f4255 fix: keep chat option actions independent of inventory (#31927)
* fix: separate chat option input from inventory observations

* fix: preserve scoped chat choices and publication ownership

* fix: complete scoped catalog and applied control ownership

* test: make catalog fixture dependency boundaries explicit

* test: request catalog discovery explicitly in demand contracts

* fix(chat): preserve option observations and operation boundaries

* fix(chat): finish pending option and catalog lifetimes

* fix(chat): project saved permissions without launch preparation

* fix(chat): correct option rejection and catalog retirement

* Preserve Claude effort validation advice through chat rejection

* test: align refresh mocks and preserve fixture type evidence

* fix: share catalog claims only across equivalent owners

* test: use typed catalog corpus instrumentation

* fix: consolidate structured launch imports

* Validate SDK queue regression envelopes without assertions

* fix: complete catalog runtime and fixture type contracts

* Align native option fixtures with explicit discovery and applied facts

* Keep initial compatibility catalog reads on held memory

* Complete the installed catalog fixture envelope

* Observe learned defaults after asynchronous projection settles

* Consolidate host fixture journal type imports

* test(native-chat): align goal and seed fixtures with applied inputs

* fix(codex): retain applied proof when goal settings skip a write

* test: load rejection wording before timed queue regression

* Fix catalog fixtures and queued option snapshot typing

* Align permission publication fixture with passive option reads

* Separate startup config from held turn permission fixture

* Align input lifecycle fixtures with sparse applied choices

* Simplify scoped catalog refresh ownership and coalesce cache snapshots

* Load catalog persistence real-module fixture during collection

* Compose catalog availability fixtures from valid session records

* Align catalog and startup fixtures with current option contracts

* Fix permission read types and separate catalog fixture preparation

* Align option and restart fixtures with current lifecycle owners

* test(mobile): retain reported model alongside discovery

* test(mobile): recalibrate the measured route script envelope

* test: let the preflight shell-capture mock run its detection callback
2026-10-28 16:08:01 -07:00
Brennan Benson fa5284aca2 feat: edit queued messages inline with the full chat composer (#31180)
* fix(native-chat): a refused queued message still blocks the queue when its card write fails

Every reader of a queued card goes through one derived view of the journal's dispatch facts,
so a card whose message was refused reads as returned even when its card-table update and heal
both failed. One decision and one writer store the derived state for every action.

* refactor(native-chat): keep each queued message in the chat's journal, not a second table

A queued message lived in its own SQL table, and a hook that may be skipped copied
each refusal from the journal into it. When that write failed, a refused card
vanished: the cards behind it sent, and its Send and Delete did nothing.

Each queued message is now a `queue` row in the chat's journal beside the
submission that hands it off and the dispatch row that answers it. The reducer
folds the card from those rows, so a refusal returns the card and holds the
cards behind it with nothing written, and replay reads the same. Every action
writes its own rows in one transaction. Cards an earlier build stored are read
through the same classification until they move: each action moves its own
card, and a bulk import runs once per open. A new epoch restates every card
still owed an answer in the transaction that deletes the old rows.

The settlement hook and its savepoint, the open-time heal, the drain's heal and
the derived-card view are gone. The published card list is unchanged.

* test(native-chat): adapt the queue tests to cards kept in the journal

Cards are written through the journal, so tests queue them with their body
alone and hand them off under their real fingerprint. Tests of the removed
settlement hook, heal and SQL store are deleted; the text-update spec now
covers the edit decision alone, and a test of an earlier build's stored holds
seeds the legacy table and reads the imported cards. Rolling over an epoch now
keeps a card whose hand-off was never handed over, so that test checks the
retried id never sends rather than that nothing sends.

* test(native-chat): a refused card holds the queue through rewind, a new epoch and a restart

One whole-flow test through the host: the refusal writes no card row, a rewind
that retires the refused hand-off and a rolled-over epoch keep the card
returned, a restart and Resume send nothing behind it, its own Send refused
again still holds the queue, and its Delete releases the next card in order.

* test(native-chat): an earlier build's queued cards move into the journal once, each read the same

One mixed-import test through the host. The first open's import fails and
moves nothing, yet every card reads as it will; Delete and Send each move only
their own card. The next open moves the rest in one transaction, writing a
refusal only where its hand-off is gone, nothing for answered cards, and leaving
an unreadable row on disk. A later command turn spends a moved command card, a
third open writes nothing, an old Delete replays from its receipt, and a chat
with only answered legacy rows clears them in a delete-only transaction.

* test(native-chat): adapt typechecked tests to cards kept in the journal

The row-kind table lists a queue row, the clear and legacy-import tests
match the current signatures, and the downgrade test keeps only the
leftover-send case: a queued card is now a newer-version journal row an
older build keeps read-only, and users don't downgrade.

* refactor(native-chat): drop the journal row writer's unused transaction hook

No caller passes one since the queue's savepoint bookkeeping left.

* test(native-chat): downgrade probes write rows at the version older builds read

The highest version this build reads is now 4, the queue row's. A newer
build's row in these probes is written at version 3 so the older build
meets its kind, not a newer version, and the Stop-event probe hands the
older build the rows as stored, since a read raises each row's version.

* test(native-chat): unit tests follow the queue row's version 4

The legacy-import test opens real SQLite, so it runs in the Node runtime
project. The newest version this build reads is now 4, and a read raises a
row's version to it, so the turn-lifecycle test no longer pins the
in-memory version (the written one stays pinned by journalRowSchemaVersion).

* fix(native-chat): one batch echoing two refused queued messages spends both

The per-row delivery check returned only the first waiting card an echo
proved delivered, so when one settlement carried echoes for two cards the
second stayed waiting and was sent again. It now returns every card the
row proves delivered, and the fold withdraws each; replay folds the same.

* fix(native-chat): a rewind moves an earlier build's cards into the journal first

While the open's import had failed, an earlier build's card that read as
refused through its hand-off lost that reading when an in-place rewind
retired the hand-off: it disappeared and the card behind it sent. The
rewind now adopts every legacy card ahead of its tombstones and deletes
their rows in its own transaction, as an epoch replacement already does,
so the fold latches each card's reading before its hand-off is gone.

* fix(native-chat): keep an earlier build's card whose hand-off is still unconfirmed

The import dropped a legacy card handed off as a send whose delivery was
unknown, though the fold keeps such a card linked and a later refusal
returns it. The import now keeps every card whose hand-off a later row can
still answer, through the same check the reducer folds dispatch rows by.

* fix(native-chat): one delivery echo withdraws at most one queued card

One provider echo proves one delivery, yet it withdrew every waiting card
with the same text whose hand-off was refused, so a second identical card
was lost. The fold now pairs each echo with one card: on its own row the
earliest-positioned match no other echo of that row took, and for a card
that waits again the earliest applied echo no card has taken. Paired echoes
live in the fold's state, so live and replay pair the same; readers of
cards not yet imported work on a copy.

* fix(native-chat): a queued message handed to the agent is sent again only on proof it never got it

Pressing Stop after Orca handed a queued or steered message to the agent,
before the agent confirmed it, put the card back in the queue, and Resume
or the next send sent it again. A check matching the agent's echo of the
text was the only guard against a double send, and it kept trading a
resend for a lost card. Whether the card waited again was decided by the
rejection's category, not by proof the agent never got the message.

A refused hand-off now waits again only where Orca proves the agent never
received it: the host still held it, or whoever settled it recorded that.
A failure still returns the card and holds the cards behind it. Anything
else may have reached the agent, so the card is spent and its message
reads as sent, derived on every fold from the stored rejection: with the
turn it was answered into, as that turn's unconfirmed message where it was
handed over; withdrawn before any turn opened, as a person's own send a
Stop took back. The reopen mark ignores a recovered doubt, and the restart
reconciler no longer judges a queued hand-off unsent from what history
lacks. The echo text matching and its pairing are deleted.

A close or quit while the agent starts settles sends with the unrun hold.
The host hands nothing to a child before its start answers
(structured-agent-session-delivery-loop.ts: a handover needs phase
ready), so such a send went to an earlier child and may have run: it now
reads as sent instead of waiting again.

* fix(native-chat): Claude's report that it removed a queued message unrun lets the card wait again

Claude says when it removed a send without running it: the interrupt
receipt's cancelled list, or a command_lifecycle cancelled, discarded or
refused frame for a command that never started. Every one settles through
rejectClaudeDispatchWaiters, which now marks the settlement unrun. For a
queued card's hand-off the host records that as proof the agent never got
it, so the card waits again under the queue's pause. A direct send keeps
the plain refusal: there the proof would owe it as stopped history.

* fix(native-chat): an earlier build's card stopped after hand-over follows the same rule on upgrade

Earlier builds put a card back to waiting after any refusal without a
verdict and cleared its link, so a card the agent may already have would
be sent again after the upgrade. The card's own hand-offs in the journal
decide now: unchanged and last sent as one that may have reached the
agent, it is spent on that hand-off and its message reads as sent; edited
or sent again since, it is held for its own Send under a host-only marker
that publishes as a plain hold; with no hand-off in doubt, including one
that never left Orca, it waits as before. The import writes a card spent
on a hand-off in doubt, so its message shows.

* fix(native-chat): read a queued row's hand-off before the lookup that uses it

The lookup's callback lost the narrowing of the row's change, which the
mobile test typecheck rejects.

* test(native-chat): a card steered into a turn a Stop ends stays sent in the Stop tests

Three tests pinned the old rule, that a card handed into a running turn
comes back to waiting when a Stop ends it. Under the new rule nothing
proves the agent never got it, so the card is spent: with the turn named,
its message reads as that turn's unconfirmed one; without, as a send the
Stop took back. Neither is ever sent again.

* fix(native-chat): a queued message stopped before Orca handed it to the agent waits again

A Stop that aborts a hand-off after its row is written but before the agent call now records
the withdrawal as never reaching the agent, for queued hand-offs only, so plan D's rule returns
the card to waiting under the Stop's pause instead of spending it. Direct sends keep the plain
withdrawal (the flag would owe them as stopped history). The agent's own refusal while aborted
is kept rather than overwritten, and an abort thrown during the call stays in doubt.

* fix(native-chat): a queued message stopped while the agent prepares it waits again

The abort signal reaches only an adapter's preparation (its options, the previous turn opening),
never its write, so the signal's own reason thrown back is the adapter saying nothing was
written. The handover now reads that, for queued hand-offs only, as never reaching the agent,
so the card waits again under the Stop's pause. Claude no longer wraps that abort as an option
refusal, which had returned a stopped card as a refused one blocking the queue. A real refusal
keeps its cause and its barrier; any other throw stays in doubt and is never resent.

* test(native-chat): the usage-limit Continue backlog case writes its card through the journal queue

Main's #30396 wrote its backlog card with the stored fingerprint and host-instance stamp the
journal queue derives instead; the card the Continue must yield to is the same waiting card.

* test(claude): the real-CLI queued Stop expects the unrun mark Claude's cancelled-unrun receipt carries

* feat(mobile): edit a queued message's images on the phone: remove or attach

* fix(mobile): gate queued image edits on the host reader verdict

* test(mobile): declare the upload fixture chat mode

* fix(native-chat): retain spent legacy messages when import fails

* fix(mobile): reveal the full queued image editor on open

* fix(mobile): invalidate queued editor geometry without a render ref write

* refactor(chat): prepare composer drafts and measured queue dragging

* feat(native-chat): add conditional queue removal and authoritative reordering

* feat(native-chat): move queued edits into the normal composer on desktop and phone

* fix(native-chat): own complete phone drafts before authoring

* fix: preserve submitted composer drafts across storage replacement

* fix composer validation and mobile CI diagnostics

* fix mobile composer test contracts and diagnostic output

* Capture mobile test compiler diagnostics in CI

* Fix queued message contract typing and English strings

* test: complete queued extraction transport fixtures

* refactor: separate composer skill binding from send mutations

* fix(mobile): grant draft storage within route limits

* fix(native-chat): settle each draft save on its own and publish complete composer drafts

Phone: a queued Edit copy no longer consumes the save that later typing
owns. Each ordinary save and the exact copy settle only their own result;
an explicit save waits for its own pending write, and a failed or retired
write never schedules another or revives the copy.

Desktop: a pasted-text leaf no longer shifts which selected file binds
where, and a hand-back held during an IME composition reaches the store
only merged with the visible editor document, including writes the editor
admits without an update and the composition settle.

* fix(native-chat): import the draft type once in the draft cache

* test(mobile): type the held-write state without an assertion

* test(native-chat): assert the handed-back file on Send without reading a typed transport as a mock

* test(mobile): pass main's agent-confirmed flag to the submitted-files harness

* fix: reveal queued reorder grip on touch screens

* fix: save reopened phone drafts and batch reorder measurements

* test: use an explicit React module type

* Preserve queued message sortable identities on unchanged renders

* Prevent stale queued drag completion after unmount

* fix(mobile): hand off navigation across session workspaces

* test(mobile): use resolved session identity in dictation fixture

* feat: edit queued messages inline with the chat composer

* fix: normalize queued edit skill ownership

* fix: retire phone skill selections with the sent draft

* fix: consolidate queued edit module imports

* fix: separate edit save action and stabilize image callbacks

* fix: complete phone inline composer integration

* fix: retain same-name queued skill selections

* fix: complete desktop queued composer integration

* test: use typed phone composer host lookups

* fix: include queued edit localization keys

* Preserve inline edit input across save and attachment completion

* Preserve complete queued edits across delayed saves

* Preserve queued edit input across delayed completion

* Complete queued edit lease loss and pending cancellation

* Use recognized queued edit test fixtures

* Consolidate queued edit imports and type host test spy

* Print mobile test compiler diagnostics on ratchet failure

* Correct queued edit integration fixture types

* fix: keep queued edit placeholder independent of readiness

* Fix queued edit compiler fixture boundaries

* Align upload completion test with ordinary insertion

* Combine mobile composer draft imports

* Load queued edit host fixture during test collection

* Size inline phone queue editor to available space

* Use typed scroll components in phone presentation contract

* Save typed text in a queued edit as written

The inline editor is the chat composer, so it keeps the composer's own identity model and no longer refuses Save for text that looks like a command. Command rows picked from the menu are still refused, Enter still means Save, and Edit never sends or runs anything.

Regression tests cover Undo after deleting an accepted command or skill pill, a scanned skill named like a command, two saved files behind one token, and typed command text saving literally. Also fixes two merge leftovers in tests: a missing import and a fixture that stored the whole menu row as a skill.

* Keep ordinary sends on the main composer contract

* Fix mobile composer imports and fixture loading

* Consolidate queued edit imports and duplicate regression

* Restore ordinary send catalog short circuit and repair test boundaries

* Preserve returned rich drafts through send acceptance

* Remove obsolete queued editor strings from new locales
2026-10-28 02:09:49 -07:00
OrcaWinandOrcaWin 0a5f9e9dc5 fix: keep identifier casing locale-independent (Turkish) (#34709)
* fix: keep identifier casing locale-independent (Turkish)

Under a tr/az default locale, toLocaleLowerCase()/toLocaleUpperCase() map
I to dotless ı and İ, and default-locale collation stops treating I/i as
base-equal. Switch identifier matching (Linear CLI selectors, priorities,
error classification, plugin/Jira/worktree/address/slash-command search) to
toLowerCase()/toUpperCase(), and pin collation to 'en' where ordering feeds
hashes, canonical JSON, semver precedence, remote selection, SSH Include
order, or WSL distro equality. User-visible prose casing and display-list
sorting stay locale-aware.

* fix: order SSH Include globs bytewise and fold dashboard search ids locale-independently

---------

Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
2026-10-27 22:47:01 -07:00
Pandu dwi PutraandBrennan Benson ec49e9fac0 fix(native-chat): list OMP skills in the / menu as /skill:<name> (#31999)
* fix(native-chat): list OMP skills in the / menu as /skill:<name>

* test(native-chat): OMP now carries the Pi-shaped skill profile

* Publish native OMP skills with compatible command catalogs

* Index native skill descriptions once per picker build

* Combine catalog test composer imports

* Correct native catalog test types and project inputs

* Run cross-platform picker scaling contract with mobile tests

* fix: discover native commands before the first chat message

* test: isolate native command discovery from mobile typechecking

* fix: release command discovery ownership after managed root exit

* refactor: reuse the ACP child owner during shutdown drain

* test(acp): load filesystem implementation before test execution

* test: drive discovery close completion explicitly

* test: await discovery admission cleanup between demand waves

* test: control discovery close ordering in demand waves

---------

Co-authored-by: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
2026-10-27 17:14:20 -07:00
OrcaWin fbe08ba14d test: remove 134 redundant tests (#34511)
Removes 134 redundant test registrations across native-chat projection, sidebar ordering, and palette matching. Deletes two entire suites: notice appearance mapping and ordering scenarios whose test-owned Host supplies the behavior being asserted.

Retains 154 registrations covering state transitions, competing inputs, FIFO tool pairing, sidebar feed application, and search ranking. Production code is unchanged. Removes the two deleted suites’ timing entries and lowers the wall-clock baseline only for the deleted Date.now assertion.

Validation: isolated static registration/body preservation, formatting, lint, discovery, runtime routing, and metadata checks. Full PR CI must verify 275 expanded cases across 17 owning test roots, including the transcript-contract aggregator; 185 cases belong to retained selected sources and required counterparts. No local runtime tests were run.
2026-10-27 13:00:29 -07:00