mirror of
https://github.com/stablyai/orca.git
synced 2026-11-17 19:34:29 +00:00
fb8d6f950bc9ec2c64fa99ef50d7ff27a866eef2
14
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
4d50c440be |
perf(orchestration): read released worker output from its original instead of a saved copy (#41374)
* perf(orchestration): read released worker output from its original instead of a saved copy * fix(orchestration): keep refusal codes on released chat reads and locate legacy remote transcripts * test(orchestration): prune flaky-pattern baseline for removed archive tests; guard a cursor read * fix(orchestration): keep locator fields when stripping copies; never let the optional receipt page block remote release * test(orchestration): drop removed archive tests from the node-runtime test list * refactor(orchestration): drop the background strip; old rows keep their saved copy and its reader * fix(orchestration): give reference rows the empty copy fields older Orca reads, with a note * test(orchestration): give the slow-exit release mock a stored archive body * fix(orchestration): record a transcript reference only for agents the reader can open |
||
|
|
2e7e992027 |
feat(orchestration): let coordinators approve worker permission prompts (opt-in) (#41306)
* feat(orchestration): let coordinators approve worker permission prompts when the user turns it on One setting on the orchestration page, off by default. When on, the escalation offers orchestration approve and deny, both with a reason, and the user still sees Allow/Deny: the first answer wins. A prompt the worker's agent lets only a person approve is refused and stays with the user. The machine running the worker enforces its own setting. * fix(native-chat): a worker approval's receipt shows the command, not its tool input as JSON * test(orchestration): list every worker-side case in the coordinator approval table * chore(i18n): ship the coordinator approval setting's search keywords in the runtime catalog * fix(orchestration): a reasonless allow keeps the person's refusal, and terminal checks no hook may approve are person-only * fix(orchestration): address review on coordinator approvals - A person-only chat prompt answered meanwhile reports as closed. - A terminal allow reads Claude's warning from the screen it checks, so a late-painted person-only warning still refuses before the hook is used. - The receipt keeps a chat worker's whole command. - orchestration approve prints the reason it sent. * fix(native-chat): read the receipt's command through a parsed shape, not Reflect * docs(skills): drop worker permission prompt guidance; the escalation carries it |
||
|
|
b8950a4f66 |
feat(orchestration): answer workers' permission prompts from the coordinator (re-land with fixes) (#41259)
* revert: worker permission approvals (#40756)
This reverts commit
|
||
|
|
35ce041e1f |
perf(orchestration): stop coordinator check and worker-list from rescanning Run history (#41293)
* perf(orchestration): stop coordinator check and worker-list from rescanning Run history - check: the empty-check hint projects only workers that can still be running or owe an action - worker-list: later pages reuse the first page's inventory counts from the cursor - check: read completion reports for follow-ups in one query - outstanding-delivery lookups and the worker seat-grab check use their indexes - hot by-id lookups name their columns so prepared statements are cached - stop-archive checks archive existence without reading the archive * fix(orchestration): judge the check hint per worker-list page and tie carried counts to their filter * fix(orchestration): reuse carried worker-list counts only for the same Run scope * perf(orchestration): find empty-check hint candidates through indexes and refresh the stale delivery trigger * perf(orchestration): read only the worker-list pages that hold hint candidates * perf(orchestration): look up page owners through indexes instead of reading pages * perf(orchestration): batch hint candidate positions and join pages that share no identity * perf(orchestration): keep creator hand-back lookups on the creator index |
||
|
|
818055fcbb |
feat(orchestration): answer workers' permission prompts from the coordinator (#40756)
* feat(orchestration): deny a worker's permission prompt, and say when mail is held
A chat worker that stops at a permission prompt now escalates with the prompt
itself as structured data (approval id, state, worker, summary, allowed
actions). The coordinator can deny it with a reason through
`orchestration deny`; the worker carries on and gets the reason as mail.
Only a person can allow a prompt: the answer method decides "person" from
the transport, never from params. The stop report keys one escalation per
approval and sends one closing line when it is answered, and no longer tells
the coordinator that `orchestration send` answers a prompt.
`orchestration send` now warns when the delivery gate would hold the mail
right now (an open prompt, a blocked status, typed text), and says delivery
state is unknown for a worker on a paired server.
* fix(orchestration): only the desktop app counts as a person for worker approvals
A paired device can carry a remote CLI, so it is treated as an agent: it can deny with a reason but never allow.
* fix(orchestration): approval answers and held receipts follow the real gates
- A same-option answer counts as Orca's only when Orca recorded it; a retry returns the same
receipt with no second reason mail.
- An unreadable chat is not a closed prompt: the answer refuses, and the closer keeps watching.
- A closing line tells a reason only when it went to the worker as mail.
- The terminal held receipt prints the delivery gate's own refusal; the chat one prints what the
pointer's admission and queue gate would do (not attached, refused, or behind an open prompt).
* fix(orchestration): read the held receipt only after the mail is stored
An await before the insert let a worker settle meanwhile, so the mail could land on a settled
Dispatch after its follow-up scan. The closer also removes only the approval map it read.
* fix(orchestration): tell the coordinator not to block on a worker's permission prompt
The approval escalation now says the worker is waiting for permission, tells a chat
coordinator the user has been shown Allow/Deny (a terminal coordinator: a person must
answer it in Orca or the worker), asks it to carry on with other work and not message
the worker until the answer arrives, and offers deny only as the way out when the
prompt is holding up the task. The guide and CLI docs say the same.
* fix(orchestration): a paired coordinator without an Orca session id mails a deny reason from its Run
* feat(orchestration): answer a Claude terminal worker's permission prompt
A worker pane's PermissionRequest hook now waits for Orca's answer, so the coordinator can deny
it with a reason (the worker continues) and a person can allow it. One record per waiting hook,
keyed by Claude's prompt and tool call; it is answerable only while the hook waits and the dialog
is on screen, and anything else gets `{}` as before.
* test: annotate the fake screen instead of casting
* test: wait on the hang-up instead of sleeping
* fix(orchestration): claim a terminal answer only from what Claude shows
An answer is written only while a caught-up screen still shows the dialog
in the same process run, and claimed only once Claude shows it applied: the
hook's deny line for a deny, no other close for an allow. A Yes, a No or the
2:00 auto-block that wins the race is refused and named from the screen.
A hook that hangs up is not an answer: with the dialog still up the
coordinator is told a person must answer it in the worker's terminal.
A PermissionRequest entry the user made async stays async: it prints {}
first and never waits for a decision.
* fix(orchestration): name a terminal prompt's close from its tool_result
The screen could show an older prompt's close, so who answered is now read
from the tool_result Claude's transcript records for that tool call: Orca's
own deny text credits Orca, the user's No and the 2:00 safety-check block
name themselves, and a run names an allow. Hook events cannot say this: a
deny or a No fires no PostToolUse. The screen only says whether the dialog
is still up before a write, and a PostToolUse seen mid-answer is kept.
* fix(orchestration): read a prompt's tool_result without blocking main
The transcript read is async, reads only its tail, and skips any path that
is not a regular file, so a FIFO or device cannot stall the main process.
A closed prompt still awaiting its result gets one last read when the lead's
turn stops, so a result written late still names the close.
* feat(native-chat): answer workers' approvals from the coordinator chat
A worker's open permission prompt appears as a card at the end of its coordinator's chat, drawn
from the escalation payload as soon as it is stored. The person allows or denies it there; the
card's buttons answer the worker's own prompt over the desktop app's IPC, so only a person can
allow. Once answered, the card turns into a receipt saying who answered.
* fix(orchestration): read a terminal prompt's countdown when it is first escalated
* refactor(orchestration): give a terminal prompt's hold state its own module
* fix(native-chat): let a worker's approval card answer, and drop it once it lapses
The window's runtime calls never carried the orchestration contract
version, so the card's Allow and Deny were refused as an obsolete client.
The renderer ships with its main process, so desktop IPC states the current
contract. An open card whose agent's own countdown has passed, with no
closing message (the app restarted while it was open), is no longer shown.
* test: say why the desktop fence test's runtime stub is enough
* fix(orchestration): a chat worker's approval asks to allow its tool, like a terminal worker's
* fix(native-chat): pause the approval countdown while the window is hidden
* chore(i18n): protect the approval card's worker line copy
* fix(orchestration): close a terminal prompt's card as soon as Orca can't answer it
When the dialog leaves without an answer through Orca, the closing line is
published at once, so the coordinator's card becomes a receipt; a tool
result that arrives later adds a second line naming how it closed, without
waking the coordinator. On startup, open terminal prompts left by an earlier
run are closed the same way, since their holds lived in memory. A Claude
terminal card's reason is the warning Claude prints under the command.
* fix(orchestration): keep the dialog-warning patterns ASCII for the orcad bundle
* fix(native-chat): say when a deny reason reached the worker as a separate message
A coordinator's deny reason for a chat worker whose prompt takes no message is sent
as mail. The receipt showed it the same as a reason that went with the denial, so it
now labels it 'Reason, sent as a message'.
* chore(native-chat): follow main's moved window-activity and agent-session modules
* fix(orchestration): only Orca's own reports draw approval cards, and every card closes
- Cards and the startup sweep read approvals only from rows whose id is the stop report's own
stable id for that approval, through one shared parser; a worker's send cannot draw a card.
- A chat worker's card closes as soon as its own chat answers it (a journal watch replaces the
turn-edge check), when an answer finds the prompt already gone, and after a restart.
- A terminal coordinator is told nobody was shown the prompt and to tell the user; the
terminal-only close asks the same and goes out as an escalation.
- A chat coordinator's line names only the answers its card offers; a prompt with none is a
plain prompt with no card.
- A person's Deny on a chat worker mails no extra reason.
- A record a quit or budget end closed stays closed.
- One closed-approval builder; `waitingOn` becomes `awaitsReply`.
* fix(orchestration): a failing read cannot hang an answer, fail a stored send, or fail the database open
* refactor(orchestration): add the held-send line in send-delivery-hold, keeping send-methods under the size cap
* test(orchestration): read the worker's mail with a schema, not a cast
* fix(orchestration): an open approval stays visible and closes even behind many closed ones or a missing database
|
||
|
|
d0a15d824f |
feat(orchestration): a worker started with --on becomes the paired computer's own worker (#40731)
* feat(orchestration): records, import and settlement for workers a paired server owns (inert until B5)
* fix(orchestration): name the re-pair when a closed link refuses a send
* feat(orchestration): offline reads of workers a paired server owns (inert until B5)
worker-show from this Orca's record when the server can't be reached, labelled
with the server and when it last reported; remote rows in worker-list named by
server; unreachable failures said in the server's terms, apart from the
server's own unknown outcome.
* fix(orchestration): remote rows share the page limit, label re-made pairings, and say what the record's time means
* fix(orchestration): keep remote rows in every page's total, date the record by state only, and retry only by request ID
* chore(orchestration): annotate the remote count query's row type
* test(orchestration): check CLI views of remote workers at the CLI layer
* docs(orchestration): say remote rows get their own page limit
* feat(orchestration): run commands about a paired server's workers there, and switch new pairs to it
* feat(orchestration): offline show and server-named failures for forwarded commands
* fix(orchestration): forwarded start timeout, receipt Run and stop key in the caller's terms
* fix(orchestration): forwarded answers name this Orca's Run
* fix(orchestration): a remote worker's question is answered only by its Run's coordinator; tests for the forwarder
* fix(orchestration): a start answered after its Run was reset says so
* fix(orchestration): refuse a chat session terminal before asking any server; test the late start after a reset
* test(orchestration): lint
* fix(orchestration): review fixes for the forwarder: retry-of stays local, legacy retries stay legacy, unknown outcomes stay fenced, refused starts leave no Task
* chore(orchestration): no type assertions in the forwarder
* fix(orchestration): a start answered after a re-pair frees its Task
* fix(orchestration): worker-show of a worker whose pairing was re-made gives this Orca's record
* fix(orchestration): a retry with --on names the server's Task instead of resending its spec
* fix(orchestration): a read about a remote worker gives up within seconds on a sleeping server
worker-show then answers from this Orca's record, as it does for a server that is off. Changes keep their longer wait.
* fix(orchestration): a refused remote start keeps the Task it created, failed
A local start that fails after creating its Task leaves it failed; deleting it here left any dependent added while the start waited pointing at nothing.
* fix(orchestration): worker-show of a remote worker reads this Orca's record, never its server
Show answers at once whether the server is awake, asleep or off, and agrees with worker-list.
Its note says when the record is from and what the pull loop last heard from the server; a
prompt wait already arrives as the server's mail. worker-read stays forwarded with its 5 s cap.
* refactor(orchestration): drop the orphaned-start lookup; the server's queue item adopts a lost start
A start whose answer was lost stays reserved until the server's dispatch-insert item names its
Dispatch, which adopts it. The 30 s dispatchShow lookup and its two placement columns repeated that.
* fix(orchestration): a stop or abandon the server does not answer settles the Task here at once
As a local stop does, the Task goes blocked so it can be retried, and the stop stays owed with its
count. The first result stands: a later state from the server changes only the attempt's record.
* fix(orchestration): task-update on this Orca's own Task applies here, by the local rule
A Task placed on a paired server is this Orca's; its update goes through the ordinary owner, which
refuses it while the worker there holds it, exactly as for a local worker. Stop first: an
unanswered stop settles the Task here at once. Nothing is forwarded to the server.
* fix(orchestration): a link that can no longer answer fails the Tasks it held, with the reason
When a re-pair closes a link, or its server is removed from this Orca, each Task a worker there
still held fails here through the ordinary Task half ("The pairing with devB was re-made. Its
worker may still run there."), and its placements go. Before, the Task stayed dispatched for good.
* fix(orchestration): a paired Orca's reads on this server are no longer narrowed to its Run
* test(orchestration): a lost start is never looked up on its server
* fix(orchestration): review fixes for the remote Task settlements
- An abandon the server does not answer stops nothing, as a local abandon: it settles the Task here
and owes no stop, with abandon's own receipt.
- A link a re-pair or removal closes tells the Run's coordinator about each Task it failed, as a
local worker failure does, naming the server in the reason.
- An unreleased database drops the placement lookup columns and gains task_settled_here on open.
- A failure settling a removed server's Runs no longer ends the pull loop's bookkeeping.
* fix(orchestration): retries of a remote attempt follow the local rule, and owed stops go out on reconnect
A retry here may follow the Task's attempt on a paired server once it settled there or was
abandoned here, exactly as a local retry follows a local prior; an unproven stop, like a local
stop_unknown, leaves nothing to follow yet. When a server answers again, every stop and cancel
owed to it is due at once through the existing resend, so a retry there follows the proven stop.
* fix(orchestration): a re-pair settles held Tasks at once, lists the Run there, and refuses reuse of its Tasks
- the pull loop closes links of a changed pairing, so their held Tasks fail without a call through them
- worker-list --on lists a Run's workers by its server Run even after its link closed
- a start --on of a Task placed through a closed link is refused here, naming the server
- the server's restart recovery readies its Task, and this Orca follows as the local rule does
- a closed link's note gives why it closed and the server's recorded name
* fix(orchestration): review fixes for the re-pair settlements
- worker-list picks the Run's latest link a server Run answered for, so a refused start's new link hides nothing
- a start answered after a re-pair keeps its placement, so the Task's next start there is refused here
- worker-list --on errors read in this Orca's terms, as other forwarded reads do
* fix(orchestration): a re-pair fails a Task a stop left blocked, and a reset still fails a readied Task
- a closed link also fails a held Task an unanswered stop blocked, which nothing can prove now
- a server reset's removal fails the Task even after its recovery readied the server's Task
- a closed link keeps why it closed when a later queue item cannot be read
* fix(orchestration): a re-paired Run's worker-list says so plainly, with no new read path
- worker-list --on for a Run whose link a re-pair closed names the re-pair instead of runtime_error or an empty page
- a Task placed through an earlier pairing still starts on another server
* fix(orchestration): a re-made pairing's refusals keep their own error code
server_pairing_changed passes through RPC instead of becoming runtime_error.
* fix(orchestration): a re-pair fails a blocked Task only while its stop is owed
A Task a proven stop or an abandon blocked stays blocked; only an unanswered stop, which nothing can prove now, fails it.
* fix(orchestration): a refused start writes no link, and a re-paired Run's list tells a reset apart
- the refusal of a Task an earlier pairing placed runs before any link is written, so the Run's list still names the re-pair
- worker-list decides from the Run's newest link: closed says re-paired, a reset lists nothing, a link closed mid-call says re-paired
* test(orchestration): a paired Orca reads another Run's work on this server, and still cannot change it
|
||
|
|
88880fca7a |
feat(orchestration): a paired Orca as a Run's coordinator on the server it placed work on (inert) (#40717)
* feat(orchestration): a paired Orca as a Run's coordinator on the server it placed work on (inert) The server half of remote-owned workers. A paired Orca's call names one of its Runs; the server admits it as a peer caller kind, writes that Run at frame receipt, and holds it to the one access check. Its workers' mail and state queue home under a sequence no reset reuses. Nothing sends the envelope until the coordinator side ships, so this changes nothing today. * fix(orchestration): reserve the peer address, keep conversation kinds apart, queue a correction once with its result * fix(orchestration): hold back a corrected Task's change whatever its latest attempt; rotate pulls in a stable order per database * chore(orchestration): typed field read, cast rationales, a wake test on fake timers * fix(orchestration): a peer's receipts per conversation, its sends only into its Run, a page that fits every conversation, pending adopted Tasks keep their gate * fix(orchestration): a peer's follow-up places where its worker ran * fix(orchestration): a peer's current/new-child start gets the --on placement refusal |
||
|
|
533a31b742 |
fix(agent-launch): restarted agents keep the launch they ran with (#38998)
* feat(agent-session): keep the permission mode a Claude session reports Claude names its live permission mode on prompt, tool and Stop hooks. Keep the root agent's latest value on the provider session, next to effort, so a resume without a recorded launch can tell whether the session ran in bypass. Ports the capture from #36359 by Nelef. * fix(agent-launch): resume an unrecorded launch bare unless it reported bypass Without a recorded launch, every restart path now resumes with no settings Arguments, env or permission default; the configured Command still runs. A session whose root agent last reported bypassPermissions keeps its bypass flag, so a hand-typed claude --dangerously-skip-permissions keeps it while a bare hand-typed claude never gains one (#29898). Account-switch restart used the shared rule only for Claude; it now uses it for every agent. Thanks to JustinCMR (#37304) for finding the account-switch and cold-restore gaps. * fix(terminal): keep the launch recipe of a window-started agent in main A window spawn hands main its recipe, but main kept only the token and agent, so restarts that main runs (workspace sleep capture, closed-worker reopen) found no recipe and resumed bare. Keep it with the launch authority, the same gate that admits the token. * fix(orchestration): reopen a closed worker with the recipe it launched with A closed worker's pane record goes away with its tab, so orchestration send reopened it bare (#37693). The worker row now keeps the recipe Orca launched the agent with, keeps it when a later capture of the same launch arrives without one (main loses it on a daemon reattach), and a reopen prefers it over a pane record that may hold another launch of the conversation. Adapted from #37757 by Pr1p, without a new column. * fix(terminal): keep a slept pane's earlier recipe only for the same launch A host sleep capture without a recipe reused the pane's earlier record for the same conversation. That is right after a daemon reattach, when Orca's launch still runs but main lost its recipe, and wrong for an agent typed into the shell that resumed the conversation: it never ran that launch. * fix(agent-session): restore a paired pane with the recipe its host recorded A client restoring a pane on a paired host sends only its recorded Arguments, and the host filled the rest from its current settings. A saved restore now replays the host's own record for that pane, or, with none at all, resumes bare and keeps a bypass only when this host's hooks saw it reported. History and other user-chosen resumes keep current settings. * fix(terminal): replay a saved note only for the launch main still holds A note belongs to the agent in a pane only while main holds that launch's token: main admits it at spawn and retires it when the launch command finishes, and a daemon reattach restores neither. Worker, host sleep and hook/quit captures now take a note only from that attested launch, and no longer copy an earlier record's note by agent or conversation match, which a typed resume in the same shell also satisfies. With no attested launch the unrecorded rule applies. Replaces the inferred orcaLaunched / recipeLostPaneKeys flags and drops the mock-only reopen and fixture-echo worker tests. * fix(agent-status): take a pane's note from the launch main attests The window carried a pane's saved note into each new record by agent and conversation match, so an agent typed into the shell that resumed the same conversation inherited an earlier launch's bypass. Main now sends the note of the launch it still holds with each status, and the window records only that, its own launch registration, or, for a restored replay of the very status a record was written from, that record's note. /clear and compact keep the note because main still holds the same launch. * fix(orchestration): reopen a worker with its own recipe or none A worker without its own note took the note of whichever pane record held the same conversation. Its reopen now always passes a complete recipe: its own note, or the unrecorded rule. The unrecorded bypass is also scoped to Claude, whose hooks are the ones that report a root agent's permission mode. * fix(agent-session): restore a paired pane from its source pane, never current settings A saved restore on a paired host looked up the destination pane, which a Wake opens as a new tab, and fell back to the host's current settings whenever the client sent its partial Arguments. The client now names the source pane (to hosts advertising agent-session.restore-source-pane.v1), and the host replays its note for that pane or, with none, resumes bare keeping only a bypass its own hooks saw there. Older hosts keep today's behavior. * fix(terminal): re-arm a launch across a main restart while its agent still runs The daemon outlives main, so it now keeps main's admitted launch (token and note) and drops it when that launch's command finishes. On reattach main re-arms the launch only when the same agent still runs in the foreground: nothing can be typed into a daemon PTY while main is down, so a running agent there is the one the unretired note launched. A shell foreground clears the daemon's note; an unknown read, including every Windows read, declines. Older daemons keep no note, so restore declines there as before. * fix(terminal): the daemon retires a launch note when its command finishes A launch can finish while main is down, so main's own retirement never sees it and a hand-typed agent in that pane would later pass the reattach foreground check. * fix(agent-status): a fresh Claude start never inherits the last process's permission mode A hand-typed resume of the same conversation may run without the bypass the previous process had, so only /clear and compact carry the mode forward. * fix(agent-session): name a restore's source pane in the host's own keys A mirrored pane's key carries the desktop tab prefix, so the host's exact lookup missed its saved note. * fix(terminal): retire a daemon launch note by its token from the one retirement owner A delayed reattach result or a late retire could clear a newer launch's note. Retires now name the token they retire, the reattach checks its PTY before clearing, and re-arming the same launch keeps the daemon's completion scanner. * fix(agent-status): only the launch owner's statement changes a pane's note Main now states the attested note, or null for none, on every hook status. An OSC or display update makes no statement, so after a completed turn it no longer erases an Orca launch's note; a typed resume still drops it through main's null. * fix(terminal): an attach leaves alone a launch main already holds The renderer attaches a pane the CLI just launched before its agent starts, so the attach saw the shell and retired the new launch's daemon note. * fix(agent-status): a paired client keeps a pane's note only on its host owner's word The host's session-tabs frame now says whether the Orca launch it admitted still runs on the published incarnation, and the client applies that fact whichever writer wins the status. With an owner's word the conversation no longer decides; an older host that says nothing keeps the same-conversation rule. * refactor(agent-status): one decision picks a pane's note for every reader The live entry, quit capture, provider-session updates, account restart and cold restore now ask the same owner-aware decision. An owner's none is final and, when it turns, ends the pane's registry entry and saved note, locally and from a paired host's frame. Cold restore and account restart take that answer for a live invocation and read the saved record only when none is live. Inlines single-use wrappers. * refactor(agent-status): a paired retirement test reaches the cold-restore command; trim comments Replaces the projection and continuity tests with one transition: host frame retires the launch, the next OSC keeps no note, and the cold-restore command has no old bypass. * fix(agent-status): an owner's none retires the pane's matched launch registry entry * chore: satisfy changed-code gates (type guards, SAFETY notes, fixed test clock) * fix(agent-launch): a teams launch keeps its note; a legacy leaf id restores without throwing * refactor(daemon): keep the session launch note on the process base so session.ts stays in budget * fix(agent-launch): a restarted terminal main can't vouch for keeps main's earlier launch rule * fix(agent-launch): read the pane's current terminal; a finished launch settles an undecided pane * fix(agent-launch): undecided and held launches end with their process A finished command, a fresh launch or a replacement process settles an undecided pane; a newer attach or finish supersedes a foreground read still in flight; a legacy relay reattach without an incarnation stays undecided; a held launch applies only to the process it was recorded for. * refactor(terminal): watch and arm a created terminal's launch in one call Keeps terminal-create.ts within the 300-line budget after main's growth. * refactor(terminal): keep main's launch evidence in one immutable record Replace the undecided flag, the reattach check map and the re-arm's writes to main's orchestration launch fields with one launchEvidence object (unknown, gone for an incarnation, or held with its recipe), owned by launch-evidence.ts. - A fresh admitted launch is held; any other fresh process is gone. - A finished command or confirmed exit is gone, sticky for its process: no reattach, legacy or noted, can revive it. - A replacement retires its predecessor's evidence without deciding the newcomer, which may still prove its own launch through a reattach. - A reattach note is held only after a foreground read sees its agent; the evidence object fences that read. - A gone launch clears its recipe and blocks both refill sites; a deliberate sleep snapshot keeps its recipe past the launch it captured. - launchToken, launchIncarnationId and launchAgent writes match main. * fix(terminal): keep launch evidence through a first incarnation and sleep snapshots - Learning a process's first incarnation binds its held or gone evidence to it, so a later attach can neither revive a finished launch nor drop a running one; a known X->Y replacement is fenced as before and now also clears the predecessor's recipe. - A status from no Orca launch leaves a sleep snapshot of its session for the wake and never takes that snapshot's recipe into a live or quit record. * fix(terminal): record a runtime split's fresh shell as running no launch * chore: rerun CI on main with the typecheck fix |
||
|
|
bd56be7146 |
feat(orchestration): mail an agent on a paired server with send --on; its reply comes back by itself (#40106)
* feat(orchestration): mail agents on a paired server with send --on, replies come back by themselves * fix(orchestration): gate --on on the carrying Orca, ack retried deliveries, refuse payloads and federated workers * chore(orchestration): annotate peer-mail row casts and drop a wall-clock wait in its test * chore(orchestration): name mail-between-servers codes server_mail_unsupported and mail_requires_server_pairing * docs(cli): list --on in the orchestration reply usage * fix(orchestration): name --environment, the flag on main, in agent mail refusals and the guide * chore(orchestration): mark the two deliberate agent-kind branches mail between servers needs * docs(cli): leave --on out of the reply usage; it is accepted only to refuse it * fix(orchestration): keep peer conversations to peer ids, survive resets and re-pairs, keep pulling on a registry error - A server takes only peerconv_ conversation ids, so a paired computer cannot name another Orca's dispatch in the relay. - A replayed reply after a mail reset is acknowledged, not retried forever; reset tasks keeps replies waiting to be pulled. - A re-paired server starts a new conversation instead of refusing every later send and reply. - A failed registry read keeps the pull loop retrying. - Drop the two ast-grep-ignore lines that only #40193's rule needed. * fix(orchestration): worker-start --on runs on the caller's own Orca, like send --on An inherited ORCA_ENVIRONMENT sent worker-start --on to that server, so the --on command the agent refusal suggests did not work. One rule now keeps send, reply and worker-start with --on on the caller's own Orca. * fix(orchestration): refuse reply --on on both sides of a conversation between servers The side that opened the conversation still took --on when it named the right server; the reply usage says --on is accepted only to refuse it. |
||
|
|
c0d3d2e0db |
test: remove 13 low-value suites and redundant cases (#40138)
* Remove low-value file, runtime and chat test cases * test: remove low-value shared contract and timing suites * test: remove leaking browser IPC mock suite * test: isolate legacy relay bridge transport fixture --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com> |
||
|
|
6c3ca0ab6d |
test: remove 34 low-value suites and redundant cases (#40115)
* test: remove low-value ACP, CLI and simulated scroll suites * test: remove redundant runtime, session composition and timing suites --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com> |
||
|
|
dd6c2a796f |
Show honest liveness for chat-mode orchestration workers (#39804)
* Project chat-mode worker liveness from the structured host * Keep chat reach checks out of per-publication attention and Crew rebuilds * Install the session host before judging structured workers in worker-list and worker-show * Keep worker-list rows to the liveness fix |
||
|
|
1b1a80a512 |
fix(orchestration): refuse a reply to a finished worker's report and name the follow-up that works (#39802)
* fix(orchestration): refuse a reply to a finished worker's report and name the follow-up that works * fix(orchestration): say what the action under a finished report does |
||
|
|
c10881fa8c |
refactor(shared): organize execution and automation defining owners (#39776)
* refactor: import journal queue state from defining owners * refactor(shared): organize execution and automation owners * fix: retain type imports used by surviving test cases * refactor: finish work item owners and refresh validation metadata * test: infer reconnect status fixture type * test(claude): resolve source files beside same-named directories * test(runtime): group repository creation mock registrations |