[philazar]

Goose agents can now run their turns through the agent gateway, the way Claude Code agents do in the base branch. Goose's gateway opt-in stays behind GATEWAY = false in src/bundled/goose/index.ts until a pinned goose (v1.57.0) has run forwarded turns end to end. The flag gates only that opt-in. The shared changes below ship either way:

• the ACP load, hold and control seams;
• the shared forwarding opener;
• the native child registration command;
• the goose transcript's fallback-notice handling.

This PR is stacked on the Claude Code forwarding branch and contains only the goose work and the shared seams it needs.

What changes

Native: child rendezvous (src-tauri/src/host_forward.rs)

• goose's delegate subagents call the model under their own session id, which a generation doesn't know yet. Those requests now wait, bounded, until the goose caller registers the child for that generation.
• Then they pass through with their own session header unchanged.
• An unknown session is still refused after at most one bounded wait, and at once when the generation is sealed, closed or revoked.
• The wait can only reject, never admit: 5 pending requests per generation, 5 s each, capped children and calls.
• plugin_host_forward_register_child is the only new command.

Shared ACP seams (src/features/agent-harness/acp/)

• Opt-in session/load in AcpProcess.open.
• A conversation can be held for handoff work. Holds queue behind a session left running, with a start deadline that only bounds waiting and never cancels accepted work.
• A session's value is saved with it, and New session is confirmed as saved before the live session is dropped, so a failed save leaves it in place.
• A null session/load answer reads as no settings.
• An optional observe callback on AcpSession, which changes nothing when unset. One that throws is logged, and the update is still handled.

Shared forwarding opener (src/features/agents/gateway/forwarding.ts)

• The opener is now shared by the Claude Code and goose callers.

goose caller (src/bundled/goose/)

• Process per turn. Each forwarded turn gets its own generation and its own goose-acp, started on the generation URL. Nothing is retried.
• Session. The conversation's saved goose session is resumed with its saved binding, or the turn fails visibly. It never quietly falls back to a new session or to the user's own configuration.
  • goose v1.57.0 keeps the provider a session was saved with. So a resumed session's first turn sets the chosen provider again with set_config_option, and fails visibly if goose refuses.
  • A forwarded conversation keeps resuming its saved session after the agent's instructions, team or memory change, until New session; an ordinary session reopens instead. Each turn sets the current system prompt on the resumed session. This is deliberate for now and can be revisited after live acceptance.
• Retirement. Every exit retires the turn in order: seal, interrupt, close, stop. The generation closes only after the process has exited. Agent retirement waits for its forwarded turns; a turn that won't stop is reported and keeps its owner. The conversation waits only for the process to exit. If native can't close a generation, that turn and the agent's retirement fail, but the conversation's later turns still run.
• Delegates. delegate children are registered from the prompt's own tool calls (forward-children.ts), matched on _meta.goose.toolCall.toolName, because goose adds the source to the title. A registration failure is shown on the turn.
  • Forwarded spawns pin GOOSE_SUBAGENT_PROVIDER (and GOOSE_SUBAGENT_MODEL when the turn names a model), so neither the model's delegate arguments nor goose config can move a child off the gateway. A recipe's own goose_provider still wins (goose summon.rs resolve_provider_config); recipes are rare, and this was accepted.
• Compact. Compact on a forwarded session runs through the gateway, or is refused with the reason.
• Pool and records. Forwarded processes count in the shared process pool until they close. A new forwarded session's prompt is recorded like any other.
• Fallback notice.
  • Once goose runs through the gateway, a plugin, watch or timer wake in a conversation that ran without it shows "Ran without the agent gateway" beside its prompt in Activity. Standalone runs (runOnce) show none.
  • goose v1.57.0 returns no id for the prompt Buzz sends. So the wake's prompt ends with a Buzz-owned <buzz-turn id="…"/> mark that names the turn, and the transcript matches the mark to goose's own message.
  • The mark is read only at the very end, or just before the steer note Buzz adds. It is hidden from the transcript even after the notice is gone. Any <buzz-turn in text Buzz didn't write is escaped, so it can't be forged.
  • Notices are kept per agent, in memory, and capped at 100. They clear when the agent retires successfully; a failed retirement keeps them with the agent. A reload or compaction loses them (docs/buzz-help.md, docs/configuration.md).
• Shared helper. withNotices moved to src/features/agents/activity-transcript.ts, and both callers now use it.

Validation

Done, at eca0231c1 (review fixes on top of 7a66492c1):

• Focused Vitest over src/features/agent-harness, src/bundled/goose, src/bundled/claude-code and src/features/agents: 110 files passed, 4 skipped; 2,370 tests passed, 13 skipped.
• tsc is clean, and biome check --error-on-warnings . reports no errors or warnings.
• cargo test --lib host_forward: 25 passed. Only doc comments changed in Rust.
• Each review fix has a regression test that fails without the fix and passes with it:
  • the delegate env pin;
  • provider reapplied on load, and a visible failure when goose refuses;
  • a delegate titled delegate · <source>;
  • later turns run after a failed native close;
  • New session ordering;
  • a throwing observe;
  • a null load answer.
• Earlier, at 7a66492c1: the native rendezvous unit tests and mutation checks on the retirement, deadline, pool, prompt-record and notice paths, each caught by a test. One deadline mutation made the reserve wait loop forever, so that check fails as a hang rather than an assertion.
• Source review of every slice by a second agent, and a four-slice review at 7a66492c1.

Not done yet:

• Live acceptance with pinned goose v1.57.0, which is required before GATEWAY can be turned on. It covers:
  • continuity, reload, reset and compaction;
  • loading a session created outside the gateway;
  • interrupt and retirement;
  • two delegates whose requests reach the gateway only after registration, with their session headers unchanged;
  • the fallback notice in Activity.
• Decide how forwarded goose spawns source the provider token. Today they set only DATABRICKS_HOST. This blocks turning GATEWAY on.
• Full app suite, full native test suite and native build in CI.
• A person trying it in the app.

Unresolved before acceptance, from the pinned-goose acceptance plan:

• Ordering evidence. Showing that a child's requests reach upstream only after it is registered needs a correlated timeline:

  • the native registration (insertion and wake under the generation lock);
  • native admission events;
  • upstream session headers.

  RPC-return timestamps or gateway logs alone can't prove that order, and the app doesn't log these events today.

• Token policy. Covered by the provider-token item above. It is still open before activation.

• Gateway listing. The gateway's descriptor and access check must list the goose harness.

• Stuck retirement. The case where a forwarded goose won't stop is covered by unit tests only.

• Ordinary → forwarded load. Resuming a session created outside the gateway needs a successful continuity run. A visible refusal shows only that it fails safely, not that it works.

• Windows. No Windows acceptance yet.

🤖 Generated with Claude Code