@@ -591,7 +591,7 @@ export const makeWith = (binder: Binder) =>
     })
 
     const settle = Effect.fn("BackgroundJob.settle")(
-      function* (id: string, token: object, sequence: number, exit: Exit.Exit<SequenceOutcome, unknown>) {
+      function* (id: string, token: object, exit: Exit.Exit<SequenceOutcome, unknown>) {
         const completed_at = yield* Clock.currentTimeMillis
         // Publishing swaps the ledger gate; the fresh gate is made before the lock so the committed
         // modification stays pure.
@@ -734,13 +734,12 @@ export const makeWith = (binder: Binder) =>
       scope: Scope.Scope,
       id: string,
       token: object,
-      sequence: number,
       run: Effect.Effect<SequenceOutcome, unknown>,
     ) {
       return yield* run.pipe(
         Effect.matchCauseEffect({
-          onSuccess: (outcome) => settle(id, token, sequence, Exit.succeed(outcome)),
-          onFailure: (cause) => settle(id, token, sequence, Exit.failCause(cause)),
+          onSuccess: (outcome) => settle(id, token, Exit.succeed(outcome)),
+          onFailure: (cause) => settle(id, token, Exit.failCause(cause)),
         }),
         Effect.asVoid,
         Effect.forkIn(scope, { startImmediately: true }),
@@ -786,19 +785,6 @@ export const makeWith = (binder: Binder) =>
       return result.info
     }, Effect.uninterruptible)
 
-    /**
-     * Releases a reserved-but-unarmed extension coordinate. Pending is returned to its prior value
-     * so the lifetime can still settle. The sequence number itself is spent - coordinates are
-     * monotonic and gaps are legitimate.
-     */
-    const unreserve = Effect.fn("BackgroundJob.unreserve")(function* (id: string, token: object) {
-      yield* SynchronizedRef.update(state.jobs, (jobs) => {
-        const job = jobs.get(id)
-        if (!job || job.token !== token) return jobs
-        return new Map(jobs).set(id, { ...job, pending: Math.max(0, job.pending - 1) })
-      })
-    })
-
     const list: Interface["list"] = Effect.fn("BackgroundJob.list")(function* () {
       return Array.from((yield* SynchronizedRef.get(state.jobs)).values())
         .map(snapshot)
@@ -963,7 +949,7 @@ export const makeWith = (binder: Binder) =>
 
           if (!armed) return yield* restore(Deferred.await(registration.arm))
 
-          yield* fork(registration.scope, id, registration.token, 0, restore(input.run))
+          yield* fork(registration.scope, id, registration.token, restore(input.run))
           const outcome: ArmOutcome = { info: armed.info, lifetime, handle: armed.handle }
           yield* Deferred.succeed(registration.arm, outcome).pipe(Effect.ignore)
           return outcome
@@ -1036,7 +1022,25 @@ export const makeWith = (binder: Binder) =>
             Effect.onExit((exit) =>
               Exit.isSuccess(exit) && exit.value !== undefined
                 ? Effect.void
-                : unreserve(input.lifetime.id, result.token).pipe(Effect.ignore),
+                : // This reserved coordinate lost admission, so nothing will ever run for it.
+                  // Returning `pending` alone left the lifetime `armed`/`running` at `pending: 0`
+                  // with nothing remaining to settle it whenever the owner sequence had already
+                  // settled successfully — a permanent strand. It hung any blocked synchronous
+                  // caller (`done` resolves only at disposition), discarded the owner's completed
+                  // answer (moving it into the terminal Info is itself a disposition step), and
+                  // withheld the terminal that releases a child Task session's attachment scope.
+                  // The refusal therefore settles as a sequence with NO outcome: `undefined` is a
+                  // legal SequenceOutcome, so nothing files, an already-successful owner answer
+                  // still disposes through its inline slot, and the status is `completed` — the
+                  // FOLLOW-UP was refused and its own caller learns that from its own result,
+                  // while the run's own work demonstrably succeeded; marking the job `error` would
+                  // emit an error envelope for a lifetime that did not fail.
+                  // `settleAdmissibility` covers the hazards for free: a replaced lifetime is
+                  // `foreign_token`, an already-terminal one `not_running`, and a concurrent second
+                  // refusal `not_running` — each a no-op. With other sequences still registered,
+                  // settle's `pending > 0` branch keeps the lifetime alive exactly as the bare
+                  // decrement did.
+                  settle(input.lifetime.id, result.token, Exit.succeed(undefined)).pipe(Effect.ignore),
             ),
           )
 
@@ -1045,7 +1049,7 @@ export const makeWith = (binder: Binder) =>
           // An accepted supplemental run registers and runs without waiting for any previous run's
           // tail: the serial hold is gone, so several runs on one lifetime can be in flight at once
           // and their answers are ordered by position at delivery rather than by execution.
-          yield* fork(result.scope, input.lifetime.id, result.token, result.sequence, restore(input.run))
+          yield* fork(result.scope, input.lifetime.id, result.token, restore(input.run))
           return { extended: true as const, sequence: result.sequence, handle: accepted }
         }),
       )
 
@@ -1,11 +1,33 @@
 import { describe, expect, test } from "bun:test"
 import { BackgroundJob } from "@opencode-ai/core/background-job"
 import { LayerNode } from "@opencode-ai/core/effect/layer-node"
-import { Deferred, Effect, Exit, Scope } from "effect"
+import { Deferred, Effect, Exit, Fiber, Scope } from "effect"
 import { it } from "./lib/effect"
 
 const jobsLayer = LayerNode.compile(BackgroundJob.node)
 
+const admission = { lease: "lease_synthetic_core", epoch: 0n }
+
+/**
+ * Arms sequence zero and refuses every later one, parking inside `bind` first so a test can hold a
+ * supplemental sequence in the registered-but-unarmed window and release it deliberately.
+ */
+const refusingBinder = (input: {
+  readonly entered: Deferred.Deferred<void>
+  readonly release: Deferred.Deferred<void>
+}): BackgroundJob.Binder => ({
+  bind: (request) =>
+    request.sequence === 0
+      ? BackgroundJob.makePermit(request.lifetime, request.sequence).pipe(
+          Effect.map((made) => ({ kind: "arm_allowed" as const, permit: made.permit })),
+        )
+      : Deferred.succeed(input.entered, undefined).pipe(
+          Effect.andThen(Deferred.await(input.release)),
+          Effect.as({ kind: "rejected" as const, reason: "refused after reserving" }),
+        ),
+  terminal: () => Effect.void,
+})
+
 /**
  * A run reports the position it answered at plus an opaque payload. Tests use the position string
  * as the payload too, so an assertion names one value.
@@ -421,4 +443,121 @@ describe("BackgroundJob", () => {
       expect((yield* jobs.get(job.id))?.status).toBe("running")
     }),
   )
+
+  it.live("dispositions when a refused extension returns pending to zero", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        // THE STRAND. `reserve` raises `pending` for a supplement that then LOSES admission. The
+        // owner sequence has already succeeded, so its settle saw `pending > 0` and correctly kept
+        // the lifetime running. When the refusal returns `pending` to zero there is nothing left
+        // running to call `settle` again — so without a disposition on this path the lifetime sits
+        // `running` at `pending: 0` forever, and two things break: a blocked SYNCHRONOUS caller
+        // never receives its answer (`done` is resolved only at disposition), and the owner's
+        // completed answer is silently discarded, because moving it into the terminal Info is
+        // itself a disposition step.
+        const holdOwner = yield* Deferred.make<void>()
+        const entered = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const jobs = yield* BackgroundJob.makeWith(refusingBinder({ entered, release }))
+        const started = yield* jobs.startExact({
+          admission,
+          id: "job_unreserve_strand",
+          type: "test",
+          run: Deferred.await(holdOwner).pipe(Effect.as({ position: "p_a", at: 1, detected: "owner answer" })),
+        })
+        if (!started.lifetime || !started.handle) return yield* Effect.die("did not arm")
+
+        // A blocked synchronous caller — the shape a synchronously started task takes.
+        const blocked = yield* jobs.wait({ id: "job_unreserve_strand" }).pipe(Effect.forkScoped)
+
+        // The supplement RESERVES (pending 2) and parks inside bind.
+        const extension = yield* jobs
+          .extendWithHandle({ id: "job_unreserve_strand", admission, run: Effect.succeed(undefined) })
+          .pipe(Effect.forkScoped)
+        yield* Deferred.await(entered)
+
+        // The owner settles successfully inside that window: pending 2 → 1, answer buffered,
+        // correctly no disposition because a supplement is still registered.
+        yield* Deferred.succeed(holdOwner, undefined)
+        yield* Effect.yieldNow
+        yield* Effect.yieldNow
+
+        // The parked bind now REFUSES: pending 1 → 0 with nothing left running.
+        yield* Deferred.succeed(release, undefined)
+        expect(yield* Fiber.join(extension)).toBeUndefined()
+
+        // The lifetime MUST dispose, and as `completed` rather than `error`/`cancelled`: the
+        // FOLLOW-UP was refused — its own caller learns that from its own result — while the run's
+        // own work demonstrably succeeded.
+        const settled = yield* jobs.wait({ id: "job_unreserve_strand", timeout: 1000 })
+        // Bounded-negative: before the fix this fiber parks forever.
+        const delivered = yield* Effect.raceFirst(
+          Fiber.join(blocked).pipe(Effect.as("released" as const)),
+          Effect.sleep("500 millis").pipe(Effect.as("hung" as const)),
+        )
+
+        // Gathered before any assertion, and asserted together, so one failing run reports every
+        // consequence at once rather than stopping at the first.
+        expect({
+          status: settled.info?.status,
+          output: settled.info?.output,
+          blockedCaller: delivered,
+        }).toEqual({
+          status: "completed",
+          output: "owner answer",
+          blockedCaller: "released",
+        })
+      }),
+    ),
+  )
+
+  it.live("releases the lifetime waiter when a refused extension ends a background job", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        // The consequence that motivated the fix. A caller can park on `waitHandle` — that is, on
+        // the job's TERMINAL — to learn when the lifetime ends; the task tool does exactly this to
+        // release a child session's attachment scope. While a refused extension could leave the
+        // lifetime running at `pending: 0`, that terminal never arrived and the waiter was held
+        // indefinitely.
+        const holdOwner = yield* Deferred.make<void>()
+        const entered = yield* Deferred.make<void>()
+        const release = yield* Deferred.make<void>()
+        const jobs = yield* BackgroundJob.makeWith(refusingBinder({ entered, release }))
+        const started = yield* jobs.startExact({
+          admission,
+          id: "job_unreserve_observer",
+          type: "test",
+          metadata: { background: true },
+          run: Deferred.await(holdOwner).pipe(Effect.as({ position: "p_a", at: 1, detected: "owner answer" })),
+        })
+        if (!started.lifetime || !started.handle) return yield* Effect.die("did not arm")
+
+        const waiter = yield* jobs.waitHandle({ handle: started.handle }).pipe(Effect.forkScoped)
+
+        const extension = yield* jobs
+          .extendWithHandle({ id: "job_unreserve_observer", admission, run: Effect.succeed(undefined) })
+          .pipe(Effect.forkScoped)
+        yield* Deferred.await(entered)
+
+        yield* Deferred.succeed(holdOwner, undefined)
+        yield* Effect.yieldNow
+        yield* Effect.yieldNow
+
+        yield* Deferred.succeed(release, undefined)
+        expect(yield* Fiber.join(extension)).toBeUndefined()
+
+        // Bounded-negative: before the fix this waiter is held forever.
+        const released = yield* Effect.raceFirst(
+          Fiber.join(waiter).pipe(Effect.as("released" as const)),
+          Effect.sleep("500 millis").pipe(Effect.as("held" as const)),
+        )
+        expect(released).toBe("released")
+
+        // And the work that DID complete is still delivered: ending the lifetime is not the same as
+        // discarding the answer the run already produced.
+        const first = yield* jobs.waitAnswer({ handle: started.handle, after: 0 })
+        expect(first.answer?.detected).toBe("owner answer")
+      }),
+    ),
+  )
 })