fix: address codex review round 2

- Wire the control service and send_message tool into every shipped
  composition with a resumable provider and background enabled
  (headless-agent, tui-agent, and the SDK helper's subagent feature
  base resources); jsonrpc-agent disables background and is unchanged.
- Resolve the send_message availability check in the CALLER's tool
  scope so a restriction that removes the follow-up tool from one
  agent also blocks that agent's continuable start.
- Control-service disposal now cancels live activations and awaits
  producer settlement instead of stranding them: TaskService keeps
  producer Tasks across a reload, so the disposing service aborts each
  activation-owned controller, resolves its terminal gate (the
  effect-scoped onTaskDone listener is already gone), and awaits done.
  A new test kills a mid-start activation through HMR disposal.

packages/subagent/subagent-control/src/index.ts

@@ -86,6 +86,10 @@ interface ActiveActivation {
   taskId: TaskId | undefined
   /** Filled when the provider publishes; `undefined` while starting or resuming. */
   run: SubagentRun | undefined
+  /** The activation-owned cancellation authority, created before any await. */
+  readonly controller: AbortController
+  /** The producer's settlement (run disposed, outcome produced); assigned when the Task registers. */
+  done: Promise<TaskOutcome> | undefined
   /** Resolved by the completion listener when the Task's terminal snapshot is recorded. */
   readonly terminal: PromiseWithResolvers<void>
 }
@@ -164,7 +168,21 @@ export class SubagentControlService extends Service {
         if (activation.taskId === snapshot.id) activation.terminal.resolve()
       }
     })
-    ctx.effect(() => () => { this.activations.clear() }, 'subagentControl.activations()')
+    // TaskService deliberately keeps producer Tasks alive across a
+    // control-surface or producer reload, so this service's disposal must not
+    // strand the activations it can no longer route to: cancel each one and
+    // await producer settlement (run disposal) before releasing the map. The
+    // effect-scoped onTaskDone listener above is already gone by then, so
+    // terminal publication is resolved here instead of waiting forever.
+    ctx.effect(() => async () => {
+      const active = [...this.activations.values()]
+      this.activations.clear()
+      for (const activation of active) {
+        activation.controller.abort('subagent control service disposed')
+        activation.terminal.resolve()
+      }
+      await Promise.allSettled(active.map(activation => activation.done ?? Promise.resolve()))
+    }, 'subagentControl.activations()')
   }
 
   /**
@@ -368,6 +386,8 @@ export class SubagentControlService extends Service {
     const activation: ActiveActivation = {
       taskId: undefined,
       run: undefined,
+      controller: new AbortController(),
+      done: undefined,
       terminal: Promise.withResolvers<void>(),
     }
     this.activations.set(childId, activation)
@@ -378,21 +398,21 @@ export class SubagentControlService extends Service {
         label,
         owner,
         run: (): TaskHooks => {
-          const controller = new AbortController()
           const done = (async (): Promise<TaskOutcome> => {
             try {
-              const run = await begin(controller.signal)
+              const run = await begin(activation.controller.signal)
               activation.run = run
               return await settleRun(run)
             } catch (error: unknown) {
               // A pre-publication abort rejects only after the provider's
               // creation transaction rolled back to quiescence, so recording
               // `killed` here honors the settlement-after-rollback contract.
-              return controller.signal.aborted
+              return activation.controller.signal.aborted
                 ? { status: 'killed' }
                 : { status: 'failed', detail: String(error) }
             }
           })()
+          activation.done = done
           void Promise.allSettled([done, activation.terminal.promise]).then(() => {
             /* v8 ignore else -- service teardown clears the map while a producer is still settling. */
             if (this.activations.get(childId) === activation) this.activations.delete(childId)
@@ -401,7 +421,7 @@ export class SubagentControlService extends Service {
             cancel: (reason?: string) => {
               // Cancellation targets the whole activation: every message that
               // joined this turn shares the `killed` outcome.
-              controller.abort(reason ?? 'subagent activation killed')
+              activation.controller.abort(reason ?? 'subagent activation killed')
             },
             done,
             // No readOutput: the child session owns intermediate detail.