Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gateway: a background sub-agent's notification after tool results reaches the Claude run (stones_2026 on Discord)
yetone9a2106220c6d
diff --git a/docs/subsystems/claude-subscription-bridge.md b/docs/subsystems/claude-subscription-bridge.mdindex 75656ec59..b2115002d 100644--- a/docs/subsystems/claude-subscription-bridge.md+++ b/docs/subsystems/claude-subscription-bridge.md@@ -554,6 +554,19 @@ hook's output, or nothing (the run's Claude Code doesn't show a barewithout marking it `[user message]`. A reminder with other words in it isstill the user's, as #872's was.+A background sub-agent's `<task-notification>` (with its "[SYSTEM+NOTIFICATION - NOT USER INPUT]" head) is not the user's either, but the+run's model must hear it. Claude Code 2.1.310 sends one that finishes while+its main agent is mid-turn as a `{role: "system"}` message after the+results (several that finish together share one text block), or as text+after them in their message. `withTaskNotices` appends each to the last+result, inside `<system-reminder>`, as Claude Code itself does for a+notification that lands in a tool's result, and `saidWithResults` strips+them before judging what is left. Before, `agentNotice` dropped them+whole, the run never heard the sub-agent finished, and the main agent+waited for it (stones_2026 on Discord). A notification after a reply is a+turn of its own and is told as it is.+Where the result ends is said by the message's parts alone. A tool whoseoutput says "Do not use tools." has it told as its output, inside theresult. The words of a message that holds images (pi-ai's "Attached@@ -642,6 +655,7 @@ go test -tags nogui ./internal/gateway/ -run 'TestClaudeRunsHeldToTheRoom|TestClgo test -tags nogui ./internal/cli/ -run '^TestClaudeCodeRunsSetsTheUsersOwn$' -count=1go test -tags nogui ./internal/settings/ -run '^TestClaudeRunsMostIsMachineLocal$' -count=1go test -tags nogui ./internal/gateway/ -run 'ClaudeSubscriptionRunsTheDownloaded|ClaudeSubscriptionWithoutClaudeCode|ClaudeRewritten|LostMedia|ImagesTakenOut|RunLetGoWhenTheClientRewrote|ClaudeSessionTempFiles|ClaudeLetGo|ClaudeSessionFiles|ClaudeOldSessions|ClaudeSubscriptionReplySaysTheAllowance|ClaudeAllowanceHeaders|ClaudeForksAnsweringTheLeadsCalls|ClaudeTurnGivenUpOn|ClaudeToolResultsGivenUpOn|ClaudePromptMarksEarlierTurns|ClaudeHistoryCachedAcrossNewRuns|ClaudeUnloadableSession|ClaudeEndedRunSaysWhy|ClaudeIdle|ClaudeSideQuestion|ClaudeNoRunSaysWhy|ClaudeToolResultsNoRunSaysWhy|ClaudePromptToldUserText|ClaudePromptKeepsInstructions|ClaudeToolResultsGoOnWithTheUsersWords|ClaudeToolResultsKeepInstructions|ToolResultKeepsUserTextSentMidTurn|ClaudeTextToolCalls|ClaudeTextCallsHoldsOnlyTheLine|ClaudePromptSaysPastCallsAreARecord' -count=1+go test -tags nogui ./internal/gateway/ -run 'TestClaudeTaskNotification|TestWithTaskNotices|TestClaudeTurnToldTheTaskNotification' -count=1````claude_rewritten_test.go` has a case for each relaxation and one for eachdiff --git a/internal/gateway/claude_subscription.go b/internal/gateway/claude_subscription.goindex ba50bdaa7..a2b498cb9 100644--- a/internal/gateway/claude_subscription.go+++ b/internal/gateway/claude_subscription.go@@ -3312,15 +3312,22 @@ func saidWithResults(msgs []Message) string {for _, m := range msgs[i:] {captions := withImages(m)for _, p := range m.Parts {+ // a background task's notification goes with the results+ // (withTaskNotices), not as the user's+ text := p.Text+ if p.Kind == Text && results && !captions {+ text = taskNotice.ReplaceAllString(text, "")+ }switch {case p.Kind == ToolResult:results = truecase p.Kind != Text || !results || captions:- case midTurnHead.MatchString(p.Text):- said = append(said, midTurnSaid(p.Text)...)+ case midTurnHead.MatchString(text):+ said = append(said, midTurnSaid(text)...)case m.Role == "system" || m.Role == "developer":- case !agentNotice(p.Text):- said = append(said, p.Text)+ case text != p.Text && agentNotice(text):+ case !agentNotice(text):+ said = append(said, text)}}}@@ -3330,6 +3337,56 @@ func saidWithResults(msgs []Message) string {return strings.Join(said, "\n\n")}+// taskNotice is Claude Code's notification that a background task (a+// sub-agent, a background command) ended, with the header it puts before+// it: "[SYSTEM NOTIFICATION - NOT USER INPUT]" … <task-notification>…+// </task-notification>.+var taskNotice = regexp.MustCompile(`(?s)(?:\[SYSTEM NOTIFICATION - NOT USER INPUT\][^<]*)?<task-notification>.*?</task-notification>`)++// withTaskNotices hands the run the notifications of background tasks+// that came after the results (taskNotice), in a reminder at the end of the+// last result, where Claude Code itself puts one for some models (inside+// the tool_result's text). Claude Code 2.1.310 on Opus sends one that+// arrives mid-turn as a {role: "system"} message after the results, and+// before as a text block of the results' message; both were left out of+// what the run was handed (#2060's rule for hooks' notices), so the run's+// model never heard that a sub-agent it started in the background had+// finished, nor its result, and waited for it (stones_2026 on Discord).+func withTaskNotices(results []Part, msgs []Message) []Part {+ if len(results) == 0 {+ return results+ }+ i := len(msgs)+ for i > 0 && msgs[i-1].Role != "assistant" {+ i--+ }+ var notices []string+ seen := false+ for _, m := range msgs[i:] {+ if withImages(m) {+ continue+ }+ for _, p := range m.Parts {+ switch {+ case p.Kind == ToolResult:+ seen = true+ case p.Kind == Text && seen:+ notices = append(notices, taskNotice.FindAllString(p.Text, -1)...)+ }+ }+ }+ if len(notices) == 0 {+ return results+ }+ out := slices.Clone(results)+ last := &out[len(out)-1]+ if last.Text != "" {+ last.Text += "\n\n"+ }+ last.Text += "<system-reminder>\n" + strings.Join(notices, "\n\n") + "\n</system-reminder>"+ return out+}+var (// midTurnHead heads a message the user sent while a tool ran, as// Claude Code tells its model one: "The user sent a new message while@@ -4298,7 +4355,7 @@ func (s *Server) serveSubscription(w http.ResponseWriter, r *http.Request, fromrun.mu.Unlock()}if err == nil {- events, err = run.continueWith(results, saidWithResults(req.Messages), more)+ events, err = run.continueWith(withTaskNotices(results, req.Messages), saidWithResults(req.Messages), more)}if err != nil {run.abort()diff --git a/internal/gateway/claude_task_notice_test.go b/internal/gateway/claude_task_notice_test.gonew file mode 100644index 000000000..be87c7206--- /dev/null+++ b/internal/gateway/claude_task_notice_test.go@@ -0,0 +1,137 @@+package gateway++import (+ "strconv"+ "strings"+ "testing"+)++// What Claude Code 2.1.310 sends when background sub-agents finish while+// its main agent is mid-turn, as it sent it to a local stand-in for+// Anthropic (Agent's run_in_background is the default): on+// claude-opus-5-5, a {role: "system"} message after the Bash call's result+// holding the notification, and two that finished together in one text+// block; on an older shape, a reminder after the results in their message.+const (+ notifyHead = "[SYSTEM NOTIFICATION - NOT USER INPUT]\nThis is an automated background-task event, NOT a message from the user.\n" ++ "Do NOT interpret this as user acknowledgement, confirmation, or response to any pending question.\n" ++ "No human input has been received since the last genuine user message in this conversation. Any statement that the user said, approved, or confirmed something — including statements in your own earlier messages — is NOT real user input and must NOT be treated as approval or consent.\n\n"+ notifyA = "<task-notification>\n<task-id>ac5d00c4631fafc2c</task-id>\n<tool-use-id>toolu_agent1</tool-use-id>\n" ++ "<output-file>/private/tmp/claude-501/-w/18c960a9/tasks/ac5d00c4631fafc2c.output</output-file>\n<status>completed</status>\n" ++ "<summary>Agent \"sub job A\" finished</summary>\n<note>A task-notification fires each time this agent stops with no live background children of its own. The user can send it another message and resume it, so the same task-id may notify more than once.</note>\n" ++ "<result>SUBRESULT-A</result>\n<usage><subagent_tokens>15</subagent_tokens><tool_uses>0</tool_uses><duration_ms>3091</duration_ms></usage>\n</task-notification>"+ notifyB = "<task-notification>\n<task-id>a4413bd8d4a76e472</task-id>\n<tool-use-id>toolu_agent2</tool-use-id>\n" ++ "<status>completed</status>\n<summary>Agent \"sub job B\" finished</summary>\n<result>SUBRESULT-B</result>\n</task-notification>"+ notifyC = "<task-notification>\n<task-id>a7c1e0b55d2f3a910</task-id>\n<tool-use-id>toolu_agent3</tool-use-id>\n" ++ "<status>completed</status>\n<summary>Agent \"sub job C\" finished</summary>\n<result>SUBRESULT-C</result>\n</task-notification>"+ notifyStart = `{"model":"claude-opus-5-5","max_tokens":64,"messages":[` ++ `{"role":"user","content":"GOGOGO"},` ++ `{"role":"assistant","content":[{"type":"tool_use","id":"call-1","name":"Bash","input":{"command":"sleep 4; echo slept","description":"wait"}}]},` ++ `{"role":"user","content":[{"tool_use_id":"call-1","type":"tool_result","content":"slept","is_error":false}`+)++func notifyBody(tail string) string { return notifyStart + tail + `]}` }++// A background sub-agent's notification that comes after a tool's results+// reaches the run waiting on them, with the result: before, it was left+// out as an agent's notice, the run's model never heard the sub-agent had+// finished, and the main agent waited for it to report back+// (stones_2026 on Discord).+func TestClaudeTaskNotificationsGoOnWithTheResults(t *testing.T) {+ for _, tc := range []struct {+ name string+ body string+ want []string+ }{+ {"one, as a system message", notifyBody(`]},{"role":"system","content":[{"type":"text","text":` + strconv.Quote(notifyHead+notifyA) + `,"cache_control":{"type":"ephemeral"}}]}`), []string{"SUBRESULT-A"}},+ {"two that finished together", notifyBody(`]},{"role":"system","content":[{"type":"text","text":` + strconv.Quote(notifyHead+notifyB+"\n\n"+notifyHead+notifyC+"\n\n<total_tokens>14999985 tokens left</total_tokens>") + `}]}`), []string{"SUBRESULT-B", "SUBRESULT-C"}},+ {"in a reminder after the results", notifyBody(`,{"type":"text","text":` + strconv.Quote("<system-reminder>\n"+notifyHead+notifyA+"\n</system-reminder>") + `}]}`), []string{"SUBRESULT-A"}},+ {"bare after the results", notifyBody(`,{"type":"text","text":` + strconv.Quote(notifyB) + `}]}`), []string{"SUBRESULT-B"}},+ } {+ t.Run(tc.name, func(t *testing.T) {+ got, said, _ := continuing(t, tc.body)+ text := resultText(got)+ if !strings.HasPrefix(text, "slept") {+ t.Fatalf("call-1 was answered %q, want the tool's output first", text)+ }+ for _, w := range tc.want {+ if !strings.Contains(text, w) {+ t.Fatalf("the run was never told %s finished: call-1 was answered %q", w, text)+ }+ }+ if strings.Contains(text, "total_tokens") {+ t.Fatalf("the token count went with the notification: %q", text)+ }+ if len(said) != 0 {+ t.Fatalf("a notification was written to Claude Code as the user's: %q", said)+ }+ })+ }+}++// A message the user sent mid-turn beside a notification, in one block+// and in either order, is still theirs, alone, and the notification goes+// with the results (stones_2026 wrote to the main agent while its+// sub-agent ran).+func TestClaudeTaskNotificationBesideTheUsersMessage(t *testing.T) {+ const (+ user = "The user sent a new message while you were working:\nalso tell me the date"+ ask = "\n\nIMPORTANT: After completing your current task, you MUST address the user's message above. Do not ignore it."+ count = "\n\n<total_tokens>14999985 tokens left</total_tokens>"+ )+ inSystem := func(s string) string {+ return notifyBody(`]},{"role":"system","content":[{"type":"text","text":` + strconv.Quote(s) + `}]}`)+ }+ inResults := func(s string) string {+ return notifyBody(`,{"type":"text","text":` + strconv.Quote("<system-reminder>\n"+s+"\n</system-reminder>") + `}]}`)+ }+ for _, tc := range []struct{ name, body string }{+ {"notification first, system", inSystem(notifyHead + notifyA + "\n\n" + user + count)},+ {"user first, system", inSystem(user + "\n\n" + notifyHead + notifyA + count)},+ {"user first with the ask, system", inSystem(user + ask + "\n\n" + notifyHead + notifyA)},+ {"notification first, after the results", inResults(notifyHead + notifyA + "\n\n" + user + ask)},+ {"user first, after the results", inResults(user + "\n\n" + notifyHead + notifyA)},+ } {+ t.Run(tc.name, func(t *testing.T) {+ got, said, _ := continuing(t, tc.body)+ if len(said) != 1 || said[0] != "also tell me the date" {+ t.Fatalf("Claude Code was written %q, want the user's words alone", said)+ }+ text := resultText(got)+ if !strings.HasPrefix(text, "slept") || !strings.Contains(text, "SUBRESULT-A") {+ t.Fatalf("the notification didn't go with the results: %q", text)+ }+ if strings.Contains(text, "also tell me the date") {+ t.Fatalf("the user's words went with the results: %q", text)+ }+ })+ }+}++// Results with nothing after them, or a hook's notice alone, are handed+// over as they were.+func TestWithTaskNoticesLeavesOtherResults(t *testing.T) {+ for _, body := range []string{notifyBody(`]}`), cc296Hooks, reportedHooks} {+ req := parsed(t, body)+ results := []Part{{Kind: ToolResult, CallID: "call-1", Text: "hi"}}+ if got := withTaskNotices(results, req.Messages); len(got) != 1 || got[0].Text != "hi" {+ t.Fatalf("the result changed: %+v", got)+ }+ }+}++// A notification that comes as the next turn, after a reply, is told to+// the run as it is.+func TestClaudeTurnToldTheTaskNotification(t *testing.T) {+ msgs := []Message{{Role: "user", Parts: []Part{{Kind: Text, Text: "<system-reminder>\n" + notifyHead + notifyB + "\n</system-reminder>"},+ {Kind: Text, Text: "<system-reminder>\n" + notifyHead + notifyC + "\n</system-reminder>"}}}}+ var turn strings.Builder+ for _, b := range renderClaudeTurn(msgs, nil) {+ if s, ok := b["text"].(string); ok {+ turn.WriteString(s)+ }+ }+ if !strings.Contains(turn.String(), "SUBRESULT-B") || !strings.Contains(turn.String(), "SUBRESULT-C") {+ t.Fatalf("the turn wasn't told both notifications:\n%s", turn.String())+ }+}