Skip to content

Release: v1.0.5 - #4617

Merged
vybe merged 1937 commits into
mainfrom
dev
Nov 17, 2026
Merged

vybe merged 1937 commits into
mainfrom
dev

Conversation

@trinity-ability

Copy link
Copy Markdown
Contributor

Release v1.0.5 — cumulative changes since v1.0.0.

478 commits · 361 merged PRs · 162 public + 128 private-tracker issues · enterprise submodule 982735f → a26e522. Full record: docs/releases/1.0.5.md · user-facing summary: docs/user-docs/whats-new/v1.0.5.md.

Highlights

1.0 put an agent in a seat on the team. 1.0.5 makes the seat workable day to day: projects
people and agents run work from, agents that wake when the thing they were waiting for
happens, a memory that can be searched, and an install that is closed to the network until
an admin opens it.


Closes #1988
Closes #2328
Closes #2530
Closes #2720
Closes #2748
Closes #2749
Closes #2891
Closes #3007
Closes #3009
Closes #3047
Closes #3060
Closes #3089
Closes #3136
Closes #3180
Closes #3254
Closes #3296
Closes #3298
Closes #3300
Closes #3302
Closes #3317
Closes #3322
Closes #3363
Closes #3380
Closes #3390
Closes #3395
Closes #3402
Closes #3408
Closes #3439
Closes #3444
Closes #3445
Closes #3448
Closes #3451
Closes #3466
Closes #3487
Closes #3495
Closes #3542
Closes #3543
Closes #3549
Closes #3562
Closes #3563
Closes #3565
Closes #3566
Closes #3568
Closes #3569
Closes #3584
Closes #3601
Closes #3603
Closes #3618
Closes #3625
Closes #3626
Closes #3651
Closes #3663
Closes #3664
Closes #3691
Closes #3706
Closes #3709
Closes #3727
Closes #3785
Closes #3799
Closes #3821
Closes #3825
Closes #3838
Closes #3840
Closes #3849
Closes #3868
Closes #3871
Closes #3872
Closes #3879
Closes #3881
Closes #3884
Closes #3886
Closes #3894
Closes #3909
Closes #3922
Closes #3932
Closes #3940
Closes #3944
Closes #3949
Closes #3950
Closes #3952
Closes #3964
Closes #3966
Closes #3982
Closes #3984
Closes #3988
Closes #3989
Closes #3993
Closes #3994
Closes #3998
Closes #4000
Closes #4001
Closes #4002
Closes #4025
Closes #4026
Closes #4027
Closes #4028
Closes #4048
Closes #4050
Closes #4051
Closes #4052
Closes #4053
Closes #4055
Closes #4057
Closes #4058
Closes #4060
Closes #4064
Closes #4072
Closes #4085
Closes #4093
Closes #4096
Closes #4099
Closes #4105
Closes #4121
Closes #4123
Closes #4128
Closes #4129
Closes #4130
Closes #4131
Closes #4132
Closes #4133
Closes #4137
Closes #4149
Closes #4151
Closes #4156
Closes #4157
Closes #4160
Closes #4165
Closes #4228
Closes #4229
Closes #4241
Closes #4256
Closes #4257
Closes #4259
Closes #4280
Closes #4284
Closes #4302
Closes #4331
Closes #4349
Closes #4352
Closes #4353
Closes #4357
Closes #4359
Closes #4369
Closes #4381
Closes #4435
Closes #4440
Closes #4442
Closes #4445
Closes #4470
Closes #4475
Closes #4479
Closes #4482
Closes #4483
Closes #4499
Closes #4501
Closes #4505
Closes #4515
Closes #4536
Closes #4541
Closes #4570
Closes #4579
Closes #4597

Pre-release checklist passed 2026-11-17. Ready for squash-merge.

  • Tag after merge: v1.0.5
  • Triggers: publish-images.yml, publish-cli.yml (src/cli/** changed) and sync-docs-to-vertex.yml

🤖 Generated with Claude Code

vybe and others added 30 commits November 2, 2026 18:54
…every door (#4180)

* feat(subscriptions): admission policy seam for a per-agent usage share (A)

One edition-agnostic point where a registered policy may stop an agent's
turn before it is admitted, on every door. With no policy registered
nothing changes. The first intended policy is an agent's share of its
subscription's usage, registered through this seam by an optional module.

- services/admission_policy.py: register / enforce / notice. A policy
  refuses with chat_signals.AdmissionRefused (code, plain-words message,
  frees_at); any other policy error is logged and the turn is admitted.
- /chat (admit_chat_request) and /task (dispatch_parallel_task) call it
  after the skill gate, before the idempotency claim: a refused request
  claims, uploads, writes and acquires nothing.
- execute_task step 1c covers every other door: the row closes SKIPPED
  with the message (not FAILED: no schedule failure count, no breaker),
  error_code usage_share, and the refusal on the result.
- routers/chat.py maps it to 429 + X-Trinity-Error-Code + Retry-After;
  a sync /task refused inside execute_task releases its claim and gets
  the same answer; the Workspace shows the message as category `limit`,
  not retryable.
- ExecutionContext.usage_notice renders the policy's notice as a
  `- **Usage**:` line via compose_system_prompt's auto-fill.

Tests: tests/unit/test_ent1059_admission_policy_seam.py (18). Each seam
call, the SKIPPED write, the router mapping, the Workspace branch, the
notice fill and the fail-open re-raise were removed one at a time and a
named test went red each time. test_2638's pre-dispatch allowlist gains
`policy_denied` with its reason.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(subscriptions): usage-share refusal survives the task backlog drain (B)

A share that ran out while a sync /task waited in the backlog: the drain
closes the row SKIPPED, and a long-poll that reads the terminal back from
the row (another worker drained it, or the wait timed out) rebuilt a
success-shaped result from a SKIPPED row. It now answers the seam's own
refusal.

- execute_task's policy gate stores the row error as `[usage_share] text`
  (the #3114 pull-sink shape), so a reconstruct can tell a share stop
  from any other SKIPPED; the in-memory result keeps the plain message.
- _dispatch_sync_backlog's reconstruct branch rebuilds AdmissionRefused
  from a SKIPPED row carrying that code; _map_task_failure then releases
  the claim and the router answers 429 usage_share (no Retry-After: the
  row has no frees_at, the message says when).

Tests: test_ent1059_admission_policy_seam.py +2 (20). The reconstruct
removed -> the drain test red; the prefix removed -> the SKIPPED-row test
red; each restored from a copy.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(subscriptions): usage share card and breakdown column (C)

An agent's share of its subscription's usage, as its owner reads and
changes it. Both surfaces render only when the instance is entitled to
`usage_share`; an unentitled build calls nothing.

- Settings > Guardrails gains a "Usage share" section (UsageShareCard):
  the rolling 7-day and 5-hour windows as used / budget with a meter, the
  warning line drawn at warn_pct, Warning / Stopped badges in words, when a
  stopped window frees, whether a stop ask is pending, the line the agent
  reads on its next turn, and where each number comes from. The owner
  changes it inline through the PUT; an empty field is the platform
  default and all three empty clears the override. Bounds are named
  client-side before a request; a refused PUT keeps the form open with an
  InlineError. Applies from the next turn, no restart.
- Settings > Subscriptions per-agent breakdown gains "Share used (7d · 5h)":
  each agent's own percent, warning/danger tone from the share's own
  threshold; a share the reader cannot see renders a dash, never 0%.
- stores/agents.js: getUsageShare / setUsageShare (single API client).
  stores/subscriptions.js: fetchAgentShares, per-agent isolated.

Tests: src/frontend/tests/unit/usageShareCard.spec.js (22, mounted under
jsdom). Mutations each turned it red and were restored from a copy:
breakdown ungated (1 red), at_budget ignored (2), client validation
bypassed (5), Guardrails section ungated (1). Raw-colour ratchet: no
existing file grew; the new card carries 0 raw non-gray.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(execution): every door answers an admission-policy refusal; a refused loop iteration is skipped, not failed (Abilityai/trinity-enterprise#1059 fix)

Review C2, H1, the test_3274 sweep red and I5 on the pre-admission policy
seam.

C2: a turn an admission policy stopped inside `execute_task` is a SKIPPED
row `[usage_share] <sentence>`, and `_admission_policy_gate` returned it as
a result rather than raising — so every `dispatch_and_await_terminal` caller
that branched on failed/cancelled only answered success-shaped with an
empty reply. On the paid door that attached the execution to the claim,
logged verify-ok and SETTLED a charge for a turn that never ran.

- `chat_signals.admission_refusal_of(result, agent_name)` is the one rule:
  the in-memory attribute when the gate ran in this process, else a rebuild
  from the row's `skipped` + code shape. `result_from_execution_row`
  attaches it, so a turn refused on another worker (the backlog drain, a
  long-poll reading the row back) carries the same refusal; the separate
  rebuild in `_dispatch_sync_backlog` is that call now.
- One branch per door, before failed/cancelled: paid releases the claim and
  neither attaches nor settles (no charge; `payment.reason` is the
  sentence); MCP inline chat answers 429 with the sentence and
  `X-Trinity-Error-Code`; a channel sends the sentence and returns before
  step 12 so no empty assistant turn is persisted; the public link answers
  429 (sync) or stores the sentence as the reply (async); `portal_chat`
  reads status + code as well as the attribute; a room posts the policy's
  sentence and keeps its resume handle and cursor; A2A maps `skipped` to
  `rejected` with the message on the inline path as `_ROW_STATE` already
  did for the row; a refused validation turn is an ERROR verdict. The
  scheduler (`internal.py`), fan-out and operator-resume doors already
  record the skipped row with its message and need no branch; voice and
  the brain orb call `execute_task` directly and close SKIPPED.

H1: `loop_service._close_run` counted a policy-refused SKIPPED as a failed
run (only a gate-held SKIPPED was exempt), so `failed_runs` rose,
`on_failure` applied, and an at-budget loop kept ticking to `max_runs`. It
now reads the refusal off the row (`_split_error_code` + the predicate),
closes the run `skipped`, counts nothing, and stops the loop with the code
as `stop_reason`.

Sweep: `usage_notice` joins the platform-controlled list in
`test_3274_gate_context` — the line is composed by a policy from platform
numbers and never reads requester text. I5: `fetchAgentShares` runs at most
six reads in flight.

Docs: `requirements/security.md` §20.5d and `architecture/execution.md`
state the result-not-worker rule and each door's branch.

Red before the fix, with the door code reverted and the predicate kept:
all ten door tests in `test_ent1059_refusal_doors.py` (the paid one read
`settled`, the Workspace one DID NOT RAISE, A2A read `failed`) and both
loop variants beside the ent#751 hold test (`('failed', 'error')`);
restored byte-identical.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* fix(completion-report): a refused turn's report shows the policy's sentence, not its [usage_share] code (Abilityai/trinity-enterprise#1059 re-review N1)

An admission-policy refusal closes the row SKIPPED with `[usage_share] <sentence>`,
and the completion report (Workspace, Slack, Telegram) posted that text as-is.
The report now strips a known `[code]` prefix from a non-success terminal before
sanitising; an unknown `[...]` and any success text stay as the agent wrote them.
`_split_error_code` moves to the cycle-free `execution_envelope` leaf as
`split_error_code` so the report uses the same parser; the old names stay
importable from `task_execution_service`.

Also adds an executing spec for `fetchAgentShares`' six-lane cap (re-review N3):
a deferred `getUsageShare` over 15 names, high-water mark 6, every name written,
a failed read as `{ error: true }`. Mutation-checked: with the cap at 100 it
fails (expected 15 to be 6).

Red before the fix: test_the_workspace_report_shows_the_sentence_without_the_code,
test_the_channel_report_shows_the_sentence_without_the_code.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…d field, stored in the agent's .env (trinity-enterprise#1066) (#4186)

* feat(asks): a credential ask kind the agent raises by name and only the secret field answers (trinity-enterprise#1066)

An agent that needs a secret asks for it BY NAME: `type: credential` with
`context.credential_name`. The ask sink validates the name through a new
policy leaf (`services/credential_ask_policy.py`: the agent reader's variable
charset, at most 64 characters, never a name the agent runtime refuses from
`.env` or one the platform writes — mirrored from the agent image's
`execution_env` and held in parity by test), refuses `options`
(`invalid_options`), and refuses the kind unless exactly one person is
resolved (`no_person`). The value never travels through an ask: `answer()`
takes `via_credential_sink`, and a credential row answered any other way
raises `CredentialAnswerRefused` → 422 `credential_answer_via_field` on both
doors (operator respond, Workspace answer). Dismiss is unchanged. The
Workspace projection carries `credential_name` only; the wake prompt names
the variable and says to read it from the environment, never a value.

Mutations recorded: removing the `via_credential_sink` check turns
TestAnswerRefusal (2) and TestOperatorDoor (1) red; disabling the `no_person`
check turns the three no-person cases red; both restored byte-identical.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(workspace): the secret field's sink stores the credential on the agent and answers the ask by name only (trinity-enterprise#1066)

A `credential` ask is answered through ONE new Workspace door,
`POST /api/enterprise/client-portal/asks/{id}/credential` (a person only —
`get_portal_principal` fences agent keys out before the row is read, a system
or ops key is 403 `person_required`; the same uniform 404 as the answer route,
which here also covers an ask of another kind). The service runs the answer
route's door checks (own ask, pending, not expired, not diverged) BEFORE the
value is handled, then hands it to the one secret-handling leaf,
`services/credential_sink.py`:

* the NAME re-checked against the ask policy (a file-channel row validates
  nothing) and the value checked by shape only (`invalid_value`: empty, below
  the scrub's floor, over 32 KiB, a line break or NUL);
* STAGED into the runtime identity scrub FIRST, fail-closed — 503
  `scrub_unavailable` when the store is down, so nothing is delivered that
  the scrub cannot see;
* the agent must be running (409 `agent_not_running`, naming the state);
* one sink write per agent at a time through a short Redis lease (409
  `env_busy`; a lease the store cannot grant is the same fail-closed 503);
* `.env` read through the agent's own `GET /api/credentials/read`, one line
  set in place through `agent_env_patch.set_keys` (the #2023 quoting the
  agent's reader reverses; duplicates collapsed; every other byte kept —
  round-tripped in test against the agent image's `parse_env_file`), refused
  over 256 KiB (`env_too_large`), written back through
  `POST /api/credentials/inject` (503 `agent_unreachable` on either leg);
* audit `credentials` / `chat_provide` with the name, the ask id and the file
  — never the value — and the requirements report cache dropped.

Only then does the ask sink end the row `provided` with `via_credential_sink`;
a compare-and-set lost after the write is 409 `already_resolved` with
`credential_written: true` and nothing is rolled back. The value appears in no
log line, no audit field, no refusal message, no response body and no wake
prompt — asserted in test on every path, and pinned by an AST guard over the
module: `value` may be measured, staged, patched into the file or passed on,
never formatted, logged, concatenated or raised.

Verified from the code, not the plan: the inject path is a whole-file
read-modify-write, so the lease is what keeps two sink writes from dropping
each other's key across workers. The owner's Credentials-tab inject and the
Nevermined bind (ent#966, "no agent-side lock, D8") do not take it and keep
their last-writer-wins contract — a documented residual of this change, not
closed by it.

Mutations recorded, each restored byte-identical: dropping `stage_secret`
(4 red), the running check (2), the lease (2), the file cap (1), the
line-break/NUL check (3), the kind check in the service (1), the person check
on the route (2), `via_credential_sink` (6), and a `logger.info` that formats
the value (the AST guard and the leak test, 2).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(workspace): a secret pasted as a plain chat message is refused before admission (trinity-enterprise#1066)

Both Workspace chat routes (`POST …/agents/{name}/chat` and `/chat/stream`)
refuse a message that LOOKS like a credential with 422 `secret_in_message`
after the roster and rate-limit gates and before anything else: no reply
context, no title decision, no session row, no execution row, and on the
streaming route no Idempotency-Key consumed (the ent#403 rule for a refused
model). The refusal names the SHAPE that matched and points at the secret
field a `credential` ask opens; it never carries the text.

The detector, `utils/credential_sanitizer.secret_shape`, runs over
`SECRET_VALUE_PATTERNS` — the one list the execution-log redaction already
uses — which gains two service-token shapes (`ops_…`, `dop_v1_…`) in BOTH
the backend and the agent-image copy, so logs learn them in the same change.
Two deliberate differences from redaction: `Bearer` / `Basic` are excluded
(in a chat message they are prose about an API, and a false refusal teaches
people to route around the guard), and a sensitive `KEY=value` pair counts
only with a value of 8+ characters (the identity scrub's own floor) under the
#3311 harmless-word blanking (`author=…` is not a credential). Every pattern
in the list is either named or excluded, and the test pins that partition
complete so a new shape cannot silently escape the guard.

Mutations recorded, each restored byte-identical: dropping the guard call on
the sync route (11 red), on the stream route (11), the `ops_` shape from the
redaction list (the both-copies redaction test), the `ops` entry from the
guard's names (3), the `KEY=value` branch (6), the value floor (3 prose
cases), and `Bearer` from the excluded set (the partition pin).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(mcp): ask_for_credential — an agent asks the person in the chat for a secret by name (trinity-enterprise#1066)

A one-purpose MCP tool over the credential ask kind: `ask_for_credential(name,
why, request_id?, expires_at?)` raises `type: credential`, titled "Needs NAME",
with `context.credential_name`, addressed to primary and carrying the turn id
so it reaches the person of the conversation. The body is built from the
declared fields only — a value, an agent name or options passed alongside
never travel. Left out, request_id is derived from the name and the turn, so
a retry in the same turn replays instead of asking twice. Refusals come back
named (no_person, invalid_credential_name). The description (1.6k characters,
under the 2,048 cap) says to ask only in a conversation with the person, never
to ask for a secret in a plain message, and to read the value from the
environment without repeating it. Registered in TOOL_ACCESS_POLICY as
self-acting; the documented tool count moves to 176.

Red first: the new describe block in operator_queue.test.ts failed on the
missing tool (TypeError reading execute/description) before the tool existed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(workspace): a masked secret field in the thread for a credential ask (trinity-enterprise#1066)

`PortalCredentialField.vue` is what a `credential` ask renders as in
PortalAsks, wherever the card is mounted (thread, Inbox, rail, agent page): the
variable's name, a masked input (`type=password`, autocomplete/spellcheck off,
password-manager hints off) with Show/Hide, and Send. Send posts once through
the new store action `provideCredential` → `POST /asks/{id}/credential` with the
value in the body only, and the field is emptied BEFORE the request goes out,
so no component state holds the value whatever the server answers; unmounting
empties the element too. Nothing touches the drafts or storage, nothing is
logged, and each refusal the sink names (agent_not_running,
scrub_unavailable, asks_unavailable, already_resolved with or without
credential_written, the server's own invalid_value words) is said in an
InlineError. Discuss is hidden on the kind: a discussion chat is a composer.

The shared kind rule gains `credential` (`queueResponseKind`, label "Needs a
credential"), so the Operating Room card, the detail panel and /m show no
respond box or acknowledge for it — one line saying it is answered in the
person's Workspace. The thread's history row reads "NAME provided" and the
card "You provided NAME", never the stored response.

The composer, on a 422 `secret_in_message` from either chat route, drops the
failed bubble (a Retry would only re-send it), never hands the text back to
the composer, clears any draft still holding it, and shows the server's
pointer above the composer until the next send.

Design system: primitives only (BaseInput, BaseButton, InlineError), the card's
own ink, no raw colour — the new file starts at zero.

Red first: the three new mount specs failed on the missing component, the
`acknowledge` kind, the quoted "provided" answer and the visible respond box,
and on the secret staying in the thread. Mutations recorded: removing the
`secret` branch of settleDelivery turns 2 composer cases red; removing the
field's pre-request clear turns 6 field cases red; both restored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(workspace): build the credential-field fixtures at run time (trinity-enterprise#1066)

The two new specs carried token-shaped literals; the backend guard's tests
build theirs by concatenation so no token-shaped string sits in the tree.
Same here.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(credentials): a credential handed in the chat — requirements, architecture, flow, user docs (trinity-enterprise#1066)

- requirements/credentials.md §3.10: the capability — ask by name, masked
  Workspace field, one `.env` line, "NAME provided", only the field answers,
  named refusals, what is out of scope.
- requirements/security.md §20.11: the one door, the one leaf (scrub first,
  fail closed; lease; one line; audit by name), the answer refusal, the name
  policy, the paste guard and the composer keeping no copy, and the stated
  residuals (channel adapters, non-sink `.env` writers last-writer-wins, live
  stream).
- architecture/backend.md: `credential_sink.py` and `credential_ask_policy.py`
  in the services catalog; the credential kind on the `ask_service` entry.
- architecture/mcp-server.md: `ask_for_credential` on the operator_queue.ts row.
- feature-flows/credential-in-chat.md (new) + index rows.
- user docs: how a person answers a credential ask and what happens when a
  secret is pasted into the chat (credential-management.md), the card and the
  tool in approvals.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(credentials): the secret sink never treats an unread .env as empty (trinity-enterprise#1066)

The sink rewrites the agent's whole `.env`. The agent's read endpoint
omitted the file from `files` in three cases that are not "no file": it
held a non-UTF-8 byte (returned in `files_b64`, which the sink never
read), the read raised (swallowed into a warning), or the path was not a
regular file. The sink mapped all of them to "" and the inject then
replaced the file with one line, deleting every other credential with a
success response.

The agent read endpoint now lists a path in `missing` only when lstat
raises FileNotFoundError, and reads from `_HOME` rather than a hard-coded
home. The sink treats `.env` as empty only when it is in `missing`; under
`files_b64` it is 409 `env_unreadable` (reason `not_utf8`), and absent
from all three maps (a read error, or an agent image older than the
list) it is 409 `env_unreadable` (reason `unconfirmed`). Nothing is
written in either case.

Red first: with the sink unfixed, a .env with other keys plus a Latin-1
byte and a .env mode 000 were both overwritten through the agent image's
real read/inject router over a tmp home (DID NOT RAISE), and so was an
omitted file from an older image.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(credentials): the ops_ shape matches the service-account token, not snake_case (trinity-enterprise#1066)

`ops_[A-Za-z0-9_-]{20,}` matched any identifier of 20+ characters after
`ops_` — this platform's own `ops_context_critical_threshold` setting,
lease keys, function names. Because the shape sits in
SECRET_VALUE_PATTERNS, such an identifier was both refused as a pasted
secret in the Workspace chat and redacted from every persisted log, in
the backend and the agent image.

The token's real form is `ops_` + a base64url JSON document, which always
begins `eyJ`. Both copies now use `ops_eyJ[A-Za-z0-9_-]{40,}` (the guard's
name map with them; the partition test pins the three together).

Red first: three ops_ identifiers were refused by `secret_shape` and
redacted by `sanitize_text` in both copies (6 red); they now pass through
both, are admitted on both chat routes, and a realistic token is still
refused and redacted in both copies.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(asks): a credential ask is addressed to primary only, on every door (trinity-enterprise#1066)

The MCP tool sent `to: primary`, but `_validated_ask` never looked at `to`
for the kind, so `POST /api/agents/{self}/operator-queue` accepted
`type: credential` addressed to `viewer`, `approver` or `role:<id>` as
long as one person filled it — handing a viewer a field that writes into
the agent's environment.

- `_validated_ask` refuses any role but primary for the kind with 422
  `invalid_to` (the REST door, which the MCP tool calls). `to: operator`
  is now refused there too, before addressing.
- The file channel never reaches `_validated_ask`: its clamp resolves the
  addressee from the entry's `addressed_to_email`. For the kind, an
  addressee who is not the agent's single primary person is dropped, so
  the item is ingested unaddressed (an operator item no Workspace field
  opens for). Fails closed on a resolution error, never raises (#1632).

Red first: `to` viewer / approver / role:finance were created or refused
with the wrong code (6 red), and the file-channel clamp kept a viewer as
the addressee (1 red).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(credentials): a refused credential write takes its value back out of the scrub (trinity-enterprise#1066)

The sink stages the value into the runtime identity scrub before it
checks the agent, takes the lease or touches the file. A refusal after
that (agent not running, env busy, lock store down, read unreachable,
env unreadable, file too large) left the value staged in Redis for 24 h
while the person was told "nothing was stored".

- `runtime_secret_scrub.stage_secret` now returns whether THIS call added
  the value; `unstage_secret` removes one (best-effort, never raises).
- The sink runs steps 3-5 in `_deliver` and, on a `CredentialSinkError`
  that left the agent's file untouched, unstages what it staged. A value
  staged earlier by something else keeps its protection.
- The inject leg is the exception: the agent may have written before
  failing, so the value stays staged and the message now says it may or
  may not be stored, instead of implying nothing was.
- Every pre-inject refusal message says nothing was stored, and now that
  is true of the scrub too.

Red first: the seven pre-inject refusal arms left the value staged and/or
did not say nothing was stored (7 red); the inject arms and the
already-staged case are pinned alongside.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(workspace): a credential card names the asking agent and quotes its reason (trinity-enterprise#1066)

A credential ask can be raised from any turn — a schedule's ask reaches
the owner's Inbox — and the card showed the agent's name only on
surfaces that pass `showAgent`, with the agent's `why` drawn as the
card's own body. A person could not always tell who was asking, or that
the reason was the agent's claim.

For the kind, the card now always says "<agent> is asking you for NAME"
(the agent's display label, else its name) and quotes the reason in a
blockquote under "In <agent>'s words:", or says it gave no reason. The
reason is drawn once, attributed, not also as the generic question. No
colour of its own (the raw-colour ratchet is unchanged).

Red first: the mount spec over the real PortalAsks and store found no
asker line and no attributed quote (2 red).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(workspace): pin the drafts-clearing loop in dropSecretMessage (trinity-enterprise#1066)

The review found no spec reached the loop: the composer watch already
clears THIS thread's draft when the send empties the field. The loop is
not redundant — it clears the same text left as a draft in ANOTHER
conversation (pasted there first, then sent here), which sits in local
storage. That case is now seeded and asserted, with an unrelated draft
kept.

Mutation: with the loop deleted from PortalConversation.vue the new case
goes red (1 failed); restored byte-identical.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(credentials): the review fixes in the flow and the backend catalog (trinity-enterprise#1066)

Primary-only addressing (REST door and file channel), `env_unreadable`
and the agent read endpoint's `missing` list, unstaging on a refusal
before the inject, the attributed card, the tightened `ops_` shape, and
the owner-reach residual.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
…cdbc) (#4190)

Three enterprise commits, all on enterprise main: ent#982 (steward
proposes members and task owners), ent#1061 (a task reaches its owner
from the project record), ent#1070 (the per-agent usage share policy,
the private half of #4180).

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
…ent_now removes an agent at once, audit first (#4183)

* feat(subscriptions): admission policy seam for a per-agent usage share (A)

One edition-agnostic point where a registered policy may stop an agent's
turn before it is admitted, on every door. With no policy registered
nothing changes. The first intended policy is an agent's share of its
subscription's usage, registered through this seam by an optional module.

- services/admission_policy.py: register / enforce / notice. A policy
  refuses with chat_signals.AdmissionRefused (code, plain-words message,
  frees_at); any other policy error is logged and the turn is admitted.
- /chat (admit_chat_request) and /task (dispatch_parallel_task) call it
  after the skill gate, before the idempotency claim: a refused request
  claims, uploads, writes and acquires nothing.
- execute_task step 1c covers every other door: the row closes SKIPPED
  with the message (not FAILED: no schedule failure count, no breaker),
  error_code usage_share, and the refusal on the result.
- routers/chat.py maps it to 429 + X-Trinity-Error-Code + Retry-After;
  a sync /task refused inside execute_task releases its claim and gets
  the same answer; the Workspace shows the message as category `limit`,
  not retryable.
- ExecutionContext.usage_notice renders the policy's notice as a
  `- **Usage**:` line via compose_system_prompt's auto-fill.

Tests: tests/unit/test_ent1059_admission_policy_seam.py (18). Each seam
call, the SKIPPED write, the router mapping, the Workspace branch, the
notice fill and the fail-open re-raise were removed one at a time and a
named test went red each time. test_2638's pre-dispatch allowlist gains
`policy_denied` with its reason.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(subscriptions): usage-share refusal survives the task backlog drain (B)

A share that ran out while a sync /task waited in the backlog: the drain
closes the row SKIPPED, and a long-poll that reads the terminal back from
the row (another worker drained it, or the wait timed out) rebuilt a
success-shaped result from a SKIPPED row. It now answers the seam's own
refusal.

- execute_task's policy gate stores the row error as `[usage_share] text`
  (the #3114 pull-sink shape), so a reconstruct can tell a share stop
  from any other SKIPPED; the in-memory result keeps the plain message.
- _dispatch_sync_backlog's reconstruct branch rebuilds AdmissionRefused
  from a SKIPPED row carrying that code; _map_task_failure then releases
  the claim and the router answers 429 usage_share (no Retry-After: the
  row has no frees_at, the message says when).

Tests: test_ent1059_admission_policy_seam.py +2 (20). The reconstruct
removed -> the drain test red; the prefix removed -> the SKIPPED-row test
red; each restored from a copy.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(subscriptions): usage share card and breakdown column (C)

An agent's share of its subscription's usage, as its owner reads and
changes it. Both surfaces render only when the instance is entitled to
`usage_share`; an unentitled build calls nothing.

- Settings > Guardrails gains a "Usage share" section (UsageShareCard):
  the rolling 7-day and 5-hour windows as used / budget with a meter, the
  warning line drawn at warn_pct, Warning / Stopped badges in words, when a
  stopped window frees, whether a stop ask is pending, the line the agent
  reads on its next turn, and where each number comes from. The owner
  changes it inline through the PUT; an empty field is the platform
  default and all three empty clears the override. Bounds are named
  client-side before a request; a refused PUT keeps the form open with an
  InlineError. Applies from the next turn, no restart.
- Settings > Subscriptions per-agent breakdown gains "Share used (7d · 5h)":
  each agent's own percent, warning/danger tone from the share's own
  threshold; a share the reader cannot see renders a dash, never 0%.
- stores/agents.js: getUsageShare / setUsageShare (single API client).
  stores/subscriptions.js: fetchAgentShares, per-agent isolated.

Tests: src/frontend/tests/unit/usageShareCard.spec.js (22, mounted under
jsdom). Mutations each turned it red and were restored from a copy:
breakdown ungated (1 red), at_budget ignored (2), client validation
bypassed (5), Guardrails section ungated (1). Raw-colour ratchet: no
existing file grew; the new card carries 0 raw non-gray.

Refs Abilityai/trinity-enterprise#1059

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(execution): every door answers an admission-policy refusal; a refused loop iteration is skipped, not failed (Abilityai/trinity-enterprise#1059 fix)

Review C2, H1, the test_3274 sweep red and I5 on the pre-admission policy
seam.

C2: a turn an admission policy stopped inside `execute_task` is a SKIPPED
row `[usage_share] <sentence>`, and `_admission_policy_gate` returned it as
a result rather than raising — so every `dispatch_and_await_terminal` caller
that branched on failed/cancelled only answered success-shaped with an
empty reply. On the paid door that attached the execution to the claim,
logged verify-ok and SETTLED a charge for a turn that never ran.

- `chat_signals.admission_refusal_of(result, agent_name)` is the one rule:
  the in-memory attribute when the gate ran in this process, else a rebuild
  from the row's `skipped` + code shape. `result_from_execution_row`
  attaches it, so a turn refused on another worker (the backlog drain, a
  long-poll reading the row back) carries the same refusal; the separate
  rebuild in `_dispatch_sync_backlog` is that call now.
- One branch per door, before failed/cancelled: paid releases the claim and
  neither attaches nor settles (no charge; `payment.reason` is the
  sentence); MCP inline chat answers 429 with the sentence and
  `X-Trinity-Error-Code`; a channel sends the sentence and returns before
  step 12 so no empty assistant turn is persisted; the public link answers
  429 (sync) or stores the sentence as the reply (async); `portal_chat`
  reads status + code as well as the attribute; a room posts the policy's
  sentence and keeps its resume handle and cursor; A2A maps `skipped` to
  `rejected` with the message on the inline path as `_ROW_STATE` already
  did for the row; a refused validation turn is an ERROR verdict. The
  scheduler (`internal.py`), fan-out and operator-resume doors already
  record the skipped row with its message and need no branch; voice and
  the brain orb call `execute_task` directly and close SKIPPED.

H1: `loop_service._close_run` counted a policy-refused SKIPPED as a failed
run (only a gate-held SKIPPED was exempt), so `failed_runs` rose,
`on_failure` applied, and an at-budget loop kept ticking to `max_runs`. It
now reads the refusal off the row (`_split_error_code` + the predicate),
closes the run `skipped`, counts nothing, and stops the loop with the code
as `stop_reason`.

Sweep: `usage_notice` joins the platform-controlled list in
`test_3274_gate_context` — the line is composed by a policy from platform
numbers and never reads requester text. I5: `fetchAgentShares` runs at most
six reads in flight.

Docs: `requirements/security.md` §20.5d and `architecture/execution.md`
state the result-not-worker rule and each door's branch.

Red before the fix, with the door code reverted and the predicate kept:
all ten door tests in `test_ent1059_refusal_doors.py` (the paid one read
`settled`, the Workspace one DID NOT RAISE, A2A read `failed`) and both
loop variants beside the ent#751 hold test (`('failed', 'error')`);
restored byte-identical.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* fix(completion-report): a refused turn's report shows the policy's sentence, not its [usage_share] code (Abilityai/trinity-enterprise#1059 re-review N1)

An admission-policy refusal closes the row SKIPPED with `[usage_share] <sentence>`,
and the completion report (Workspace, Slack, Telegram) posted that text as-is.
The report now strips a known `[code]` prefix from a non-success terminal before
sanitising; an unknown `[...]` and any success text stay as the agent wrote them.
`_split_error_code` moves to the cycle-free `execution_envelope` leaf as
`split_error_code` so the report uses the same parser; the old names stay
importable from `task_execution_service`.

Also adds an executing spec for `fetchAgentShares`' six-lane cap (re-review N3):
a deferred `getUsageShare` over 15 names, high-water mark 6, every name written,
a failed read as `{ error: true }`. Mutation-checked: with the cap at 100 it
fails (expected 15 to be 6).

Red before the fix: test_the_workspace_report_shows_the_sentence_without_the_code,
test_the_channel_report_shows_the_sentence_without_the_code.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(agents): a dotted tag in github:owner/repo@ref pins the clone

The ref after `@` was checked against [A-Za-z0-9_-/] only, so a release tag
such as v1.2.0 failed the check and was dropped without a word: the agent was
created on main while the caller believed it pinned. The ref is now taken
whole when it is a valid branch or tag name (dots allowed, minus the git
ref-format shapes '..', a leading-dot component, a trailing '.' or '.lock'),
and an unusable ref is a named 400 instead of a silent fall-back to main.
The charset stays a shell-safety barrier for startup.sh's eval-built clone.

Red first: tests/unit/test_4165_github_ref_tag.py — the five dotted refs
returned url_branch=None and the ten unusable refs did not raise.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(agents): purge_agent_now removes an agent at once, audit first (Abilityai/trinity-enterprise#1055)

Agent delete is a soft delete (#834): rows, volumes and the MCP key stay for
the retention window. Removing an invited member's agent, or rolling back a
half-created one, must leave nothing but the audit trail, so the retention
sweep's hard purge becomes an immediate, edition-agnostic primitive with no
route of its own:

- the agent_lifecycle:purge audit row is written while the agent still
  exists and outlives it; if it cannot be written nothing is destroyed (503)
- a person caller must pass assert_admin (an agent key carrying an admin
  owner's role is refused); actor=None is the platform itself
- container, queued and in-flight work, Redis state, the #816 cascade
  (sharing, permissions both ways, MCP key) and the data volumes under both
  identities of a renamed agent (#1664) go; a base another agent claims
  stays; a Docker fault never stops the row purge
- system agents (403) and ephemeral agents (409) are refused; no row is a no-op

Red first: tests/unit/test_ent1055_purge_agent_now.py (module absent). Each
of five mutations turns it red: admin gate removed (2), fail-closed removed
(1), soft-delete-before-purge removed (7), base-claim guard removed (1),
audit moved after the container removal (2).

Docs: requirements/core-agent.md §1.4.1 and §4.2 ref pinning (trinity#4165);
architecture/agent-lifecycle.md pointer. Registry: both new test files.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(agents): a tag in github:owner/repo@ref survives the three ref-existence checks (trinity#4165, Abilityai/trinity-enterprise#1055 review C1)

The parser accepted a dotted tag and stored it in `source_branch`, but every
check that consumed that value before the clone asked for a BRANCH of that
name: `provisioning.check_remote_branch_exists` ran `ls-remote --heads
refs/heads/<ref>`, `ref_probes._ref_arg` prefixed `refs/heads/`, and the
PAT path asked `GET /repos/{repo}/branches/{ref}`. So a tag passed the
parser and was refused with "Branch 'v1.2.0' not found" on every path; the
public doc claimed it pinned the clone.

Now all three accept a branch or a tag, the ref still a value after the URL
and never an option: the anonymous check asks for `refs/heads/<ref>
refs/tags/<ref>` with no `--heads`; the probes ask for both and take the
branch first (as `git clone -b` does), peeling an annotated tag to its
commit; the REST path answers a 404 on `/branches/{ref}` with
`/git/ref/tags/{ref}` before calling the ref missing. The refusal names
both: "Branch or tag '…' not found".

Red first: `tests/unit/test_4165_ref_existence_checks.py` drives the real
`check_remote_branch_exists`, `probe_anonymous_ref`,
`probe_tokened_repo_access` and `_validate_github_access` on all three
paths against a fake `ls-remote` that filters like git (so a check that
asks for heads only cannot see the tag) — 9 of 15 red before the change,
all green after. Three pins on the old branch-only contract moved with it
(`test_3725_*`: the argv now carries both refs and a same-named tag answers
when no branch does; `test_ent123_tokenless_clone`: the wording).

Docs: `requirements/core-agent.md` §4.2 names the three checks and the
precedence; the two flow rows that quoted `--heads` / the old wording
follow. Registry entry added.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* fix(agents): a ref in github:owner/repo@ref may not begin with '-' (trinity#4165, Abilityai/trinity-enterprise#1055 review I5)

`_GITHUB_REF_RE` admitted `-foo`. Safe today — every live site passes the
ref as a value (`git clone -b <ref>` takes the next token whatever it
starts with; the probes prefix `refs/…`) — but `startup.sh` also runs
`git checkout "${SOURCE_BRANCH}"`, where a leading `-` IS parsed as an
option, benign only because the clone already checked the ref out. One
shell edit away from not. The regex gains `(?!-)`; the 400 names it.

Red first: `TestRefRefused[-foo]` — DID NOT RAISE. Upgrade-safe: the parser
has one caller (creation); no stored `source_branch` is re-parsed on boot,
pull or reset, so existing agents are untouched.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* fix(agents): an annotated tag in @ref resolves to its commit, not the tag object (trinity#4165)

`ref_probes` asked `ls-remote` for `refs/heads/<r>` and `refs/tags/<r>` and
took a peeled `refs/tags/<r>^{}` line when one was listed. git never listed
one: it shows a ref only when a pattern names it, and the peeled line's name
ends in `^{}`. So an annotated tag resolved to the TAG OBJECT, and the raw
template read was pinned to an id that is not the commit the clone checks
out. The probe now also asks for `refs/tags/<r>^{}` by name.

The unit fake listed `^{}` lines for a bare tag pattern, which is why the old
test passed. It now lists a ref only when a pattern names it, and a new file
runs the probes against a real bare repository over file:// (a lightweight
tag, an annotated tag, a branch and an annotated tag sharing a name).

Red first: test_4165_ref_probes_real_git.py — the annotated-tag and tokened
cases returned the tag object id; 4 others passed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(agent-server): a tag-pinned agent's pull cycle is a named skip, not a failure every tick (trinity#4165)

`github:owner/repo@<tag>` clones with `git clone -b <tag>` in source mode,
which leaves the agent on a detached HEAD: pinned to that release, by design.
Pull sync is on for every `github:` agent, and `_run_pull_once` recorded
`failed: detached HEAD: nothing to pull onto` on every cycle, a failure
streak for an agent doing what it was asked to.

A detached HEAD now records `skipped` with the reason named. A detached HEAD
left by a rebase stopped part-way (its rebase-merge/rebase-apply directory
exists) stays `failed`, so a stuck tree still shows. The push cycle is
unchanged: it is off by default for a source-mode agent, and an owner who
turns it on for a pinned agent gets an honest failure.

Red first: test_4165_pull_cycle_pinned_tag.py::test_every_cycle_is_a_named_skip_not_a_failure
— 'failed' == 'skipped'. Real repos, the agent cloned -b v1.0.0 (annotated).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
…make the paste guard linear (#4191)

* fix(agent-server): the credential read stays inside the agent home (trinity-enterprise#1066)

CodeQL flagged the `os.lstat` this branch added to `GET /api/credentials/read`
(path depends on a user-provided value). The finding is real at the guard,
not at any current caller:

- the guard (`lstrip("/").lstrip(".")`, a `".." in` test on the stripped
  string, `str(resolved).startswith(str(home))`) let a single leading `../`
  through, and its prefix compare had no separator, so `../home2/.env`
  READ a file in a sibling directory whose name extends the home's;
- the new `lstat` ran before any containment check, so `../<anything>`
  came back in `missing` — an existence probe one level above the home.

Not reachable before this fix through the platform: the route sits behind
the agent's per-agent auth middleware (#1159) and every backend caller sends
fixed relative paths (`.env`, `.mcp.json`, `.credentials.enc`) or the agent's
own `/list` output.

Fixed at the root with one helper, `_contained_read_target`: refuse absolute
paths and any `..` component, then require both the normalised lexical path
and the link-resolved path to sit under the home with a trailing separator.
`lstat` runs on the contained lexical path (the absence proof); the read goes
through the contained resolved path, so a link is followed only to a target
that is itself inside.

Red first: tests/unit/test_ent1066_credential_read_containment.py — 5 of 13
red at the previous guard (sibling read, `../` oracle, absolute path, link to
a sibling file, linked parent directory), all green with the fix; the fix
reverted from a scratch copy turns the same 5 red.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(sanitizer): the paste guard's KEY=value walk is linear by construction (trinity-enterprise#1066)

CodeQL flagged the two regex calls in `secret_shape` (py/polynomial-redos,
"may run slow on many repetitions of '!'"). Origin: the patterns pre-exist
on dev — `_KV_LINE_RE` / `_KV_PAIR_RE` are the redaction's #1661/#3311 walk —
but these two alerts are introduced by this branch, which feeds them a
Workspace chat message (user-provided text) through the new guard.

Measured before the change, CPython was already linear on every shape tried
(`!`*n, `=`+`!`*n, `!`*n+`=`, `!=`*n, `k=!`*n, an unclosed quote, sensitive
keys with short values): 1M characters took 0.04-1.1 s, scaling ~10x per
10x. The lookbehind pins each key to the start of its run — the engine
detail CodeQL's model does not see (#1661 says the same). The route caps a
message at 100k characters.

The guard no longer rests on that detail. It finds each `=` with
`str.find`, walks back to the key start (never past the previous `=`, so
no character is visited twice), and checks the value with one fixed-width
match — an optional opening quote and eight non-space, non-quote
characters. No length cap, so nothing at the end of a long message is
dropped. One deliberate widening: the closing quote is no longer required,
because a truncated paste is still the secret. The redaction path is
unchanged.

Red first: tests/unit/test_ent1066_secret_guard_linear.py — red before the
change on the no-unbounded-regex pin and the unclosed-quote case (2 of 43);
the timing bound (1M < 3 s, 10x input < 30x time) and both-way detection
were green before and after. The change reverted from a scratch copy turns
the same 2 red. The 1661/2208/2398/3840 sanitizer suites and the paste-guard
suite stay green (608 passed).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…7a02) (#4193)

Picks up Abilityai/trinity-enterprise#1072 (member_agents module, ent#1055),
which composes the purge_agent_now primitive from #4183.

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* Revert "feat(subscriptions): an agent's share of a subscription, enforced at every door (#4180)"

This reverts commit 9eedbbb.

* chore(enterprise): bump the gitlink to the ent#1070 revert (trinity-enterprise#1076)

Lands with the #4180 revert so dev never carries the usage_share module
without the admission_policy seam it imports.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…4160) (#4169)

Every agent bubble renders PortalMarkdown's sr-only live region, which is
position:absolute. The reading pane's scroll box was not positioned, so
those regions resolved against the page, escaped the overflow box, and a
long room stretched the document: the wheel scrolled the whole Workspace.
Make the scroll box `relative`, as the list column's already is.

Adds a mount spec pinning the containment structure for a long room, a
room with many messages, and a thread.

Fixes #4160

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
… the poller core into PollerCoreMixin (#3785, PR 2 of 4) (#4037)

* fix(operator-queue): the #1677 helper delegates to the platform-alert seam

create_bounded_alert(_outcome) keep their signatures and outcome contract
and become a thin delegate of platform_alerts.observe, which already
composes the per-(agent, type) budget inside its one locked create. The
registered type names its kind; the key is read back from the item's id
and context by derive_legacy_subject and must resolve to that same kind,
else ALERT_FAILED_CREATE. The two kinds whose ids carry no subject
(gitignore, problem report) are keyed by the request id minus the kind's
prefix. observe's "updated" and "snoozed" pass through; "failed" maps to
ALERT_FAILED_CREATE; every refused or failed arm logs [#1677 budget].
ALERT_FAILED_COUNT stays importable and is no longer returned.

The budget episode reports through observe as kind alert_budget keyed by
the budgeted type: one alert_budget:<type> row per agent, re-read by a
later refusal outside the cooldown, ended by its 14-day lifetime. The
bucketed id and its own operator_queue_new broadcast are gone; observe
sends the thin operator_queue_sync trigger.

Ratchet: create_bounded_alert_outcome and _maybe_emit_alert_budget_episode
leave EMITTERS_NOT_YET_ON_SEAM; alert_budget gets a NO_CLEAR_SITE reason.
Census: both leave _ALLOWED_CALLERS (no direct create left in either).

#3254 re-pins (asserted outcomes unchanged):
- test_1677_operator_alert_budget: write-observation point. The harness
  stands in for the seam's create with the same budget arithmetic and
  runs what observe spawns. Id shape in
  test_deterministic_bucketed_id_with_reserved_prefix,
  test_cooldown_knob_zero_never_raises (the subject replaces the bucket)
  and test_under_cap_creates_item_and_notification (the seam's id). The
  episode raise now stays in its spawned task, so
  test_episode_helper_raise_swallowed_refusal_stands reads the delegate's
  WARNING marker; test_ws_broadcast_failure_swallowed checks the thin
  operator_queue_sync payload.
- test_3130_flood_guard, test_1632_operator_queue_caps: write-observation
  point. The flood alert still rides the delegate, so its writes, the
  typed budget read and the I1 fault injection move to the seam's create.
- test_3243_atomic_asks::test_a_cap_hold_never_fires_the_flood_alert:
  write-observation point. Watched at observe, since the oqs.db assertion
  alone would now pass whether or not the alert fired.

Known until the problem report moves in its own commit: nine
test_3521_problem_report_comment cases are red here. The delegate files
an event-kind row under the seam's id, which the old _attach_comment
(keyed on the pre-seam request id) cannot find.

New: tests/unit/test_3254_budgeted_alerts.py (registry parity, reach-back
imports, the delegate's outcome table over all five budgeted types, the
episode's seam properties, R1 for alert_budget).

Part of #3254

* fix(operator-queue): the flood alarm reports through the seam and ends with its episode

OperatorQueueSyncService._maybe_emit_flood_alert reports through
platform_alerts.observe as kind queue_flood keyed by the reason: one
pending row per (agent, reason), rewritten in place, budgeted by the
seam. #3130's outcome rule is kept on observe's strings: a failed write
releases the episode and is retried after the cooldown (I1); created,
updated, snoozed and refused consume it.

While an episode lasts it is re-read at most every 6 hours, so the kind's
14-day lifetime ends only a row nobody re-read, never a condition that
still holds. The refresh time per (agent, reason) is a dict the method
creates on the instance for itself; __init__ is unchanged. The flood's
own operator_queue_new broadcast (which carried the title) is gone;
observe sends the thin operator_queue_sync trigger.

The two _sync_agent statements where an episode ends
(_flood_episodes.discard for oversize_file and ingestion_cap) become
calls to the new _end_flood_episode, which ends the episode and, only
when one was running, ends its alert as the platform through
platform_alerts.clear. A cycle with no episode costs no read.

Ratchet: _maybe_emit_flood_alert leaves EMITTERS_NOT_YET_ON_SEAM;
queue_flood's clear site is _end_flood_episode.

No re-pin in this commit: the #3130 and #1632 harnesses were moved to
the seam's create in the previous commit and keep their results.

Tests: the flood through the real _sync_agent poll for 30 simulated days
with the real expiry sweep (one row, re-read every 6 hours, ended as the
platform when nothing is held), no read without an episode, two reasons
two subjects, I1 on the real seam, a person's ending standing through the
re-read and the clear, the thin trigger, R1 for queue_flood.

Part of #3254

* fix(execution): the effect guard and missing-skill alarms report through the seam

_on_unguarded_effect reports a refused effect through
platform_alerts.observe as kind effect_unguarded keyed
"<effect_type>:<reason>": one row per agent, effect and reason,
rewritten by each further refusal, ended by its lifetime (nothing
observes an agent starting to send ids). The send is refused whatever
the alarm's outcome.

_alert_skill_not_found reports through observe as kind skill_not_found
keyed by the truncated command: one row per agent and command, re-read by
each scheduled run. The paired notification is sent only on "created": a
repeat of a pending command is an "updated" reading and already had one;
refused, failed and snoozed wrote no new row. The pre-create dedup read
stays and now matches only a pending pre-#3246 row (no subject), which
keeps standing for its command until the upgrade sweep stamps it; a seam
row is re-read through observe, where a repeat is never refused at the
cap.

task_execution_service.py: only _alert_skill_not_found changes. Its
module-level utc_now_iso import is now unused and is left in place.

Ratchet: _on_unguarded_effect and _alert_skill_not_found leave
EMITTERS_NOT_YET_ON_SEAM; skill_not_found gets a NO_CLEAR_SITE reason
(only the dispatch path could see a command resolve, and there the
detector cannot tell "resolved" from "not a slash command").

#3254 re-pins (asserted outcomes unchanged):
- test_1677_operator_alert_emitters::
  test_skill_not_found_emitter_is_routed_not_allowlisted: the module must
  call platform_alerts.observe naming "skill_not_found" (AST), the seam
  that composes the budget, instead of mentioning create_bounded_alert.
- test_2392_effect_guard_fail_closed: write-observation point and id
  shape. The alarm is recorded at platform_alerts.observe instead of a
  sys.modules stub of operator_queue_service, which lacks the names the
  seam reaches back for. The id prefix is asserted on the kind; the
  at-budget case returns the seam's refused_at_budget.
- test_ent879_aauth_resource_route (the refused-call case): the dead
  create_bounded_alert patch moves to platform_alerts.observe.

Tests: the effect refusal's seam properties and lifetime; the missing
skill's one row per command, no notification on a repeat, a pre-seam row
still standing, no notification at the cap; R1 for both kinds; the other
shape, the clock 30 days ahead: a full skill_not_found budget frees
itself through the real expiry sweep and a new command files.

Part of #3254

* fix(git-sync): the gitignore sweep's alert is one row per change set

_emit_gitignore_untracked_alert reports through platform_alerts.observe
as kind gitignore_untracked, which stops being an event kind
(platform_alerts.py: event=True dropped). It is a must-act kind: no
lifetime, never ended by the platform.

It is keyed by the change itself: a 32-hex digest of the canonical,
direction-tagged set of paths the Push untracked and newly un-ignored
(sorted removed paths, the exact removed count, sorted un-ignored paths).
A repeat of the same set collapses onto one row; a different set, a
different total behind a capped list, or the same path in the other
direction is a different row. Keying per agent would let a later Push
overwrite an earlier Push's path list on a pending must-act alert, which
#2529 calls the surface that outlives the session. The legacy prefix
keeps its _no_subject parser, so pre-existing rows stay pending until a
person acts.

Ratchet: _emit_gitignore_untracked_alert leaves EMITTERS_NOT_YET_ON_SEAM.

#3254 re-pins (asserted outcomes unchanged):
- test_2529_gitignore_precedence: write-observation point and id shape.
  The alert is watched at platform_alerts.observe (the two
  create.await_count == 0 checks would otherwise have gone vacuous); the
  per-agent id prefix is asserted on the kind, with the 32-hex key.
- test_3246_platform_alerts_leaf::test_event_kind_has_no_subject:
  gitignore_untracked is a condition now, so it is asserted keyed and the
  problem report stays the event example.

Tests: a repeated set is one row that never expires; distinct sets and a
capped list with another total stay distinct; the direction tag holds;
a person's ending stands; the 30-day case now also shows the gitignore
row still pending.

Part of #3254

* fix(workspace): the problem report is one seam row per person, target and day

raise_problem_report reports through platform_alerts.observe as kind
workspace_problem_report, which stops being an event kind (event=True
dropped). It is keyed by the 32-hex digest _problem_report_id already
computes: one row per person per target per UTC day, the "never
duplicates" rule its docstring states. A person must act on it, so it
never expires and the platform never ends it. The workspace-problem- id
prefix is kept, so ent#866's owner-only rule and the machine-key "about a
person" exclusion still hold. It returns True when the row was created or
updated, False when snoozed, refused or failed.

#3521's words-only rule moves under the seam's lock. observe gains
keep_text (passed through database.create_platform_operator_queue_item to
create_platform_item and _touch): with keep_text and a pending row, the
reading only counts (last_seen_at, seen_count, expires_at) and the title,
question, priority and context stand. The bare click passes keep_text, a
reading with words does not. The click and the comment are two background
requests that meet on one row inside the per-agent lock, so either order
ends with the words. With no pending row the reading files as usual.

update_pending_problem_report (database.py, db/operator_queue.py) and the
nested _attach_comment are removed: one write path.

Ratchet: raise_problem_report leaves EMITTERS_NOT_YET_ON_SEAM, which
fixes the nine test_3521 cases the delegate commit left red.

#3254 re-pins (asserted outcomes unchanged):
- test_3521_problem_report_comment: the acknowledgement fixture goes
  through ask_service.answer (fixture shape; a raw status UPDATE carries no
  person ending for the snooze to read); the accessor test asserts the
  same type guard at the seam (a foreign row under the report's old id is
  never written); the lost-race test injects the bare click's whole
  reading, in its own thread, before the comment's locked create.
- test_ent499_problem_report: write-observation point. The fake moves from
  create_bounded_alert to platform_alerts.observe; the routing AST test
  asserts the call to observe.
- test_ent715_queue_person_fields: update_pending_problem_report leaves
  _NON_ROW_ACCESSORS (the accessor census forbids a stale entry).
- test_3246_platform_alerts_leaf::test_event_kind_has_no_subject: no
  built-in kind is an event any more, so the property is pinned on a kind
  registered for the test, and both former events are asserted keyed.
test_ent866_problem_report_owner_only is unchanged.

Tests: keep_text at the sink, both interleavings keeping the words, one
must-act row per person, target and day, the owner-only prefix, the
delegate and the emitter landing on one subject, a person's ending not
rewritten or reopened; the 30-day case now also shows the report still
pending; the five-type admission test asserts every kind keyed.

Part of #3254

* fix(operator-queue): decide a platform alert's snooze under the create's lock

observe checks the snooze before the create's lock. Two moments let a
person's ending slip past that check: an acknowledgement after observe
read the pending row but before the locked create (the locked find then
misses), and one between the locked find and _touch's compare-and-set
(the lock covers creates, not respond_to_item, so the CAS loses). Either
way the create fell through to an insert, and the alert a person had just
ended was back at once. Before this batch most of the moved writers had a
deterministic id that could not re-file after an ending, so the moves
would otherwise ship that regression.

create_platform_item gains snooze_since and a snoozed predicate. On the
insert path, after a missed find or a lost CAS and inside the same locked
transaction, it reads the newest person-ended row for the subject through
the transaction's own connection (the public lookup opens another one)
and returns {"outcome": "snoozed"} without inserting when the predicate
says so. observe passes the standard 7-day window, computed on its own
rather than from the pre-lock check's conditionally assigned cutoff, and
lambda ended: _snoozed_by(kind, ended, priority, context). The pre-lock
check stays as the fast path. A caller that passes neither keeps the old
behaviour.

The statement behind the public find_person_ended_by_subject becomes
_find_person_ended_by_subject(conn, ...), shared by both reads.

Tests: a person's acknowledgement through ask_service.answer, landed (a)
between observe's read and the locked create and (b) between the locked
find and the CAS, yields "snoozed" and no new row, for the problem
report, an inbox collision as registered on dev, and the flood alarm's
6-hourly re-read. All six cases were red before this commit (a fresh row
was created) and pass with it. On SQLite, BEGIN IMMEDIATE holds every
other writer, so moment (b) lands the ending first and hands both finds
the row as it stood just before it; two real workers are not exercised.

Review fixes carried here (the earlier commits are left as they are):
- OperatorQueueSyncService._maybe_emit_flood_alert: the cooldown is
  stamped before every reading, the 6-hourly re-read included. A failed
  re-read released the episode with the cooldown stamp still 6 hours
  old, so it was retried on the next 5-second cycle. New test: a failed
  re-read is retried no sooner than the cooldown (red before the fix).
- test_3521_problem_report_comment (the lost-race re-pin): asserts the
  bare click's own request returned True and left a pending, comment-free
  row before the comment's locked create ran, so the test cannot pass
  without the interleaving it claims.
- gitignore_sweep: states that past the probe's 2,000-line cap the key is
  the capped list plus the exact total (a full-set digest needs the
  in-container probe, outside this change).
- test_1677_operator_alert_emitters: the census's guidance for an
  agent-influenceable emitter now points at platform_alerts.observe, not
  the delegate the #3246 ratchet counts as off the seam.
- test_3254_budgeted_alerts: the frozen clock also covers
  db.operator_queue's ent#815 commit-lag check, which logged spurious
  errors against the real clock.

Part of #3254

* fix(operator-queue): a failed flood re-read keeps the episode, so its end still clears the alert

Fresh review of the #3254 budgeted slice (two findings):

- A failed 6-hourly re-read of a persisting flood released the episode.
  If the condition then cleared before the retry, `_end_flood_episode`
  found no episode and the pending alert waited out its 14-day lifetime,
  although the code had seen the condition clear (AC 2). A failed re-read
  now keeps the episode, whose alert an earlier reading filed, and the
  re-read is retried once the cooldown has passed. A failed first reading
  still releases the episode (#3130 I1). New test:
  test_a_failed_reread_keeps_the_episode_so_its_end_still_clears_the_alert
  (red with the old release branch put back).
- AC 8 for two kinds had no "a person's ending is never overwritten" test:
  `skill_not_found` (the next run is snoozed and sends no notification)
  and `alert_budget` (a later refusal re-reads the episode and the
  acknowledgement stands). Both added.

* test(operator-queue): the budgeted-alert suite freezes the clock its running methods read

In the full serial unit tier, test_1595_sync_health_signals evicts
`database` and every `db.*` module from sys.modules and restores only
some of them. Afterwards `database.db` and `ask_service.db` run on an
older `db.operator_queue` module than the one this suite's clock fixture
imports and patches, so the seam's create, the expiry sweep and the
answer's compare-and-set read the real clock: rows filed at the frozen
T0 read as long expired (five cases red, `AskConflict: expired`, a
second flood row). The fixture now also freezes `utc_now_iso` and
`datetime` in the globals of the live operations class (R6: patch what
the running method reads). Red before: test_1595 followed by this file,
7 failed; green after: 66 passed; the file alone: 55 passed.

* refactor(operator-queue): operator_queue_service becomes a package, content unchanged (#3785)

The 2,840-line module moves to services/operator_queue_service/__init__.py
byte for byte (100% similarity), the first step of the Invariant #1 split.
Every `from services.operator_queue_service import X` and
`from services import operator_queue_service` resolves as before.

Six path-keyed guards name the file by its path, so their key moves with it
(the PR #2487 precedent): _NOT_EMITTERS (test_3246), _ALLOWED_CALLERS
(test_1677), _ALLOWED (test_1920), _OQS (test_ent715), FLEET_LEVEL_ALLOWLIST
(test_ent467), and the source read in test_ent499. Only the key changes; the
rule, the reason text and every assertion are untouched.

Part of #3785

* test(operator-queue): pin the package's one-binding rules before the split (#3785)

tests/unit/test_3785_operator_queue_package.py pins what S2–S6 must keep
while they move code out of __init__, each property derived from the tree
so no later slice edits it: modules under 800 lines (__init__ exempt, with
a staleness check); the import surface src/backend and tests/ read still
resolves; no from-import between package modules; one top-level binding per
name; import-time reads defined first and the _MARKER_UNCHANGED default the
owner's object; a patch of a re-exported name lands where its readers read;
one logger identity; owner-exact qualified reads; no submodule named like a
package attribute; one rate_limiter; no method on two classes of the
composed service; external imports before the first submodule import,
and a failed first import, injected at that line, leaves no stale submodule.
The AST scans live in _oqs_package_scan.py (pure stdlib, never imports src).

The other shape, a fresh install: each consumer imported first in its own
interpreter on an empty database raises a bounded alert (created; only main
binds a WebSocket manager, and then exactly one thin operator_queue_sync
trigger goes out). Outcomes equal on the base.

Part of #3785

* refactor(operator-queue): bind the service's collaborators once, in deps.py (#3785)

db, _queue_db, principal_reach, get_breaker_redis, ask_service, AgentClient
and the audit sink _audit_sync move to services/operator_queue_service/deps.py,
bound once and read as deps.X everywhere in the package. They are no longer
attributes of the package, so a stale monkeypatch.setattr(oqs, "db", ...)
raises AttributeError instead of patching a copy nothing reads (Invariant
#1(a), the PR #2487 rule). rate_limiter stays on the package: ask_service
reads oqs.rate_limiter.check.

Tests that patched a collaborator on the package now patch oqs.deps.X; no
assertion, expected value, fixture or control flow changes. The package guard
gains G4 (deps binds exactly the collaborators, no other module imports one
from its source under any alias or holds one by identity, the package has
none) and refuses any reach of a package function's __globals__.

Part of #3785

* refactor(operator-queue): the queue listing engine moves to listing.py (#3785)

QueueListError, narrow_to_agent_key, the cursor and walk-snapshot helpers and
list_for_principal (trinity-enterprise#815) move whole from __init__ to
services/operator_queue_service/listing.py. The two package-owned prefix
tuples are read as _oq.X, collaborators as deps.X. The package re-exports
exactly the six names read from outside (the router's list_for_principal and
QueueListError; narrow_to_agent_key, encode_cursor, decode_cursor and
CURSOR_MAX_BYTES, which tests call or compare).

test_ent715's row-reader census re-keys list_for_principal to listing.py; no
assertion changes.

Part of #3785

* refactor(operator-queue): the poller core moves into PollerCoreMixin (#3785)

The instance state, start/stop, the Redis leader lease, _poll_loop,
_poll_cycle and _broadcast_sync move into PollerCoreMixin in
services/operator_queue_service/poller.py. OperatorQueueSyncService is now
composed in __init__ from the mixin and keeps its singleton there (the
db/schedules shape). Package-owned names (DEFAULT_POLL_INTERVAL, _LEADER_KEY,
_RESERVED_ID_PREFIXES, _websocket_manager) are read as _oq.X; the default
poll_interval still binds 5 at import.

Three path-keyed censuses re-key their poller entries to poller.py
(test_1920's lease, test_ent467's operator_queue_sync trigger, test_ent715's
_poll_cycle); no assertion changes.

Part of #3785

* fix(operator-queue): a new flood, budget or untracking episode files after an acknowledgement (#3254)

A person's ending of a `queue_flood`, `alert_budget` or `gitignore_untracked`
row snoozed every later reading of the subject for 7 days, because none of
the three kinds had a material key, so `_snoozed_by` was vacuously true. A
runaway agent's second flood, a second budget-full episode and a second
untracking Push of the same paths were all silent (review C1; dolho on
operator_queue_service.py:2800 and gitignore_sweep.py:335).

Each reading now carries an episode marker that the kind lists in its
`material_keys`:
- queue_flood: `episode_started_at`, stamped when the in-memory episode
  starts. Re-reads of one episode share it; an episode that starts after the
  condition cleared does not.
- alert_budget: `filled_by`, a digest of the ids of the pending rows filling
  the budget. Re-reads of the same full budget share it; once a slot frees
  and a new row fills it, it differs.
- gitignore_untracked: `push_id`, one per call. The emitter runs once per
  Push, so every untracking Push after an acknowledgement files; repeats
  still collapse onto a pending row.

So the snooze silences re-reads of the acknowledged episode for the snooze
window and a new episode files at once, which makes the
`_maybe_emit_flood_alert` docstring's #3130 edge-trigger claim true again.
The budget episode's read of the filling rows is classified in the ent#780
row-reader census as internal.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HWna79vVmnezQdhpaGRKbw

* fix(operator-queue): a flood re-read no longer stamps the per-agent cooldown; the oversize end is pinned (#3254)

Review follow-ups on the flood alarm:
- dolho on operator_queue_service.py:2778 (webmixgamer agreed): the 6-hourly
  re-read of one reason's episode stamped the per-agent
  `_flood_alert_cooldown`, so the other reason's first alert could wait up to
  one cooldown. The cooldown spaces episodes and a re-read is not one, so it
  is now stamped only before an episode's first reading. A failed re-read's
  retry spacing already comes from its refresh time.
- webmixgamer I3: the 6-hour re-read spacing is one constant,
  `OPERATOR_QUEUE_FLOOD_REREAD_SECONDS`, read by the gate and by the failed
  re-read's retry arithmetic, so the two cannot drift.
- webmixgamer I1: a `_sync_loop` case serves an oversized file and then a
  sane one and asserts the row ends as the platform. It goes red when
  `_sync_agent`'s `_end_flood_episode(agent_name, "oversize_file")` is
  replaced by a bare episode discard.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HWna79vVmnezQdhpaGRKbw

* docs(operator-queue): state the fail-open double-leader bound on the flood episode marker (#3254)

The episode marker is worker-local. With Redis down the leader lease fails
open, so each worker stamps its own episode_started_at and another worker's
re-read can file past a person's ending, at most one extra row per extra
worker per re-read window. Docstring only; no behaviour change (review L1).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HWna79vVmnezQdhpaGRKbw

* lint(operator-queue): __init__ drops its file-level F401 waiver (#3785)

Review I1 (dolho): the file-level `# ruff: noqa: F401` switched off
unused-import detection for all of `__init__`, so a dead import left behind
by a later slice or feature would go unflagged. At this PR's head
`__init__` still reads every name in its import block, so the waiver hid
nothing: `ruff check --select F401` gives 0 findings with it removed. It is
dropped, and the block's comment now says that a name `__init__` stops
reading keeps its line with a per-line waiver naming why (G13, or read as
`oqs.X` from outside). PR2, PR3 and PR4 add those per-line waivers where
their moves leave a name unread.

`deps.py` keeps its file-level waiver: it is a binding module whose
imports are its bindings, so there is no import there F401 could rightly
flag.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HWna79vVmnezQdhpaGRKbw

* lint(operator-queue): per-line F401 waivers for what __init__ stops reading (#3785)

Review I1 on #4036: PR1 dropped `__init__`'s file-level F401 waiver. This
slice's moves leave four of its imports unread in `__init__`; each now
carries its own `noqa: F401` with the reason, so F401 keeps checking every
other line:
- `asyncio`, `base64`, `uuid`: kept for G13, because `listing` and `poller`
  import them at module level.
- `from . import listing`: loads the submodule at its G6 point; the names
  callers read come from the re-export block.

`ruff check --select F services/operator_queue_service/` is clean.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HWna79vVmnezQdhpaGRKbw

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
#2720) (#4185)

The last bare axios call in the composable, voice stop, built its own auth
header. It now uses the shared client, so it follows the interceptor's
token and 401 handling (Invariant #7). The WebSocket URL still takes the
store token, which is a different path.

Closes #2720

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
)

The memory_on fixtures in test_ent1022_retrieval_memory and
test_ent1027_model_gateway stubbed is_loaded and availability but not
last_error, so an embedder error left by an earlier test on the same
worker made status() report memory unavailable. The 1028 fixture got
the same stub in #4145.

Fixes #4137
* docs(readme): link the Trinity 1.0 complete course

Add the 39-chapter complete course video as the first entry under
"Watch more" so new visitors find the end-to-end walkthrough first.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(readme): update Complete Course link to new YouTube id and chapter count

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(readme): update Complete Course YouTube link to re-published video

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
…#1054) (#4195)

OSS half of trinity-enterprise#1054: the terms-gate seam (services/terms_gate.py, consulted in resolve_platform_user_unfloored; @terms_route exemptions), EmailService.send_html on one HTML shell, the /terms SPA view + interceptor, and the entitlement-gated InvitesPanel.

Refs Abilityai/trinity-enterprise#1054

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…and you hear its own reply (trinity-enterprise#1046) (#4194)

* feat(workspace): a Direct call, where every spoken turn goes to the agent and you hear its own reply (trinity-enterprise#1046)

A second call mode beside Live, chosen from the Call control's menu (remembered per
browser; Live stays the default). No model sits in the conversation: the browser
endpoints an utterance, the backend transcribes it, and the browser sends the text
through the same POST .../chat/stream a typed message uses, carrying the call's vd_ id.
The bridge then speaks the agent's reply sentence by sentence.

- Harness-agnostic: every reply is spoken from the persisted row; a runtime whose
  stream carries messages (Claude Code, Codex) only starts sooner, and the unspoken
  tail is reconciled so nothing repeats. Gemini CLI agents work, with a line saying
  replies take about 10 s.
- Agent approvals by voice: an ask the turn raises is read aloud, and a whole-utterance
  yes/no after the prompt has played is posted by the browser on the person's own
  answer route. The socket never answers an ask and never starts a turn.
- Gates: socket owner only (no admin attach); a turn may carry only the caller's own
  live Direct call on this agent and thread (uniform 404); a spoken run must be the
  caller's own execution, including one reached through an approval; one call per
  thread, claimed atomically when the socket opens; a vd_ id never bypasses the Live
  call guard; 30 utterances/min per person.
- Speech providers behind services/speech (Gemini REST STT/TTS, ElevenLabs), chosen in
  Settings (GET/PUT /api/settings/direct-voice, admin, audit-logged).
- The #2694 delta cursor treats a Direct reply as the agent's own session answering.

Measured end to end with real speech: first spoken word 3.4-4.4 s after send on Claude
Code, 10.7-12.0 s on Gemini CLI; STT 1.1-1.9 s.

The speech providers and the bridge were written before their tests. Every gate was
then mutation-checked: 16 backend gates go red when removed, run with bytecode caching
off.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(workspace): two call buttons, and the Live orb in the Direct call's strip (trinity-enterprise#1046)

Operator review of the first build:

- The Call control's mode menu is gone. The composer has two buttons, one per
  call: the Live call (waveform) and the Direct call (handset). Each carries its
  own reason when it is off; while one call is on, its button ends it and the
  other says "Another call is on". Nothing is remembered per browser any more
  (`CALL_MODE_KEY`, `loadCallMode`, `saveCallMode` and `CallModeMenu.vue` are
  removed; `callButtons` is the pure rule).
- The Direct strip's flat pulsing disc is replaced by the Live call's orb in a
  48px disc. The overlay's smoke and core move into `chat/voiceOrbField.js`
  (one renderer, an instance per orb, no module state) and `VoiceOverlay.vue`
  draws through it unchanged. `chat/VoiceOrb.vue` draws the same field clipped
  to a circle on the orb's black ground, so it reads in both themes: 80
  particles, a DPR-capped bitmap, the first frame drawn on mount, one still
  frame under reduced motion, and the core tinted with the state — green
  listening, amber working, blue speaking — because at this size the smoke is
  a rim and cannot carry it. `directOrbState` maps the Direct statuses onto the
  orb's vocabulary.
- While the person talks, the orb moves with their voice: the composable feeds
  the mic RMS into `amplitude` whenever nothing is playing (`rmsOf` is exported
  from the endpointer).

PortalConversation's raw_gray count stays at its baseline: the two buttons
share one class recipe (#2662 arms) instead of repeating it.

Tests: `portalDirectCall.spec.js` covers the button rule, the status→orb map and
the mounted orb (draws, animates, stops on unmount, still under reduced motion);
`portalDirectCall.mount.spec.js` drives both buttons in the real conversation.
Verified in the browser on the local stack, light and dark, Live and Direct.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

* feat(workspace): the Direct call's strip shows four call bars, not a canvas orb (trinity-enterprise#1046)

The strip's mark is now `portal/CallBars.vue`: four rounded bars in a disc
tinted with the status tokens, sitting on the theme's own surface. Green bars
follow the person's mic while it listens, amber bars run a slow wave while the
turn is worked on, blue bars follow the agent's voice while it speaks, and
muted is four flat gray dots. Four elements and no canvas; under
prefers-reduced-motion it holds one still frame per state.

The canvas orb and the field extracted to share with it are gone, so the Live
call's VoiceOverlay.vue is back to dev's version and this PR no longer touches
it.

Tests mount the bars. Each of three mutations turns a test red: ignoring the
sound, ignoring mute, and starting the loop under reduced motion.
`portalUndefinedCalls` now lists `cancelAnimationFrame` as a browser global,
next to `requestAnimationFrame`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(workspace): a Direct call answers a reply it cannot read aloud, and its strip is one quiet row (trinity-enterprise#1046)

A reply that is only code, a table or links had no speakable sentence, so the
call said nothing and looked dead. test-echo's fenced echo hit this on every
turn. A successful reply with nothing to read aloud now gets "The reply is in
the chat." (LINE_REPLY_IN_CHAT); a reply with any spoken sentence does not.

The strip is now one fixed-height row, so the thread below it no longer moves
when the state changes: 32px bars, one short word (Listening, Got it,
Thinking, Speaking, Yes or no?), one detail line (a notice, what was heard,
the tool at work, or the slow-runtime wait), a mic icon that shows a slash
when muted, and a red hang-up handset. The "Direct call · runtime · speech
by …" line and the first-word timing are gone; Esc moves to the hang-up's
tooltip.

Tests written red first: two backend (the in-chat line, and no line when
something was spoken) and four frontend (the detail order, short words, and
the mounted row with icon buttons and a danger-token hang-up).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(workspace): a Direct call reads a reply that is only a code block, instead of pointing at the chat (trinity-enterprise#1046)

test-echo answers with nothing but a fenced block. The previous fix spoke
"The reply is in the chat." for it, which is no answer. When a reply has no
prose outside its code blocks, the text inside the blocks is the reply and is
now read (fence markers and the language tag dropped). Code beside prose
stays unsaid. The in-chat line remains only for a reply with nothing to read
at all, such as a table alone. The rule lives in spoken_text.speakable, so the
streamed speech and the reconciled tail agree and nothing is said twice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Revert "fix(workspace): a Direct call reads a reply that is only a code block, instead of pointing at the chat (trinity-enterprise#1046)"

This reverts commit c214c9e. Operator ruling: a reply that is only a code
block is correctly answered with "The reply is in the chat." Code is not read
aloud, whether or not prose sits beside it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(voice): a Direct call speaks an execution once (trinity-enterprise#1046)

Each speak frame built a fresh SpokenBudget, and only utterances were
rate-limited, so re-sending speak for the same run bought its synthesis
again, up to the call's 30 minutes and across calls. The bridge now claims
an execution before speaking it: Redis SET NX across calls and workers,
plus a per-socket set that holds when Redis cannot answer.

Also pins the store<->backend contract of a Direct call (mode on start,
voice_call_id on a spoken turn, the roster's direct_voice), each of which
could be deleted with every test green.

merge-train 2026-11-02, mechanical per operator ruling at Gate 1.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(voice): stub the Live capability in the one-call-per-thread test (trinity-enterprise#1046)

The live case reached realtime_voice_capability before the cross-kind 409
and got a 503 on a host with no realtime provider key (CI). merge-train.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…(trinity-enterprise#1054) (#4200)

src/backend/enterprise 47cb75a → 452ea04 (Abilityai/trinity-enterprise#1074).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…y-dial

Re-chains the Alembic revision as 0113_seat_ask_class_state on dev's
0112_loop_runs_stale_duplicates (it forked at 0107, leaving two heads).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…e one verb (Abilityai/trinity-enterprise#871) (#4174)

An agent key a grant admits now writes one `capability_used` audit row: the
agent as actor, its key id, the capability, the target, the method and the
endpoint. It is written inside `enforce_agent_capability`, after the owner
bound, so it means the grant cleared the call, not that the change landed, and
a refused call writes only `capability_refused` (a holder aiming outside its
owner's agents included, code `capability_target_not_owned`, same 404). People,
`user` and `system` keys write none. One row per capability and target per
request; manifest deploys and an honoured skill-set probe record their own use.

`skills.manage` grant changes log `capability_grant` / `capability_revoke`
through every door; earlier rows keep `skill_manager_*`.

Security fixes found by `/cso --diff` and review
(docs/security-reports/cso-diff-2026-11-02-871-capability-used.md):
- `owner_owns_agent` now refuses the system agent. Owned by the admin, it was
  reachable by any holder an admin owns, and what lands there runs under a key
  that bypasses every permission check.
- The file routes apply the owner bound, so an edge to another user's agent no
  longer lets a holder write its instructions or skills (now 404).
- The skill-gate map read uses the same bound.
- The create row names the slug the agent would get, not the raw body.

Also: `request_id` on the agent `delete` row; `test_ent1030_gates.py` no longer
reaches the host's Docker. Out of scope: issue item 3 (outcome rows for schedule
writes and the timeout PUT); `trinity_prompt` via create-mode deploy stays #4025.

Fixes Abilityai/trinity-enterprise#871

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
# Conflicts:
#	tests/registry.json
…unt get_autonomy in the MCP docs (ent#641)

Fallout from merging dev:
- test_ent719_self_gate_identity drives every assert_own_agent route with a
  well-formed request. The new GET /seat-autonomy needs an execution_id query
  parameter, like its seat-decision siblings.
- tool-count-docs (ent#991 T5) reads the registered total from the user docs.
  dev's search_memory plus this PR's get_autonomy make 177 tools (172
  operator), and decisions.ts now has 3 tools.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…owner's turn (ent#926)

test_ent1003_gemini_wall_clock and test_ent986_gemini_usage_statistics came in
with the dev merge and drive the Gemini runtime with an execution id. This
branch's tier check asks the platform whose turn it is, and with no platform
to ask it fails closed (503). These tests are about the CLI, not the turn, so
they take the same owner-turn stub the branch's other Gemini tests use
(turn_scope.fetch_turn).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
feat(workspace): the autonomy dial — what a companion may do unprompted (ent#641)
feat(access): hold an agent's turn to what its person may do, and declare every agent route's tier (ent#926)
Re-chains the Alembic revision as 0114_room_participant_visible_from on dev's
0113_seat_ask_class_state (#2984), and orders the SQLite migration after it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
feat(rooms): people in a room — a read floor, leaving, and who is speaking (Abilityai/trinity-enterprise#701)
…ts (Abilityai/trinity-enterprise#660) (#4178)

- Assign skills dialog: text, source and category filters narrow the rows
  and both bulk buttons, never the draft. Each row and a footer count say
  what Save would do: "to add", "to remove", or "kept by set" for a skill an
  assigned set still holds. The list keeps one height while the filter
  narrows, in a panel capped to the window.
- Library and the agent's Skills tab: the lists scroll in a BoundedRegion
  that fills the window, so the page no longer grows with the library. The
  Library gets the same filters and a stated total. On the tab, Own and
  Shared share one box, a total sits in the header, and Shared's heading
  docks to the box from 640 px up.
- BoundedRegion is now `relative`: unpositioned, the cards' sr-only labels
  escaped the box and Chrome counted them in the page height.
- Backend: `category` on SkillInfo, from the skill's frontmatter. No
  migration, no new route, no base-image or MCP change.
- e2e/skills-bounded-lists.spec.js (Chromium, @smoke, hermetic) pins the
  geometry that jsdom and Firefox cannot see.

ent#660 was re-scoped because its text predates ent#754. Edition:
OSS-core, ungated (confirmed on ent#660).

Fixes Abilityai/trinity-enterprise#660
Fixes #3448

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…sus (#4206)

#2984 added GET /api/agents/{agent_name}/seat-autonomy and #3778 added the
census that requires every agent-naming route to declare a tier. They merged
one after the other without seeing each other, so dev fails
test_ent926_agent_route_census::test_every_agent_route_is_declared.

Declared accessor, with a reason, matching its sibling decision routes'
gates (assert_own_agent, then assert_agent_access).

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Motivation: with FRONTEND_URL empty (the .env.example default), the Slack
OAuth callback redirect fell straight to http://localhost, so after
Install to Workspace the admin landed on a dead page even though the install
succeeded. The redirect URI for the same flow is already built from the
Public URL setting.

Approach: get_oauth_callback_redirect now uses FRONTEND_URL if set (unchanged
precedence), else the Public URL setting, and only then the localhost
fallback with the existing error log. This covers the platform and per-agent
success and error redirects, since they share the function.

Validation: ran tests/unit/test_slack_*.py plus the new
tests/unit/test_3563_slack_oauth_redirect_base.py: 227 passed. With the fix
reverted, test_empty_frontend_url_uses_public_url fails; the other two new
tests pass either way. Not run: a live Slack install, and the full unit suite,
which does not collect in my local venv because of missing dependencies.

Report: #3563

Assisted-by: claude-sonnet-5-5 (via Claude Code)

Signed-off-by: Pujitha Paladugu <10557236+pujitha24@users.noreply.github.com>
Co-authored-by: Pujitha Paladugu <10557236+pujitha24@users.noreply.github.com>
Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
obasilakis and others added 26 commits November 13, 2026 20:08
…r wins the status race (#4475) (#4550)

* fix(audit): record a terminate that ended the turn when another writer wins the status race (#4475)

The execution_terminate audit row fired only when the terminate request won
the CANCELLED compare-and-swap. The agent's terminate route waits for the
process to exit before it answers, so the synchronous /task or /chat caller
that started the turn usually writes the terminal status first, and the
terminate wrote no audit row although its kill ended the work. The parked
arm had the same race with the parked dispatcher.

The container arm now records the row when the agent answers `terminated`,
and the parked arm when it finds the turn parked. A Redis first-claim
(terminate_audit:{agent}:{execution_id}, SET NX, 24h) on an id the agent or
the call limiter verified keeps a repeat or concurrent terminate to one row.
It fails open when Redis is unreachable and releases the claim if the audit
write raises. The CAS still decides the status row and the activity close.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(audit): release the terminate audit claim when the audit write fails (#4475)

- The route hook returns platform_audit_service.log's event id; a None
  result releases the terminate_audit claim, so the next terminate
  records the turn. log swallows insert errors, so the raise branch
  alone never fired for the real hook.
- Allowlist the terminate_audit dedupe claim in the #1920 single-flight
  guard (once-guard, 24 h TTL, deleted only on a failed audit write).
- Tests: the Redis claim raising still writes the row; a failed audit
  insert through the real route releases the claim and a repeat writes
  one row.
- Refresh the #3180 test docstrings, the feature-flow Audit Row text and
  Revision History, the CSO report A10 row; register the #4475 test file.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…4536) (#4545)

* fix(wake): park an ending that collides with a running wake's window (#4536)

A delegate->wake loop with a callee faster than 15 s stalled after a few
rounds: the callee's ending landed in the window its own wake had claimed
and was dropped as "already woken in this window".

- A wake releases its 15 s window when it ends, so an ending after a
  finished wake wakes at once.
- An ending that hits a window whose wake still runs collapses into it only
  if the run ended at or before the wake's claim (the sweep storm bound is
  kept). Otherwise it is parked in Redis (trinity:wake_missed:{caller},
  24 h, audited `parked`) and delivered once when the wake ends, on the
  follow-on key caller_wake:{caller}:after:{wake_id}, drained from the
  wake row's own terminal and from the holder after it releases.
- Redis trouble on the park is audited `skipped_window`, never raised.

Tests: tests/unit/test_4536_wake_window.py against the real idempotency
claim and fakeredis. Red with the fix absent (5 of 6, the sweep guard
green on HEAD). Mutations each turn a test red: no terminal drain
(in-flight + follow-on tests), no holder drain (parked-after-terminal),
no coverage rule (sweep), no re-check after park (holder-releases race).

Fixes #4536

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(learnings): a time-bucket dedup key collapses events the holder caused (#4536)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(wake): keep a parked ending across a backend stop and keep the sweep bound (#4536)

- A holder cancelled by a backend stop no longer drains the parked ending;
  the wake row's terminal delivers it after the restart.
- The follow-on key is released when the follow-on ends, so a second ending
  parked on the same wake is delivered.
- The latest claim of a wake whose turn ran is kept in Redis
  (trinity:wake_claimed:{caller}); an ending from before it collapses, so a
  sweep still fanning out after its wake returned is one wake.
- Tests for the cancelled holder, the second drain, the late sweep, the
  _expect_caller guard, the real follow-on spawn, and a holder that raises
  or returns failed. _complete_idempotency had no caller left and is removed.
- Docs: budget sentences back on the #4357 bullet; bound, restart and
  one-marker audit behaviour stated in the requirements and feature flow.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(wake): drop the latest-claim collapse; a closed holder leaves the marker (#4536)

- Remove trinity:wake_claimed:{caller}, _note_claim, _last_claim and the
  pre-claim collapse. An ending collapses only into the wake still running
  in its window. Bound: one running wake plus one pending per caller.
- The holder drains on Exception; GeneratorExit and CancelledError leave the
  marker for the wake row's terminal.
- Tests: a back-dated recovered run, a parked ending drained by a later
  window's wake (failed and completed), a FAILED wake in an earlier window,
  a holder closed mid-wake, a holder raising past the dispatch. Removed the
  test that pinned the dropped rule.
- Docs, module docstring and registry entry describe the current behaviour.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
* fix(channels): B18 fixes — Telegram setup UX (Abilityai/trinity-enterprise#1189)

Fixes found while testing B18.

- Channel config dialog closes when the KeepAlive-cached agent page is
  deactivated, so a link inside it (e.g. to Settings) no longer leaves the
  teleported dialog and its body scroll lock on the next page.
- Telegram webhook warning explains why a public HTTPS address is needed and
  links to Settings > General.
- Verify checks the webhook, not only getMe: it registers a missing webhook
  when a Public URL is set, reports "operational" only when registered, and
  returns Telegram's rejection reason, shown in the warning. The result sits
  inline next to the button and the binding refreshes in place.
- Client roster: fixed widths on the Access and Actions columns so an
  in-flight button or state change does not re-balance the table.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(channels): Telegram Verify reads Telegram's webhook record (Abilityai/trinity-enterprise#1189)

- Verify reads the Public URL through get_public_chat_url_setting(), so a
  row with a trailing host dot is registered without it (#3881).
- Verify calls getWebhookInfo. It re-registers when Telegram holds no
  webhook or one for another URL, and reports not operational when a
  delivery error is outstanding with updates pending.
- GET binding returns webhook_url only under the current Public URL and
  adds public_url_set; the PUT response carries public_url_set too.
- setWebhook, getWebhookInfo and deleteWebhook errors are logged through
  masked_traceback; the bot token stays out of logs and reason strings.
- Panel: the warning follows the Verify result, non-admins are told to ask
  an admin, the set-the-URL advice shows only when no Public URL is set,
  and the Verify result is cleared on connect and disconnect.
- Tests exercise set_webhook and get_webhook_info reason strings and the
  token-free log; feature flow updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…nues (Abilityai/trinity-enterprise#1225) (#4546)

* fix(access): a platform continuation turn stands as the turn it continues (Abilityai/trinity-enterprise#1225)

Four turns the platform dispatches continue another turn's work and carry
nobody on the row: caller_wake, operator_response, operator_ending and
skill_gate. turn_actor rated each a visitor's turn, so the agent's key read
no executions while it ran, a continuation of a shared person's turn got the
shell, and a continuation of a delegated turn lost owner tier.

Each continuation row now names the turn it continues
(schedule_executions.continues_execution_id, nullable, SQLite migration +
Alembic 0124). turn_actor and turn_person rate a continuation trigger as that
turn. The link is written only through turn_tier_service.continuation_origin,
which accepts an id only while it is RUNNING on the same agent and stores the
root of a chain:

- /chat, /task and fan-out callee rows record the caller key's acting turn;
  the wake copies it (ent#1216's _standing_person stays the fallback for a
  callee row with no link);
- a native ask raise records its turn under a platform-only context key
  (stripped from agent-authored context); the answer and ending wakes copy it;
  agent-written context.execution_id is never used;
- a gate request records the requesting agent's turn; the notice copies it;
  DISPATCH_FIELDS freezes the link for an approved replay.

A link that cannot be followed (pruned, another agent's, unreadable, or one
ending over asks raised by different turns) rates (share, person, None): no
shell, no reads. Rows with no link are rated as before.

Tests: tests/unit/test_ent1225_continuation_tier.py (50, real DB, real
admission/wake/resume/raise paths). Mutations: disabling the rule turns 24-29
red, dropping the running check 3, removing each producer hand-off at least 1.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(access): a Workspace-reported resume keeps the Workspace rule; auto-memory and /task gated freeze follow the link (Abilityai/trinity-enterprise#1225)

Review of #4546:
- an answer resume whose result goes into the answering person's Workspace
  chat records no link, so it keeps the Workspace rating (share, person,
  None) instead of the asking turn's owner tier;
- keeps_shared_auto_memory: a linked continuation keeps auto-memory only when
  the continued turn is the owner's own;
- /task's own gate call freezes continues_execution_id like /chat's.

Tests: three new cases in test_ent1225_continuation_tier.py; each goes red
with its fix reverted.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(access): an ask's wake follows the asking turn only for an answerer who may stand as it (Abilityai/trinity-enterprise#1225)

- operator_resume_service._continuation_of: the answer and ending wakes follow
  the link only when the answerer or canceller is owner tier on the agent or
  rates exactly as the asking turn (turn_tier_service.person_may_continue).
  Anyone else, or an unknown answerer, records NO_SINGLE_ORIGIN and rates
  (share, person, None). A platform ending with no person follows the link.
- claim_next_queued RETURNING carries continues_execution_id, so a pulled
  continuation judges auto-memory as the push path does.
- Tests through ask_service.answer / cancel and the wake filer; pull claim;
  file-channel strip of the platform key.
- Docs: auth.md §2.12 answerer rule and Workspace wording; security.md §5d
  answerer rule and the cost of a fail-closed continuation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(access): resolve an ask's answerer by user id for the continuation tier (Abilityai/trinity-enterprise#1225)

The resume of an answered or cancelled ask checks the person who ended it
with person_may_continue. That check matched on email only, so the admin
provisioned from ADMIN_PASSWORD, who has no email on record, failed it on
its own agent and the resume ran as a shared person with no shell.

person_may_continue now takes the user id when the caller has one. The
answer path reads it from the row's responded_by_id; cancel, dismiss and
bulk cancel carry it on EndingEvent.actor_user_id into
maybe_dispatch_ending. Workspace clients have no users row and keep the
email path.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(ent1225): drop the _complete_idempotency stub removed on dev by #4536

The caller wake no longer has _complete_idempotency (#4545), so patching it
raised AttributeError in six continuation-tier tests after merging dev.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…nd Slack (Abilityai/trinity-enterprise#1253) (#4543)

* fix(channels): rate-limit sign-in code emails on Telegram, WhatsApp and Slack

Telegram `/login <email>`, WhatsApp `/login <email>` and the Slack
require_email email step sent a verification email on every request.
Commands reach handle_command straight from the transports, so the
router's per-sender message limit never saw them.

services/channel_login_limit.py caps code requests over 10 minutes:
5 per sender ({channel}:{sender_id}), 3 per address (shared across
channels) and 20 per Telegram bot / WhatsApp binding / Slack workspace,
counted with rate_limiter.check keyed on the input. Adapters call it
after the email-format check and before the ent#849 membership branch.
Over the limit the bot says so, mints no code and sends no email.

The cap never reads email_login_codes: the web login writes rows only
for whitelisted addresses, so a reply derived from them would reveal
whitelist membership. Logs carry a hash of the sender id (a WhatsApp
sender id is a phone number).

tests/unit/conftest.py empties the limiter's in-process buckets before
each test; several files send /login from the same fake sender.

Fixes Abilityai/trinity-enterprise#1253

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(whatsapp): give each /login integration test its own sender number

The module sent /login six times from one number, past the per-sender
cap of 5 per 10 minutes, and the cap lives in Redis, so re-runs within
the window failed sooner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(auth): share the sign-in code address budget across web, MCP and channels

- Web login and MCP inline auth charge the per-address rate_limiter
  bucket the channels use (login_code_email:<email>), before their
  whitelist / known-address check, so the budget is one budget and its
  refusal reveals no membership.
- A channel request refused by a later cap no longer spends the earlier
  ones: rate_limiter.refund removes the recorded hit.
- The in-process fallback is capped at 10,000 keys; keys here are user input.
- Accepted risk documented: one sender can keep a named address from
  receiving a code on every surface (module docstring, security.md, flow doc).
- Current consumers list in security.md updated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(auth): bound the shared sign-in address key and the in-process fallback

- The per-address limiter key holds a sha256 of the stripped, lowercased
  address, so its size is fixed for any input. Web, MCP and the channels
  build it in one function and share the same key for the same address.
- The web login model caps email at 254 characters; a longer address gets
  the route's usual 422 before any budget is charged.
- The in-process fallback caps each key prefix at 10k keys and evicts the
  oldest key of the same prefix, so a flood of login addresses while Redis
  is down cannot evict another limiter's bucket.
- Log the anonymous address with %r on the web and MCP suppression lines.
- Unit test for check + refund through the Redis branch (fakeredis).

Refs Abilityai/trinity-enterprise#1253

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
) (#4561)

A Workspace person who had not accepted the terms got the in-place terms
screen, accepted, and was then told "Couldn't load your agents — Accept
the current terms to continue." beside "No agents shared with you yet".
The accept was recorded (200, created:true), but no roster or chat read
followed it, so every new portal client hit this on their first sign-in.

The cause is an ordering one. `acceptTerms()` cleared `termsRefusal`, the
state `Portal.vue` mounts `PortalTerms` under. The scheduler flush that ran
before `PortalTerms.onAccept()` resumed from its `await` unmounted the
screen, and Vue's `emit()` returns early for an unmounted instance, so the
`accepted` event never reached `bootstrap()`. The roster's refusal message
stayed in `error`, and the chat reads that the gate had refused kept their
failure flag; "Try again" re-read only the roster, so the Inbox still said
it could not refresh the chats until a reload.

The store no longer clears the refusal on accept. The screen stays mounted
until it has emitted, the shell re-bootstraps, and the roster read clears
the refusal on success, so the roster, the thread list and the chat state
are all read again with the accept in place.

The existing specs drove `PortalTerms` alone, or emitted `accepted` by hand
right after clearing the refusal, so none saw the unmount-before-emit
order; three of them asserted the clear itself and now assert the
contract instead. The new mount spec drives `Portal.vue` with the real
`PortalTerms` through a click on Accept against a stub server that refuses
every gated call until the accept is recorded.
* fix(deps): bump Pillow to 13.0.0 in the backend image (Abilityai/trinity-enterprise#1124)

The backend image pinned Pillow 11.1.0. OSV lists 90 advisories against
that version, several of them Critical heap overflows in decoders that
Image.open() reaches with default settings. Every 11.x and 12.x release
is affected: 12.3.0 still carries 62 open advisories, including the
bundled-OpenJPEG write overflow that has been present since 11.1.0.
13.0.0 is the first release that fixes all of them, and OSV lists none
against it.

The exposure matters because the backend now decodes avatar images taken
from template repositories (local templates and GitHub templates), so the
bytes handed to Pillow come from whoever wrote the template.

13.0.0 ships cp313 manylinux_2_28 wheels for both x86_64 and aarch64,
which the trixie base image (glibc 2.41) installs. The only Pillow calls
the backend makes are Image.open, .width/.height, thumbnail with
Image.LANCZOS, and a WebP save; none of them is removed or changed in
12.0 or 13.0 (Image.LANCZOS is one of the constants Pillow restored for
good in 9.4).

The test requirements floor moves with it so CI never resolves an older
Pillow than the image ships.

* test(avatar): decode a real PNG and WebP through the template avatar install

The tests for _install_bundled_avatar_bytes stub both Image.open and
optimize_avatar, so a Pillow upgrade that broke the header read, the
resize or the WebP encoder would leave them green. This test passes real
PNG and WebP bytes (the two formats a template may bundle) through the
function with nothing mocked on the image path, and checks that the file
written is a 512x384 WebP with the source colour.

Checked that it fails when the decoder cannot read the input: restricting
optimize_avatar's Image.open to JPEG turns both cases red with
UnidentifiedImageError.
…e slice (#4505) (#4552)

* fix(rooms): a short gated request is held whatever others wrote in the slice (#4505)

The room wake handed the skill gate one text for the scan, the approver's
card, the 6,000-byte check and the approved run. A long post by another
participant in the unread slice made a short gated request a standing
request_too_long refusal on every wake.

The scan still reads the whole shown slice. The card, the size check and
the approved run now read the posts that themselves invoke a gated skill,
plus the ask answer, passed as gate_replay. enforce cards the scanned text
when that replay misses a skill the scan matched. A too-long refusal whose
gated post is someone else's names that author. Room requesters read
"A person in a room" on the card; the requester kind is unchanged.

Fixes #4505

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): the gate card names each post's sender; the replay fallback is room-only (#4505)

- The room card holds the gated posts and the requester's latest post, each
  line prefixed with its sender as the transcript writes it. An agent's gated
  line reads as the agent's, and the person's own line is on the card and in
  the approved run.
- Room requesters read "A room conversation" on the card.
- enforce drops a replay that misses a matched skill only when
  triggered_by is "room". A /task whose gated name is only in user_message
  keeps its message and system prompt apart.
- A too-long refusal naming another author says to ask again: that post is
  held and the next wake runs without it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): a post's own newlines cannot forge a sender line on the gate card (#4505)

The room's gate card renders posts with _format_card: each post's first
line carries its sender label, and every further line of the post, on any
line break a renderer honours, starts with "  | ". A participant who writes
"\n<person> (human): /pay-invoice ..." inside a post no longer produces a
line that reads as the person's. The card is still the approved run's
message. The agent transcript keeps _format_delta unchanged.

A too-long refusal names another author's gated post only when the
requester's own post is not what overflows: when the others' posts fit by
themselves, the notice says to shorten the request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): an ask answer's own newlines cannot forge a sender line on the gate card (#4505)

The answer to an agent's ask goes on the gate card under the label
`(ask reply): `, and each further line of it carries the `  | `
continuation prefix through `_format_card`, the same path posts take.
No agent name or email starts with "(", so no sender line reads as it.
The responder stays withheld from the agent's message (ent#715); the
approved run equals the card text.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): a gated name only in an ask answer gets the labelled gate card (#4505)

When no post names a gated skill and only the ask answer does,
_room_gate_card now builds the card from the answer under "(ask reply): "
plus the requester's latest post, through _format_card. A newline in the
answer cannot forge a sender line, and the approved run equals the card.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): a room card missing a scanned gated name raises no card (#4505)

When the gate map changes between the room's read and enforce's read, the
room's card text can miss a gated name the scan matched. enforce now refuses
gate_unavailable on that mismatch and raises no approval card, since the raw
scanned text has no sender labels and a post's newline could forge a sender
line on it. The refusal is transient, so the room delivers the post again and
the next wake builds a labelled card. /task replay behaviour is unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): gate card wraps cannot forge a sender line; a redacted name cannot refuse every wake (#4505)

- GatedSkillRequest draws each input line as its own block with a hanging
  indent. A wrapped segment (a long line, a run of spaces) is indented; only
  a real line start sits at the left edge.
- The room card check scans the request through the credential sanitizer, as
  the card is. A gated name the sanitizer redacts is carded redacted and the
  post is held; later asks run.
- A room wake that sends no card text (its own gate-map read failed) is
  refused gate_unavailable, so no card carries the raw unlabelled slice.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): each post is sanitised by itself on the gate card; a card mismatch holds the post (#4505)

- The room card sanitises each post and the ask answer on its own before
  labelling, and is not sanitised again: a credential pattern can no longer
  reach across a line into the next post or its sender label, and Approve
  runs what the approver read.
- The coverage check reads the scanned parts (`REQUEST_PARTS`, popped by the
  backstop) and requires, per gated part, the names that part keeps once
  sanitised by itself (`room_card_misses`).
- A card that misses a required name refuses `room_card_incomplete`, a
  standing refusal, so the room holds the gated posts. A failed room map
  read still refuses `gate_unavailable`.
- Every post of the requester's in the slice is on the card.
- Gate card input lines use a 4ch hanging indent.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(rooms): the requester's old context leaves the gate card first; a context-only gated name is carded (#4505)

- The requester's ungated posts on a room gate card are context. While the
  card is over 6,000 bytes the oldest of them are dropped; gated posts and the
  requester's latest post stay. An old long post to another agent no longer
  makes every short gated ask request_too_long.
- A room wake whose only gated match is in the context text (the waker's
  email) goes to the normal card path, which cards the context lines. A room
  wake that sent no card text while a post names a gated skill still refuses
  gate_unavailable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
#4533)

Pairs trinity#4493 and trinity#4496 with their enterprise halves: task shape
(ent#1232) and project mode (ent#1235).

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
…ilityai/trinity-enterprise#1163) (#4494)

* feat(projects): GitHubService.get_issue and GitHub ref fields on the task tools (Abilityai/trinity-enterprise#1240)

Checkpoint B (platform). GitHubService.get_issue: one GET to
/repos/{o}/{r}/issues/{n} over a bounded client (5 s, one redirect),
GitHubError carries status, reset and rate_limited; network errors never
carry httpx's text. create_project_task gains refs, update_project_task
gains refs_add/refs_remove, and both now forward only the keys they
declare.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(projects): task modal GitHub refs block, read-owners setting, store and docs (Abilityai/trinity-enterprise#1240)

Checkpoint C (platform).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(github): issue reads refuse a redirect off the API origin (Abilityai/trinity-enterprise#1240)

C1: GitHubService.issue_client adds a request hook that raises GitHubError
(status None -> the refs read records "unreachable") when a redirect hop's
scheme, host or port differs from API_BASE's, before that hop is sent, so
the platform token never leaves the API host.

I2: the Projects GitHub owners setting says removing an owner stops new
reads and titles already read stay as last read.

Bumps src/backend/enterprise to 6925b6e (C2 + I1).

Tests: test_redirect_to_another_origin_is_refused_before_it_is_sent and
test_redirect_changing_scheme_or_port_is_refused[x2] — red with the hook
removed, green restored.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(projects): GitHubService.list_sub_issues, a GET-only read of an issue's sub-issues (ent#1163)

One paged GET /repos/{o}/{r}/issues/{n}/sub_issues on the bounded issue
client: 100 per page, the next page requested by number only while GitHub
sends rel="next" (no URL from a response is requested), capped at limit.
Non-200s share get_issue's error mapping (status, reset, rate_limited), now
one helper; a network error never carries httpx's text (#4284).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(projects): import a GitHub epic from the project import dialog (ent#1163)

ProjectImportModal gets one source switch, a radio group: 'From an agent'
(the folder import, unchanged, the default) and 'From a GitHub epic' (one
field for owner/repo#N or the issue link, pre-validated with a named
error and an example, and a note that it is a one-time copy that writes
nothing back to GitHub). A clean import opens the project; one that left
sub-issues out, hit the 100 cap, could not link a task or met nested
sub-issues names them first. Server refusals show inline in their own
words. store.importEpic posts { epic } to /import/epic and refreshes the
list. The projects user guide gains a paragraph.

Mounted vitest spec workspaceProjectsEnt1163.mount.spec.js (10 tests,
all red against the previous modal and store).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(github): a non-JSON 200 from an issue read raises GitHubError(status=200) (ent#1163 review I2)

get_issue and list_sub_issues called response.json() bare, so a proxy's
HTML page answering 200 surfaced as a ValueError no caller maps, and the
import route answered a bare 500. Both now raise GitHubError with
status=200, which callers already map to 'unreachable'.

Red before the fix: test_a_non_json_200_is_a_github_error_with_status_200
(both parametrizations, JSONDecodeError).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(enterprise): pin the submodule to the ent#1163 branch tip f8bd5a2 (Abilityai/trinity-enterprise#1163)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(projects): an imported epic begins Not started, its open sub-issues to do (ent#1163)

Review C2/W1 on the user doc: the import creates a not_started project and
open sub-issues import as todo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
A github: template that ships avatar.png/webp had the file installed but
never stamped as the agent's avatar, so avatar_url stayed null and every
surface showed initials. After a successful install, record it as a
default avatar seeded with the template's own avatar_prompt (from the
template.yaml the create already reads), or a generic prompt when it
declares none. A failed install is not stamped.
…yai/trinity-enterprise#1105) (#4492)

* feat(executions): attribution seam — record at every creation site, explicit project_id checked first (Abilityai/trinity-enterprise#1105)

An edition may attribute an execution to a project. The platform side is an
inert seam, services/execution_attribution.py:

- every create_task_execution( site offers its row to record_row right after
  it exists: /chat, /task, execute_task, both Workspace turn sites, loop
  iterations, fan-out children (project resolved once at request time and
  carried, since children are created when a slot frees), the skill-gate
  replay, and the scheduler's row in the internal execute-task route;
- the public link, external A2A and brain-orb postprocess turns are untagged
  by design, allowlisted with a reason;
- a request naming project_id on /chat, /task or /fan-out is checked via
  dependencies.check_requested_project before admission, any claim or row;
  with no attributor registered it is 422 project_attribution_unavailable;
- GET /api/agents/{name}/executions/{id} carries project_id from annotate;
  record and annotate fail open;
- MCP chat_with_agent and fan_out take an optional project_id, forwarded and
  keyed only when set; get_execution_result passes project_id through when
  present.

Census guard tests/unit/test_1105_execution_attribution.py walks the platform
backend (rglob) and fails on an unrecorded creation site or a stale allowlist
entry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(projects-ui): Runs tab and list_project_executions MCP tool (Abilityai/trinity-enterprise#1105)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(executions): gate replay carries the frozen project; a failed explicit attribution says so (Abilityai/trinity-enterprise#1105)

Review I1, (b) and (c) of the planned attribution paths (plan §2.2 rules 2-3).

(b) Skill-gate replay. A hold on /chat (admit_chat_request), on /task
(dispatch_parallel_task) and on a fan-out subtask (via gate_replay) now
freezes the project resolved while the requesting turn runs into the gate
record's `dispatch` (`skill_gate_service.frozen_project`: `project_id`, plus
`project_requested` when the request named it). `_dispatch_approved` records
the approved run with it: as the explicit claim when the request named it,
otherwise as inherited. Inert in OSS, where resolve returns None and nothing
is frozen.

(c) Honest status. `record_row` now reports FAILED for a named project that
passed `check` and was then not recorded (the write raised, or the
record-time re-assert no longer held). /chat and /task record inline, so the
outcome rides a per-request ContextVar (reset by `check`) to the router,
which answers `project_attribution: "failed"` (`execution_attribution.report`).
Fan-out answers it on `FanOutResponse` when the named project did not
resolve at request time, or when a sync batch's subtask record failed.

(a) Loop iterations are NOT built. The loop record (`agent_loops`) has no
project column and no free-form field, so storing the project resolved at
loop start needs an OSS schema migration, which has not been ruled.
Iterations still record from their own row only.

Mutation check: each wiring line was reverted on its own and a named test went red:
- the chat/task router `report` → test_{chat,task}_route_answers_failed_…[False];
- the chat/task hold `frozen_project` → test_a_held_{chat,task}_freezes_…;
- the fan-out gate_replay project → test_a_fan_out_subtask_hands_its_project_to_the_gate;
- the child failure append → test_a_fan_out_subtask_whose_record_failed_marks_the_batch;
- the router FAILED → test_fan_out_answers_failed_when_the_named_project_did_not_resolve;
- the replay `requested` → test_the_approved_replay_records_the_frozen_project[frozen1];
- the seam's unrecorded → FAILED → test_an_explicit_request_that_was_not_recorded_is_failed.

Known gap: an Idempotency-Key replay of /chat or /task returns the stored
snapshot, which does not carry the field.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(mcp): list_project_executions task_id takes up to 64 chars, the backend's bound (Abilityai/trinity-enterprise#1105)

Review I4. The tool had `max(16)` while the route has
`Query(max_length=64)`. The new test (64 accepted, 65 refused) went red
against max(16).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(ent875): census the internal execute_task attribution read (ent#1105)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* chore(1105): pin enterprise to b01cee0c7 (#1247 head re-pin)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
…o a card waits for (Abilityai/trinity-enterprise#1096) (#4559)

* feat(asks): admin decider seat on gate approvals + stamped re-address (Abilityai/trinity-enterprise#1096, C1)

The decider order (primary → owner → instance admin) had no answering path
for its third arm: a gate approval with an empty snapshot waited on nobody.
OSS sink half:

- R1: a gate raise may address nobody only with the platform's new
  `workspace_decider_seat = admin` stamp (a `_PLATFORM_CONTEXT_KEYS` member,
  stripped from agent content).
- R8: `may_end`'s admin arm decides a stamped, empty gate approval only for
  a principal passing the admin gate and the person rule; `addressed_view`
  reports the same answer plus `waiting_on_seat` on stamped rows.
- R4: `readdress_item` compares stamps, a None stamp removes its key; an
  `actor` makes the audit row carry the admin and `has_reason`.
  `ADMIN_READDRESSED` joins the readdress reasons.
- R5: answer/cancel on a seat-fenced row compare the stored address in the
  CAS; a lost compare is `AskConflict("readdressed")`.
- R6: `bulk_cancel` skips fenced rows the actor is not addressed on
  (`Ending.skipped_fenced`).
- R7: `AskNotAddressee` carries `waiting_on`/`seat`; the message names the
  person for gate approvals only; role refusals stay person-free.
- R9: the admin arm records `admin:<username>` for an admin with no email.
- Resolver registry (`register_readdress_resolver`) for platform families
  under `gate-`; R12 docstring on `readdress_role`.

Tests: tests/unit/test_1096_admin_seat_fence.py (62); the ent#715 reader
table classifies the two new row readers.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(operator-queue): admin /readdress, reason-required cancel, named refusals (Abilityai/trinity-enterprise#1096, C2)

- POST /api/operator-queue/{id}/readdress {to: rule|admin, reason}:
  require_admin + require_person (grant-vs-use: human-only), row visibility
  as the read's, `ask_service.admin_readdress` re-runs the rule that raised
  the card (registered family resolver, or the role) or takes a registered
  family's gate approval to the admin seat (R2/T2, no person picker; a
  skill-gate approval is refused the admin seat, T3). 409
  audience_unchanged names who it waits for; 422 unknown_family.
- /cancel: an admin ending a fenced card they are not on must give a
  reason (422 reason_required, `AskReasonRequired` in the sink).
- /bulk-cancel returns `skipped_fenced` (R6).
- 403 not_addressee on Operations and Workspace carries `seat` and, except
  on role refusals (the ent#1042/#1053 "never a person" contract),
  `waiting_on`; admin verbs on Operations only (R11). An ending that lost
  to a re-address is 409 `readdressed` (people named on Operations only).
- R14: `# mcp:` header names readdress as a human-only admin verb.

Re-pinned in this checkpoint: test_ent751_gate_dispatch (admin cancel now
needs a reason), test_ent611_ask_endings (bulk body gains skipped_fenced),
test_ent715_queue_person_fields (new door + readers classified).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(operator-queue): the not-addressee notice shows who the card waits for (Abilityai/trinity-enterprise#1096, C3)

The server's 403 `not_addressee` now names the seat and the person
(C2). `notAddresseeMessage(err)` prefers `detail.message` and keeps the
generic line when the server sends none (an older backend); the desktop
store keeps it beside `notAddresseeItemId` for QueueCard, and /m uses it
directly. One string path, no new component; raw-color counts unchanged
(QueueCard 28/59/0, MobileAdmin 0/4/130 — equal to the baseline).

Re-pinned: mobileAdminNotAddressee.spec (the server's message, plus the
fallback case); queueCardNotAddressee.spec gains the named and fallback
mount cases; new operatorQueueNotAddressee.spec for the helper.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(asks): a role row's 409 readdressed body names its role, never a person (Abilityai/trinity-enterprise#1096, M1)

readdressed_detail built its message from waiting_on for every seat-fenced
row, so a role, approver or project row's 409 named people and carried
waiting_on, while the same row's 403 stays person-free. It now returns the
AskNotAddressee.detail shape for those rows: the role message and seat, no
waiting_on, no email. New role:cfo case in test_1096_admin_seat_fence was
red before the change (waiting_on present, email in the message).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* test(operator-queue): pin the address clause of the ending compare-and-set (Abilityai/trinity-enterprise#1096, S1)

No test reached the window the CAS exists for: a re-address landing after
the service read the address and before the ending's UPDATE. Two db-level
tests take the expectation the service builds, move resolved_to while
addressed_to_email stays NULL ([alice,bob] -> [alice,carol]), then call
respond_to_operator_queue_item / cancel_operator_queue_item with
expect_address: each returns _status_conflict and the row stays pending.

Mutation: dropping resolved_to from the respond CAS turns
test_an_answer_read_before_the_move_does_not_land red; dropping it from the
cancel CAS turns test_a_cancel_read_before_the_move_does_not_land red. Both
reverted byte-identical.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(asks): a re-address resolver prefix that could start a skill-gate id is refused (Abilityai/trinity-enterprise#1096, L1)

admin_readdress looks a registered resolver up before the skill-gate shape,
so a prefix of hex digits only (gate-a...) would match gate-<40 hex> ids
and let to: admin put a skill-gate approval on the admin seat. The
registration now raises ValueError for any prefix fully matching
gate-[0-9a-f]*. New parametrized test was red (DID NOT RAISE) before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix(asks): admin re-address refuses a failing or empty rule with 409 rule_refused (Abilityai/trinity-enterprise#1096, L3)

admin_readdress trusted the registered family rule: a resolver that raised
surfaced as a 500, and one that returned a primary or owner seat with no
people wrote a card nobody could decide. Both now return 409 rule_refused
and leave the row untouched; only the admin seat may be empty. Two new route
tests (raising rule; primary/owner seat with nobody) were red before (an
uncaught RuntimeError, and 200 instead of 409).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* merge-train: shorten the decider-seat key comment so operator_queue_service/__init__.py is back at the 800-line cap (#4559)

test_3785's size threshold failed the regression diff at 804 lines. Comment only; no code change.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

---------

Co-authored-by: Trinity Agent (trinity) <trinity-agent@ability.ai>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
…rinity-enterprise#1098) (#4581)

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
… the primary, else the owner, else refused by name (#4579) (#4580)

A credential ask is addressed to a person who can open its secret field: the primary when they are on the agent's roster, else the owner, else a named refusal (role_cannot_open_agent). Both re-address arms follow the same rule.

Fixes #4579
… column (#4597) (#4598)

The project page header stacks at every width. On desktop the action buttons are their own right-aligned, wrapping row above the title, so the title, goal and role line use the full reading width.

Fixes #4597
Delta sync of docs/user-docs/ against dev since the last full review (2026-10-20): one new page (agents/agent-memory.md), 78 pages updated, FAQ index regenerated. Docs only.
VERSION 1.0.5-rc2 -> 1.0.5-rc3; trinity-do-create.sh default TRINITY_IMAGE_TAG -> v1.0.5-rc3. Not a release: no issues close on this tag.
main carries 7 commits that are not ancestors of dev: the ent#1117 security
back-ports (#4291, #4294, #4314, #4315, #4399, #4400) and the llms.txt refresh
(#4287). Every one of them is already on dev in its original form, so this is a
merge with dev's tree kept as-is (strategy ours). It records main as a parent so
the dev -> main release PR no longer conflicts.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
… image (#4483) (#4602)

After an upgrade, agents keep the image they were started from until their
next cold start (#1809, unchanged), and only trinity-system said so. Agent-side
fixes in a release were silently inert on every agent nobody stopped.

- services/fleet_image_service.py: reads the fleet through the tri-state
  agent_container_states(), compares each running, non-ephemeral agent with
  check_base_image_state, and keeps ONE platform alert
  (fleet_base_image_stale:fleet) naming the stale agents. It updates as the
  set changes and ends when a pass proves every agent current. The same alert
  is raised when trinity-agent-base:latest's version label is older than the
  backend, with the command for a source and for a hosted install.
- Docker unreadable, a failed comparison or a base image with no parseable
  version label is "could not check": nothing is filed and nothing is ended.
- Read-only: no container is stopped, started or recreated. Leader-leased
  (fleetimage:leader, fail-open), first pass 25s after boot, then every 10 min.
- 409 env_unreadable (credential sink, Nevermined delegation) names the older
  agent image and the restart when the agent's read answer has no `missing`
  list.
- upgrading.md: agents must be restarted to receive agent-side changes; the
  base image is rebuilt when anything under docker/base-image/ changed.

Mutation check: with each of these reverted, tests in
tests/unit/test_4483_fleet_base_image_check.py went red and were restored
byte-identical — Docker-unreadable read as an empty fleet
(test_docker_unreadable_is_could_not_check), ephemeral or system agent not
excluded (test_ephemeral_stopped_and_system_agents_are_left_out), unknown
readings allowed to clear (test_an_agent_whose_comparison_failed_is_neither_
stale_nor_current), the main.py start call removed
(test_main_starts_the_loop_with_the_watch_loops), the lease ignored
(test_a_worker_that_does_not_hold_the_lease_runs_nothing), the old-image
wording dropped (test_env_unreadable_on_an_old_image_names_the_image_and_the_
restart).

Fixes #4483

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
Moves src/backend/enterprise from dd84ab4 to a26e522, which adds the
Abilityai/trinity-enterprise#1091 fix (enterprise PR #1273): a person's
task events share one pending Inbox item.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Bumps VERSION and the DigitalOcean installer's default image tag to
v1.0.5-rc4 so the release candidate tag can be cut from dev.

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
…e project tools

Two user-doc pages listed the Workspace project tools among the tools an
admin's `user` key can call on behalf of an agent. That part is not in
v1.0.5: act-as covers asks, reports, metrics, objectives and the canvas
tools. The pages now say so, and say that a project-tool request carrying
`agent_name` from an admin's key is refused.

Docs only; no code or behaviour change.

Refs abilityai/trinity-enterprise#1189 (row B10)

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
docs(user-docs): an admin's key acting for an agent does not cover the project tools
chore: reconcile main into dev ahead of release v1.0.5
… README (#4615)

* chore: set version to 1.0.5

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

* docs(learnings): fold fragments into the ledger for 1.0.5

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

* docs(releases): add v1.0.5 release notes, What's New page and llms.txt refresh

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

* docs(releases): v1.0.5 README banner; SQLite move is a recommendation; private module items counted, not listed

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

---------

Co-authored-by: trinity-ability <309458136+trinity-ability@users.noreply.github.com>
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
@vybe
vybe merged commit 87e21ff into main Nov 17, 2026
47 of 48 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

10 participants