@@ -74,6 +74,14 @@ export namespace RunAccounting {
     // finishes are real failures.
     let challengeAbortSuppressed = false
     let challengeFinishSuppressed = false
+    // altimate_change start — upstream_fix: the abort of the interrupted prompt
+    // can surface as onSessionError(MessageAbortedError), onPromptResult
+    // (finish="error"/"other"), or both — either channel may fire for that
+    // SAME abort, so both suppressions above are scoped to it. Once the
+    // challenge reply itself is sent, a real failure there (e.g. an errorless
+    // finish="other" on the confirm-DONE reply) must not be silently forgiven
+    // by whichever suppression the interrupted prompt's abort left unused.
+    let challengeReplySent = false
 
     function isCompactionStep(messageID: string) {
       return agents.get(messageID) === "compaction"
@@ -112,14 +120,25 @@ export namespace RunAccounting {
       onIdleDoneChallengeIssued() {
         idleDoneChallengeTurn = turnCount
       },
+      // altimate_change start — upstream_fix: see challengeReplySent above.
+      /** the idle-done confirm-DONE challenge reply has been sent; suppression of the interrupted prompt's own abort no longer applies. */
+      onIdleDoneChallengeReplySent() {
+        challengeReplySent = true
+      },
+      // altimate_change end
       onSessionError(name: unknown, message?: string) {
         const errorName = typeof name === "string" && name.length > 0 ? name : "UnknownError"
         if (RECOVERABLE_ERROR_NAMES.has(errorName)) return
         // the idle-done challenge is delivered by aborting the in-flight
         // prompt first; that harness-initiated abort surfaces as a
         // MessageAbortedError and must not be scored as a fatal run error.
         // Exactly ONE such abort exists per challenge — later aborts are real.
-        if (idleDoneChallengeTurn !== undefined && !challengeAbortSuppressed && errorName === "MessageAbortedError") {
+        if (
+          idleDoneChallengeTurn !== undefined &&
+          !challengeAbortSuppressed &&
+          !challengeReplySent &&
+          errorName === "MessageAbortedError"
+        ) {
           challengeAbortSuppressed = true
           return
         }
@@ -151,7 +170,7 @@ export namespace RunAccounting {
           // the terminal message of the ONE prompt the idle-done fallback
           // aborted (to deliver its challenge) finishes abnormally by design;
           // any further abnormal finish is a real failure.
-          if (idleDoneChallengeTurn !== undefined && !challengeFinishSuppressed) {
+          if (idleDoneChallengeTurn !== undefined && !challengeFinishSuppressed && !challengeReplySent) {
             challengeFinishSuppressed = true
             return
           }
 
@@ -1115,6 +1115,12 @@ You are speaking to a non-technical business executive. Follow these rules stric
       // delivered via the nudge arbiter so this injected turn carries exactly
       // ONE system-authored directive.
       if (idleDone.challengeIssued && !accounting.fatal) {
+        // altimate_change start — upstream_fix: mark the challenge reply as
+        // sent BEFORE anything in this phase can raise a session-error/prompt-
+        // result event, so a genuine failure of the reply itself is never
+        // absorbed by the interrupted prompt's own abort suppression.
+        accounting.onIdleDoneChallengeReplySent()
+        // altimate_change end
         // Dedicated abort for the challenge subscription so a failed challenge
         // send can cancel the event-stream loop deterministically (the SSE
         // generator exits cleanly on abort; the loop's for-await then drains).
 
@@ -44,17 +44,24 @@ export namespace SessionTermination {
     if (last.replace(/^ {0,3}/, "") !== DONE_TOKEN) return false
     // Reject a final line inside an unclosed code fence — the block's content is
     // quoted material, not an assertion. Fence state follows CommonMark: a fence
-    // opens with a run of >= 3 backticks or tildes; only a run of the SAME
-    // character with at least the SAME length closes it. Any other fence-looking
-    // line inside an open fence (other marker, or a shorter run) is content.
+    // opens with a run of >= 3 backticks or tildes (an info string, e.g. an
+    // opening ```lang, is permitted); only a run of the SAME character with at
+    // least the SAME length, followed by nothing but optional whitespace, closes
+    // it. A fence-looking line with a trailing info string is opener/content,
+    // never a valid closer — treating it as one would let a still-open fence's
+    // interior DONE terminate the run.
     let open: { char: string; length: number } | undefined
     for (let i = 0; i < lines.length - 1; i++) {
       const match = CODE_FENCE_PATTERN.exec(lines[i]!)
       if (!match) continue
       const marker = match[1]!
       if (!open) {
         open = { char: marker[0]!, length: marker.length }
-      } else if (marker[0] === open.char && marker.length >= open.length) {
+      } else if (
+        marker[0] === open.char &&
+        marker.length >= open.length &&
+        /^[ \t]*$/.test(lines[i]!.slice(match[0]!.length))
+      ) {
         open = undefined
       }
     }
 
@@ -335,4 +335,36 @@ describe("RunAccounting done_reason + idle-done bookkeeping", () => {
     expect(acc.termination().why_harness_stopped).toBe("error")
     expect(acc.fatal).toBe(true)
   })
+
+  // altimate_change start — upstream_fix regression: the interrupted prompt's
+  // abort can surface as EITHER onSessionError(MessageAbortedError) or an
+  // abnormal onPromptResult (or both) — both suppressions above are scoped to
+  // that one abort. Once the challenge reply itself has been sent, a genuine
+  // failure of the reply must not be absorbed by whichever suppression the
+  // interrupted prompt's abort left unused.
+  test("a genuine challenge-reply failure is fatal even if the interrupted prompt's abort only used one suppression channel", () => {
+    const acc = RunAccounting.create()
+    acc.onIdleDoneChallengeIssued()
+    // The interrupted prompt's abort surfaces ONLY via onSessionError — its
+    // own onPromptResult never reports an abnormal finish (e.g. it resolved
+    // "stop" before the abort landed), so challengeFinishSuppressed is never
+    // consumed here.
+    acc.onSessionError("MessageAbortedError", "aborted")
+    expect(acc.fatal).toBe(false)
+    // The challenge reply is now sent; its own errorless abnormal finish is a
+    // real failure of the confirmation, not a leftover of the abort above.
+    acc.onIdleDoneChallengeReplySent()
+    acc.onPromptResult({ finish: "other" })
+    expect(acc.fatal).toBe(true)
+    expect(acc.termination().why_harness_stopped).toBe("error")
+  })
+
+  test("both suppression channels still forgive the same interrupted-prompt abort before the reply is sent", () => {
+    const acc = RunAccounting.create()
+    acc.onIdleDoneChallengeIssued()
+    acc.onSessionError("MessageAbortedError", "aborted")
+    acc.onPromptResult({ finish: "error" })
+    expect(acc.fatal).toBe(false)
+  })
+  // altimate_change end
 })
@@ -57,6 +57,16 @@ describe("SessionTermination.isExplicitDone", () => {
     expect(SessionTermination.isExplicitDone("~~~\n```\n~~~\nDONE")).toBe(true)
   })
 
+  test("a fence-looking line with trailing info-string text never closes the fence", () => {
+    // Per CommonMark, only whitespace may follow a closing fence's marker —
+    // a line like "```not-a-closer" is content (or a nested opener), not a
+    // closer. The DONE that follows is still inside the open fence.
+    expect(SessionTermination.isExplicitDone("```\ncode\n```not-a-closer\nDONE")).toBe(false)
+    expect(SessionTermination.isExplicitDone("~~~\ncode\n~~~lang\nDONE")).toBe(false)
+    // A real closer with trailing whitespace only still closes normally.
+    expect(SessionTermination.isExplicitDone("```\ncode\n```   \nDONE")).toBe(true)
+  })
+
   test("quoted and indented-code DONE never terminates", () => {
     expect(SessionTermination.isExplicitDone("The instructions said:\n> DONE")).toBe(false)
     expect(SessionTermination.isExplicitDone("Example:\n    DONE")).toBe(false)