fix(core): cancel a session's background shell jobs on interrupt

packages/core/src/job.ts

@@ -130,6 +130,11 @@ export type BackgroundAllInput = {
   type?: string
 }
 
+export type CancelAllInput = {
+  sessionID: SessionSchema.ID
+  type?: string
+}
+
 export interface Interface {
   readonly get: (id: string) => Effect.Effect<Info | undefined>
   readonly start: (input: StartInput) => Effect.Effect<Info>
@@ -138,6 +143,7 @@ export interface Interface {
   readonly background: (id: string) => Effect.Effect<Info | undefined>
   readonly backgroundAll: (input: BackgroundAllInput) => Effect.Effect<Info[]>
   readonly cancel: (id: string) => Effect.Effect<Info | undefined>
+  readonly cancelAll: (input: CancelAllInput) => Effect.Effect<Info[]>
   readonly pendingBackground: Effect.Effect<readonly Background[]>
   readonly runningBackground: Effect.Effect<readonly Recovery[]>
   readonly completeBackground: (notificationID: SessionMessage.ID) => Effect.Effect<void>
@@ -445,6 +451,28 @@ export const make = Effect.gen(function* () {
     return result.info
   })
 
+  const cancelAll: Interface["cancelAll"] = Effect.fn("Job.cancelAll")(function* (input) {
+    const owned = yield* SynchronizedRef.modifyEffect(
+      state.jobs,
+      Effect.fnUntraced(function* (jobs): Effect.fn.Return<readonly [string[], Map<string, Active>]> {
+        const ids: string[] = []
+        for (const [id, job] of jobs) {
+          if (job.info.status !== "running") continue
+          if (input.type !== undefined && job.info.type !== input.type) continue
+          if (job.info.metadata?.sessionID !== input.sessionID) continue
+          ids.push(id)
+        }
+        return [ids, jobs]
+      }),
+    )
+    const cancelled: Info[] = []
+    for (const id of owned) {
+      const info = yield* cancel(id)
+      if (info) cancelled.push(info)
+    }
+    return cancelled
+  })
+
   const pendingBackground: Interface["pendingBackground"] = Effect.gen(function* () {
     const recovered: Background[] = []
     let after: string | undefined
@@ -486,6 +514,7 @@ export const make = Effect.gen(function* () {
     background,
     backgroundAll,
     cancel,
+    cancelAll,
     pendingBackground,
     runningBackground,
     completeBackground,

packages/core/src/session/execution.ts

@@ -125,7 +125,12 @@ export const layer = Layer.effect(
             }
             if (outcome.type === "interrupted") {
               // Deliberate stops release the claim; shutdown keeps it for restart continuity.
-              if (outcome.reason !== "shutdown") yield* jobs.cancel(sessionID)
+              if (outcome.reason !== "shutdown") {
+                // A session running as a subagent job is keyed by its own id; owned
+                // background work (shell, image) carries the session in job metadata.
+                yield* jobs.cancel(sessionID)
+                yield* jobs.cancelAll({ sessionID })
+              }
               yield* bus.publish(
                 SessionEvent.Execution.Interrupted,
                 { sessionID, reason: outcome.reason },

packages/core/test/job.test.ts

@@ -450,4 +450,61 @@ describe("Job", () => {
       expect((yield* jobs.get(job.id))?.status).toBe("running")
     }),
   )
+
+  it.live("cancels running jobs owned by the session and leaves foreign work alone", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const owner = SessionSchema.ID.make("ses_owner")
+      const other = SessionSchema.ID.make("ses_other")
+      const latch = yield* Deferred.make<void>()
+      const finish = Deferred.await(latch).pipe(Effect.as("done"))
+      const owned = yield* jobs.start({
+        id: "job_owned_shell",
+        type: "shell",
+        metadata: { sessionID: owner },
+        run: finish,
+      })
+      const foreign = yield* jobs.start({
+        id: "job_foreign_shell",
+        type: "shell",
+        metadata: { sessionID: other },
+        run: finish,
+      })
+      const unowned = yield* jobs.start({ id: "job_unowned", type: "test", run: finish })
+
+      const cancelled = yield* jobs.cancelAll({ sessionID: owner })
+
+      expect(cancelled.map((info) => info.id)).toEqual([owned.id])
+      expect(yield* jobs.get(owned.id)).toMatchObject({ status: "cancelled" })
+      expect(yield* jobs.get(foreign.id)).toMatchObject({ status: "running" })
+      expect(yield* jobs.get(unowned.id)).toMatchObject({ status: "running" })
+      yield* Deferred.succeed(latch, undefined)
+      expect((yield* jobs.wait({ id: foreign.id })).info).toMatchObject({ status: "completed" })
+      expect((yield* jobs.wait({ id: unowned.id })).info).toMatchObject({ status: "completed" })
+      expect((yield* jobs.wait({ id: owned.id })).info).toMatchObject({ status: "cancelled" })
+    }),
+  )
+
+  it.live("filters cancelAll by job type", () =>
+    Effect.gen(function* () {
+      const jobs = yield* Job.Service
+      const owner = SessionSchema.ID.make("ses_filter")
+      const latch = yield* Deferred.make<void>()
+      const finish = Deferred.await(latch).pipe(Effect.as("done"))
+      yield* jobs.start({ id: "job_filter_shell", type: "shell", metadata: { sessionID: owner }, run: finish })
+      const image = yield* jobs.start({
+        id: "job_filter_image",
+        type: "image",
+        metadata: { sessionID: owner },
+        run: finish,
+      })
+
+      const cancelled = yield* jobs.cancelAll({ sessionID: owner, type: "image" })
+
+      expect(cancelled.map((info) => info.id)).toEqual([image.id])
+      expect(yield* jobs.get("job_filter_shell")).toMatchObject({ status: "running" })
+      yield* Deferred.succeed(latch, undefined)
+      expect((yield* jobs.wait({ id: "job_filter_shell" })).info).toMatchObject({ status: "completed" })
+    }),
+  )
 })

packages/tui/src/config/index.tsx

@@ -267,6 +267,7 @@ export type Resolved = Omit<Info, "attention" | "cursor" | "keybinds" | "leader"
   keybinds: TuiKeybind.BindingLookupView
   leader: { timeout: number }
   mouse: boolean
+  animations: boolean
   cursor?: {
     style: "block" | "underline" | "line" | "default"
     blinking: boolean
@@ -315,6 +316,7 @@ export function resolve(
     }),
     leader: { timeout: input.leader?.timeout ?? 2000 },
     mouse: input.mouse ?? true,
+    animations: input.animations ?? (options.environment ?? process.env).HERDR_ENV !== "1",
     cursor: input.cursor
       ? {
           style: input.cursor.style ?? "block",

packages/tui/test/config-v2.test.tsx

@@ -91,6 +91,15 @@ test("resolves automatic tabs from the terminal environment", () => {
   ).toMatchObject({ mode: "on", enabled: true })
 })
 
+test("resolves animations off by default inside herdr panes", () => {
+  expect(resolve({}, { terminalSuspend: true, environment: {} }).animations).toBe(true)
+  expect(resolve({}, { terminalSuspend: true, environment: { HERDR_ENV: "1" } }).animations).toBe(false)
+  expect(resolve({ animations: true }, { terminalSuspend: true, environment: { HERDR_ENV: "1" } }).animations).toBe(
+    true,
+  )
+  expect(resolve({ animations: false }, { terminalSuspend: true, environment: {} }).animations).toBe(false)
+})
+
 test("shows resolved tab defaults in settings", () => {
   expect(settings.find((setting) => setting.path.join(".") === "tabs.mode")).toMatchObject({
     default: "auto",

packages/tui/test/mini/footer.view.test.tsx

@@ -1930,7 +1930,7 @@ test.each([8, 12])("production footer grows for wrapped instructions in %i rows"
 test("an oversized queue shortcut prevents backfilling shorter work and identity hints", async () => {
   const app = await renderFooter({
     width: 32,
-    tuiConfig: createTuiResolvedConfig({ keybinds: { "session.queued_prompts": "ctrl+shift+alt+q" } }),
+    tuiConfig: createTuiResolvedConfig({ animations: false, keybinds: { "session.queued_prompts": "ctrl+shift+alt+q" } }),
     queuedPrompts: [{ messageID: "queued", prompt: { text: "later", parts: [] }, delivery: "queue" }],
     subagents: {
       tabs: [subagent({ sessionID: "s-1", label: "Explore", description: "Inspect" })],