test: restore 100% per-file coverage for agent-loop and the acp bridge

agent-loop: behavior tests for retry-while-busy, cancelled recovery
windows, no-facts stream failures, idle-listener preemption, rejected
driver promises under whenIdle, finish-chunk failures after step close,
presentationMeta persistence, pre-aborted and torn-down create/resume
signals, and configured-start failures over existing artifacts or after
teardown. The remaining guards that no public path can reach carry
justified v8 ignore annotations naming the invariant that starves them.

acp bridge: cover the retry-adoption path (a retry turn resolves the
prompt the failed turn deferred), the no-retry quiescence rejection, and
the admission-blocked cancelled settlement; the synchronous send-throw
catch is annotated as a future-proofing guard since the machine's send()
contains listener failures.

packages/acp/acp/src/index.ts

@@ -275,14 +275,16 @@ export function apply(ctx: Context, config: AcpConfig): void {
           record.inflight = inflight
           try {
             record.agent.followup({ content: [{ type: 'text', text }], source: { kind: 'user' } })
+            // The machine's send() contains listener failures and accepts
+            // any typed input; this guards a future synchronous throw so the
+            // slot cannot wedge.
+            /* v8 ignore start -- future-proofing guard, see above */
           } catch (error: unknown) {
             record.inflight = undefined
-            // followup() throws only Errors (invalid input); the String arm
-            // is a defensive fallback for a non-Error throw.
-            /* v8 ignore next */
             const detail = error instanceof Error ? error.message : String(error)
             throw internalError(`prompt was not queued: ${detail}`)
           }
+          /* v8 ignore stop */
           // Admission is pre-turn and retries outlive their failed turn, so a
           // turnless slot settles only at quiescence: a held failure rejects
           // (no retry adopted the prompt); no turn at all means admission

packages/acp/acp/tests/turns.spec.ts

@@ -166,4 +166,40 @@ describe('ACP prompt lifecycle', () => {
       .resolves.toEqual({ stopReason: 'end_turn' })
     await vi.waitFor(() => { expect(messageText(harness!)).toBe('next') })
   })
+
+  it('a retry turn adopts the prompt instead of rejecting at the failed turn end', async () => {
+    harness = await makeBridgeHarness({ script: [errorResponse('transient boom'), textResponse('recovered')] })
+    // A recovery policy: schedule one retry for the failed request.
+    let retried = false
+    harness.ctx.on('agent/request-error', async (subject) => {
+      if (!retried) {
+        retried = true
+        subject.retry()
+      }
+    })
+    const sessionId = await newSession(harness)
+    const result = await harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'go' }] })
+    expect(result.stopReason).toBe('end_turn')
+    await vi.waitFor(() => { expect(messageText(harness!)).toBe('recovered') })
+  })
+
+  it('a failed turn with no retry still rejects, at quiescence', async () => {
+    harness = await makeBridgeHarness({ script: [errorResponse('terminal boom')] })
+    let offered = 0
+    harness.ctx.on('agent/request-error', async () => { offered += 1 })
+    const sessionId = await newSession(harness)
+    await expect(harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'go' }] }))
+      .rejects.toThrow(/turn failed: terminal boom/)
+    expect(offered).toBe(1)
+  })
+
+  it('an admission-blocked prompt settles cancelled instead of hanging', async () => {
+    harness = await makeBridgeHarness({ script: [] })
+    harness.ctx.on('agent/prompt-submit', async () => ({ kind: 'block' as const, reason: 'policy said no' }))
+    const sessionId = await newSession(harness)
+    await expect(harness.client.prompt({ sessionId, prompt: [{ type: 'text', text: 'go' }] }))
+      .resolves.toEqual({ stopReason: 'cancelled' })
+    // The blocked prompt opened no turn and streamed nothing.
+    expect(messageText(harness)).toBe('')
+  })
 })