diff --git a/app/lib/features/chat/domain/chat_commands.dart b/app/lib/features/chat/domain/chat_commands.dart
index c4fafe3f..b274c8af 100644
--- a/app/lib/features/chat/domain/chat_commands.dart
+++ b/app/lib/features/chat/domain/chat_commands.dart
@@ -160,10 +160,11 @@ const String chatRenameUsageReport =
'Usage: /rename
— renames this session.';
/// The line the fresh conversation opens on after `/new`: the chat is the
-/// same, the agent's context is empty.
+/// same, the agent's context is empty, and the server has already stopped the
+/// replaced session's agent and background work before it answered.
const String chatNewSessionNotice =
'New session started. The agent no longer sees the earlier conversation; '
- 'the previous session can still be resumed in a terminal.';
+ 'the previous session was stopped.';
/// The line a conversation opens on when another device started its new
/// session.
diff --git a/app/test/features/chat/domain/chat_commands_test.dart b/app/test/features/chat/domain/chat_commands_test.dart
index e1d11d30..464a5590 100644
--- a/app/test/features/chat/domain/chat_commands_test.dart
+++ b/app/test/features/chat/domain/chat_commands_test.dart
@@ -94,4 +94,15 @@ void main() {
'“/close” is not available yet, so nothing was sent to the agent.',
);
});
+
+ test('the /new notice says the replaced session was stopped', () {
+ // The server releases the old harness session before it answers, so the
+ // notice must not suggest it is still running or resumable.
+ expect(
+ chatNewSessionNotice,
+ 'New session started. The agent no longer sees the earlier '
+ 'conversation; the previous session was stopped.',
+ );
+ expect(chatNewSessionNotice, isNot(contains('resume')));
+ });
}
diff --git a/docs/chat-backends.md b/docs/chat-backends.md
index e595e19c..7134fc7f 100644
--- a/docs/chat-backends.md
+++ b/docs/chat-backends.md
@@ -231,11 +231,15 @@ and with the same title. OpenCode makes a new `ses_` session, Codex a new thread
and Claude Code a new session UUID. The server then re-keys the
`operator_sessions` row in one transaction. The new row keeps the title,
directory, tag, backend, colour, star, creation time, model override and mode.
-The old row is not deleted: it records `replaced_by`, is no longer listed, and
-its native session can still be resumed in a terminal. Before the row is moved,
-the server releases the old native runtime; this stops active/background work
-without deleting the native transcript. If release fails, `/new` reports an
-error and leaves the registry row on the old session.
+The old row is not deleted: it records `replaced_by` and is no longer listed.
+Before the row is moved, the server releases the old native runtime, the same
+release chat close uses, so `/new` never leaves the replaced session running:
+Claude Code's host and CLI exit (including a registered host this server is not
+attached to), a Codex thread's turn is interrupted and the thread is
+unsubscribed so the App Server unloads it, and OpenCode's turn and running
+shells are stopped (the shared OpenCode service itself has no per-session
+process). The native transcript is kept on disk. If release fails, `/new`
+reports an error and leaves the registry row on the old session.
The row is re-keyed rather than mapped from a stable id because every other
layer is keyed by the native id: rooms, queues, transcripts, shells, exports and
diff --git a/internal/claude/claude.go b/internal/claude/claude.go
index ff58d953..57a3e8a9 100644
--- a/internal/claude/claude.go
+++ b/internal/claude/claude.go
@@ -510,7 +510,8 @@ func (s *session) releaseIdleProcess() {
}
}
-func (s *session) closeProcess() {
+// closeProcess stops the session's CLI and reports whether one was attached.
+func (s *session) closeProcess() bool {
s.mu.Lock()
p := s.proc
s.proc = nil
@@ -518,6 +519,7 @@ func (s *session) closeProcess() {
if p != nil {
p.close()
}
+ return p != nil
}
// findTranscriptFile locates the CLI's session file. Project directories are
diff --git a/internal/claude/hosted.go b/internal/claude/hosted.go
index bf284c13..f67eb1b3 100644
--- a/internal/claude/hosted.go
+++ b/internal/claude/hosted.go
@@ -647,14 +647,63 @@ func (c *Chat) Detach() {
}
// ReleaseSession stops a session's CLI (and its host) for an explicit operator
-// close. The transcript stays; a later prompt resumes it.
+// close or /new. The transcript stays; a later prompt resumes it. A host still
+// registered for the session that this server holds no connection to (a
+// reattach that failed, or one left by an earlier server) is stopped too, so a
+// release never leaves a Claude Code process running behind the chat.
func (c *Chat) ReleaseSession(_ context.Context, id string) error {
- if s := c.session(id); s != nil {
- s.closeProcess()
+ if s := c.session(id); s != nil && s.closeProcess() {
+ return nil
}
+ c.stopUnattachedHost(id)
return nil
}
+// stopUnattachedHost asks the host registered for id to stop its CLI and exit,
+// then kills whatever is left of it (KillStale only signals processes whose
+// command line names this session) and removes its files.
+func (c *Chat) stopUnattachedHost(id string) {
+ if c.hostDir == "" || id == "" {
+ return
+ }
+ data, err := os.ReadFile(claudehost.PathsFor(c.hostDir, id).Record)
+ if err != nil {
+ return
+ }
+ var record claudehost.Record
+ if json.Unmarshal(data, &record) != nil || record.SessionID != id {
+ claudehost.Remove(c.hostDir, id)
+ return
+ }
+ if conn, err := claudehost.Dial(record.Socket, time.Second); err == nil {
+ closed := make(chan struct{})
+ go func() {
+ defer close(closed)
+ if conn.Send(claudehost.Frame{Op: claudehost.OpClose}) != nil {
+ return
+ }
+ for {
+ frame, err := conn.Recv()
+ if err != nil || frame.Op == claudehost.OpClosed {
+ return
+ }
+ }
+ }()
+ select {
+ case <-closed:
+ case <-time.After(8 * time.Second):
+ }
+ _ = conn.Close()
+ // The host exits right after OpClosed; give it a moment before the
+ // fallback signals below.
+ deadline := time.Now().Add(2 * time.Second)
+ for time.Now().Before(deadline) && claudehost.ProcessMatches(record.HostPID, record.SessionID) {
+ time.Sleep(50 * time.Millisecond)
+ }
+ }
+ claudehost.KillStale(c.hostDir, record)
+}
+
// ProbeTurn reports whether a turn is in flight, after a reattached host's
// replay has rebuilt the session, so a turn that survived a restart is
// observed and notifies.
diff --git a/internal/claude/hosted_test.go b/internal/claude/hosted_test.go
index a861e6cb..ce86188b 100644
--- a/internal/claude/hosted_test.go
+++ b/internal/claude/hosted_test.go
@@ -353,6 +353,39 @@ func TestReleasingAHostedChatStopsItsHost(t *testing.T) {
}
}
+// /new and close release a session even when this server never attached to
+// its host (a failed reattach, or a host left by an earlier server): the
+// registered host is stopped rather than left running until it idles out.
+func TestReleasingAnUnattachedHostedChatStopsItsHost(t *testing.T) {
+ fixture := hostedSetup(t)
+ first := hostedChat(t)
+ session := newCreatedChat(t, first)
+ frames := subscribe(t, first, session.ID)
+ if err := first.Prompt(context.Background(), session.ID, "hello"); err != nil {
+ t.Fatal(err)
+ }
+ waitStepEnded(t, frames)
+ record := onlyRecord(t, fixture)
+ first.Detach()
+ if !alive(record.HostPID) {
+ t.Fatal("a detached host must keep running")
+ }
+ // A server without the reattach pass holds no connection to the host.
+ second := newChat(context.Background())
+ t.Cleanup(second.Close)
+ if second.session(session.ID) != nil {
+ t.Fatal("the second server must not be attached to the host")
+ }
+ if err := second.ReleaseSession(context.Background(), session.ID); err != nil {
+ t.Fatal(err)
+ }
+ eventually(t, "the unattached host to exit", func() bool { return !alive(record.HostPID) || isZombie(record.HostPID) })
+ eventually(t, "the CLI to exit", func() bool { return !alive(record.ClaudePID) || isZombie(record.ClaudePID) })
+ if records := claudehost.Records(fixture.hostDir); len(records) != 0 {
+ t.Fatalf("a released host must remove its registry record: %+v", records)
+ }
+}
+
func TestHostStatusReportsRegistryAndPrivateSocket(t *testing.T) {
fixture := hostedSetup(t)
chat := hostedChat(t)
diff --git a/internal/codex/chat.go b/internal/codex/chat.go
index 9e3cf060..3785b3c9 100644
--- a/internal/codex/chat.go
+++ b/internal/codex/chat.go
@@ -554,16 +554,28 @@ func (c *Chat) StopTasks(context.Context, string) (int, error) {
return 0, errors.New("Codex does not expose a separate background-task stop operation")
}
-// ReleaseSession stops an active Codex turn while preserving the thread and
-// its transcript. Codex has no separate per-thread process to reap.
+// ReleaseSession stops a Codex thread for an explicit close or /new: it
+// interrupts an active turn, then unsubscribes this connection so the App
+// Server unloads the thread (and its live runtime) once no other client holds
+// it. The persisted thread and transcript stay; a later prompt reloads it
+// through the "thread not found" resume path in PromptWithMessageIDModel.
func (c *Chat) ReleaseSession(ctx context.Context, id string) error {
c.mu.Lock()
turn := c.turns[id]
c.mu.Unlock()
- if turn == "" {
+ if turn != "" {
+ if err := c.Interrupt(ctx, id); err != nil {
+ return err
+ }
+ }
+ _, err := c.call(ctx, "thread/unsubscribe", map[string]any{"threadId": id})
+ var refused *rpcCallError
+ if errors.As(err, &refused) && refused.Code == -32601 {
+ // An App Server without thread/unsubscribe keeps the thread loaded;
+ // the interrupt above already stopped its work.
return nil
}
- return c.Interrupt(ctx, id)
+ return err
}
// Create starts one Codex thread in directory.
diff --git a/internal/codex/detach_test.go b/internal/codex/detach_test.go
index 74b5b9c8..920215aa 100644
--- a/internal/codex/detach_test.go
+++ b/internal/codex/detach_test.go
@@ -46,3 +46,59 @@ func TestDetachLeavesTurnRunningForNextConnection(t *testing.T) {
}
}
}
+
+// Releasing a thread (chat close or /new) interrupts its turn and then
+// unsubscribes, so the App Server unloads the replaced thread instead of
+// keeping it loaded indefinitely.
+func TestReleaseSessionInterruptsAndUnloadsThread(t *testing.T) {
+ var mu sync.Mutex
+ var methods []string
+ var unsubscribed string
+ appServer := func(method string, params json.RawMessage) any {
+ mu.Lock()
+ defer mu.Unlock()
+ methods = append(methods, method)
+ if method == "thread/unsubscribe" {
+ var body struct {
+ ThreadID string `json:"threadId"`
+ }
+ _ = json.Unmarshal(params, &body)
+ unsubscribed = body.ThreadID
+ return json.RawMessage(`{"status":"unsubscribed"}`)
+ }
+ return json.RawMessage(`{}`)
+ }
+ c := modelTestChat(t, appServer)
+ c.mu.Lock()
+ c.turns[fixtureThread] = "turn"
+ c.mu.Unlock()
+ if err := c.ReleaseSession(context.Background(), fixtureThread); err != nil {
+ t.Fatal(err)
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ if len(methods) != 2 || methods[0] != "turn/interrupt" || methods[1] != "thread/unsubscribe" || unsubscribed != fixtureThread {
+ t.Fatalf("release must interrupt then unsubscribe the thread: %v (%q)", methods, unsubscribed)
+ }
+}
+
+// An idle thread is still unloaded, and an App Server that predates
+// thread/unsubscribe does not make the release fail.
+func TestReleaseSessionUnloadsIdleThreadAndToleratesOldServers(t *testing.T) {
+ var mu sync.Mutex
+ var methods []string
+ c := modelTestChat(t, func(method string, _ json.RawMessage) any {
+ mu.Lock()
+ defer mu.Unlock()
+ methods = append(methods, method)
+ return &rpcError{Code: -32601, Message: "method not found"}
+ })
+ if err := c.ReleaseSession(context.Background(), fixtureThread); err != nil {
+ t.Fatalf("an unsupported unsubscribe must not fail the release: %v", err)
+ }
+ mu.Lock()
+ defer mu.Unlock()
+ if len(methods) != 1 || methods[0] != "thread/unsubscribe" {
+ t.Fatalf("an idle release must only unsubscribe: %v", methods)
+ }
+}