@buyong/pi-devin 0.1.3 → 0.1.4

package/README.md

@@ -80,7 +80,7 @@ There are two toggles, both off by default. Changes apply to all sessions at onc
 - **Recommended models only**: `/model` shows only the models that have a variant Devin marks as Recommended, plus Devin Fusion. Devin marks single variants such as `swe-2-high`, but the list keeps the model itself (`swe-2`), so you still pick the thinking level with `/thinking`. The recommended level is not applied automatically. If your account has no recommended models, the full list is shown.
 - **Usage in status line**: the TUI footer shows the remaining daily and weekly quota as bars, plus this session's input and output tokens, like `devin day ▕█████████░▏98% week ▕█████████░▏98% · ↑263 ↓49`. A bar turns to the warning color at 40% or less and to the error color at 20% or less.
 
-Quota is not live. It is refreshed when you log in and when Pi checks the login right before sending a model request, so the usage of the message you just sent shows up after the next request. `/devin` and the status line send no network requests. Credits, per-request costs and usage history are not shown.
+Quota is not live. It is refreshed when you log in and by the account check right before each model request, so the usage of the message you just sent shows up after the next request. If that check cannot reach the Devin server (for example `ECONNREFUSED` or a 503), the request is still sent with the last checked account. A model request whose connection is refused, reset or cut off mid-response is reported as `Connection error (…)`, which Pi's automatic retry recognizes; a lasting outage reports that connection error instead of `OAuth refresh failed`. `/devin` and the status line send no network requests. Credits, per-request costs and usage history are not shown.
 
 If a filter change removes the model you are using from the list, you can keep using it in the current session. When you reopen the session, that model is not restored, so pick a model from the list again.
 
@@ -95,8 +95,9 @@ Picking **Devin Fusion** (`fusion`) in `/model` turns on the `devin_sidekick` to
 - You can also use arguments: `/devin-fusion <lead model ID> <sidekick model ID>` (for example, `/devin-fusion swe-2 swe-2-high`). The lead is a family ID from the `/model` list; the sidekick is a variant ID with a fixed thinking level. With the TUI picker you do not need to know the IDs. The saved pair applies to all sessions.
 - The lead's thinking level follows `/thinking`.
 - The sidekick runs as a separate Pi process for each lead session. It shares the working directory, active tools and Devin login with the lead.
-- By default, the lead waits for the sidekick's report. If the lead model calls the `devin_sidekick` tool with `block: false`, it continues without waiting, and runs again when the report arrives. Cancelling the lead also stops the sidekick task it was waiting for.
-- The lead receives at most about 131,072 tokens of each sidekick report, counted like Pi's own context estimate (4 characters per token). A longer report is cut at that point, and the cut report ends with the path of a temporary file that holds the complete text (see [Storage locations](#storage-locations)).
+- By default, the lead waits for the sidekick's report. If the lead model calls the `devin_sidekick` tool with `block: false`, it continues without waiting, and runs again when the report arrives. A later blocking call to the running task receives the report as its tool result instead of another background message. Actual user input while waiting moves the task back to the background.
+- Cancelling the lead also stops the sidekick task it was waiting for. A call already cancelled before handoff starts no work, including with `block: false`. A broken connection to the sidekick fails the task and closes that child process rather than terminating the lead Pi.
+- The lead receives at most about 131,072 tokens of each sidekick report, counted like Pi's own context estimate (4 characters per token). This includes status, errors, background headings and truncation notices. A longer report is cut, and the cut report ends with the path of a temporary file that holds the complete report (see [Storage locations](#storage-locations)). If saving fails, the report stays bounded and includes a notice instead.
 - If you restricted tools with `pi --tools`, include `devin_sidekick` in the list for Fusion to work.
 - With Fusion, the lead and the sidekick each use quota as regular requests to the models they call.
 
@@ -108,7 +109,7 @@ Picking **Devin Fusion** (`fusion`) in `/model` turns on the `devin_sidekick` to
 | Request timeout | Follows the value set by Pi (300 seconds by default). |
 | Prompt cache | Short cache by default. `PI_CACHE_RETENTION=long` is allowed only for models Devin marks with a 24-hour cache; for other models the request is refused before sending. |
 | Images | On supported models, up to 4 MiB per image and 5 MiB in total per message. |
-| Sidekick report | The lead receives at most about 131,072 tokens (524,288 characters) of each report. The complete text of a longer report is saved in a temporary file. |
+| Sidekick report | The lead receives at most about 131,072 tokens (524,288 characters), including errors and notices. The complete report is saved in a temporary file when possible. |
 | print and JSON modes | These modes do not fetch the model list; they use the list stored by an earlier TUI or RPC session. After logging in, run the TUI or RPC mode once, or `--model devin/<model ID>` is not found. |
 
 - On a 401 error, log in again. 403, 429 and timeouts are not treated as an expired login. If logging in again does not help, check your account permissions, quota and network.
@@ -212,4 +213,12 @@ SOFTWARE.
 
 ## Development
 
-The source and verification procedures are in the [GitHub repository](https://github.com/buYoung/pi-packages/tree/main/apps/pi-devin). See `verification/README.md` for verification and `proto/README.md` for the schema sources.
+The source and verification procedures are in the [GitHub repository](https://github.com/buYoung/pi-packages/tree/main/apps/pi-devin). With development dependencies installed, run these from `apps/pi-devin/` in a source checkout; they use local fixtures and need no Devin account:
+
+```bash
+pnpm run typecheck
+pnpm run test:unit
+node verification/scripts/import-closure.mjs . --expect verification/inventory.json
+```
+
+Expected: exit code 0, all tests passing, and `ok: true` with no import-closure problems. The sidekick tests cover cancellation, broken child connections, one-time delivery and report limits. See `verification/README.md` for isolated Pi and archive checks, and `proto/README.md` for the schema sources.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buyong/pi-devin",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Unofficial Pi provider for Devin accounts (OAuth)",
   "license": "MIT",
@@ -54,12 +54,13 @@
     "@earendil-works/pi-tui": "1.3.0",
     "@types/node": "26.6.5",
     "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "vitest": "4.1.12",
     "@repo/typescript-config": "0.0.0"
   },
   "scripts": {
     "typecheck": "tsgo --noEmit",
-    "verify:offline": "node --test tests/*.test.ts",
-    "test:unit": "node --test tests/*.test.ts",
+    "verify:offline": "vitest run",
+    "test:unit": "vitest run",
     "cli": "node cli.ts"
   }
 }

package/src/core/protocol/transport.ts

@@ -80,6 +80,18 @@ export function failureDetails(error: unknown): JsonObject {
   return { category: "error" };
 }
 
+const TRANSIENT_CONNECTION_CODES = /^(ECONNREFUSED|ECONNRESET|ECONNABORTED|EPIPE|ETIMEDOUT|EHOSTUNREACH|ENETUNREACH|ENETDOWN|ENOTFOUND|EAI_AGAIN|ERR_STREAM_PREMATURE_CLOSE)$/;
+
+/** The request got no usable answer from a working server, so sending it again may succeed. TLS and certificate failures are not included. */
+export function isTransientConnectionFailure(error: unknown): boolean {
+  if (error instanceof RPCError) return error.code === "unavailable" || [502, 503, 504].includes(error.httpStatus ?? 0);
+  return error instanceof Error && "code" in error && typeof error.code === "string" && TRANSIENT_CONNECTION_CODES.test(error.code);
+}
+
+function prematureClose(message: string): Error {
+  return Object.assign(new Error(message), { code: "ERR_STREAM_PREMATURE_CLOSE" });
+}
+
 function retryAfterMs(headers: Headers): number | undefined {
   const value = headers.get("retry-after")?.trim();
   if (!value) return undefined;
@@ -185,8 +197,8 @@ export async function* decodeFrames(
       yield { isEnd: hasEnded, data };
     }
   }
-  if (buffered.length !== 0) throw new Error("The connection ended with an incomplete Connect frame.");
-  if (!hasEnded) throw new Error("The connection ended without EndStream.");
+  if (buffered.length !== 0) throw prematureClose("The connection ended with an incomplete Connect frame.");
+  if (!hasEnded) throw prematureClose("The connection ended without EndStream.");
 }
 
 async function* responseChunks(response: Response, signal: AbortSignal): AsyncGenerator<Uint8Array> {

package/src/pi/auth.ts

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import type { OAuthAuth, OAuthCredential } from "@earendil-works/pi-ai";
 import { loginAccount, type LoginOptions } from "../core/auth/index.ts";
 import { DevinClient } from "../core/client.ts";
-import { awaitWithSignal, endpoint, isAuthenticationError, RPCError } from "../core/protocol/transport.ts";
+import { awaitWithSignal, endpoint, isAuthenticationError, isTransientConnectionFailure, RPCError } from "../core/protocol/transport.ts";
 import { object, requiredString, type Credential, type JsonObject } from "../core/types.ts";
 
 export const OAUTH_ONLY_MESSAGE = "Devin uses only the OAuth account session from /login. API key authentication is not supported.";
@@ -48,6 +48,8 @@ export function createDevinAccountAuth(options: {
   onValidated?: (credential: Credential, ownerHash: string, status: JsonObject) => void;
   onInvalidated?: (credential: Credential, error: unknown) => void;
   getSignal?: () => AbortSignal;
+  /** The account was already checked in this process; each model request checks it again outside Pi's credential lock. */
+  isAccountChecked?: (credential: Credential) => boolean;
 } = {}): DevinAccountAuth {
   const invalid = new Set<string>();
   // Remembers only a hash, never the token. Pi calls toAuth on every request, so the session in use moves back to the front.
@@ -104,6 +106,9 @@ export function createDevinAccountAuth(options: {
       const credential = credentialFromOAuth(current);
       requireUsable(credential);
       rememberOAuth(credential);
+      // expires 0 makes Pi call this before every request while holding the shared auth.json lock. A network
+      // check here serializes every Pi process using Devin, so only the first resolution in a process checks.
+      if (options.isAccountChecked?.(credential)) return current;
       const expectedGeneration = generation;
       const client = (options.createClient ?? ((value) => new DevinClient(value, { profile: "login" })))(credential);
       try {
@@ -111,7 +116,13 @@ export function createDevinAccountAuth(options: {
         const status = await client.status(signal);
         if (expectedGeneration === generation) options.onValidated?.(credential, requiredString(client.accountIdentityHash, "Devin account scope"), status);
         return current;
-      } catch (error) { auth.invalidate(credential, error, expectedGeneration); throw error; }
+      } catch (error) {
+        auth.invalidate(credential, error, expectedGeneration);
+        // An unreachable check must not block the request: keep the stored session so the model request
+        // succeeds or reports its own retryable transport error.
+        if (!signal.aborted && isTransientConnectionFailure(error)) return current;
+        throw error;
+      }
       finally { client.transport.close(); }
     },
     async toAuth(current) {

package/src/pi/provider.ts

@@ -9,7 +9,7 @@ import { applyTeamModelPolicy } from "../core/models/access.ts";
 import type { BackendModelSelection, EffectiveThinkingLevel } from "../core/models/variants.ts";
 import { createFingerprintProvider, type FingerprintProvider } from "../core/protocol/fingerprint.ts";
 import { CHAT_METHOD } from "../core/protocol/protobuf.ts";
-import { awaitWithSignal, endpoint, isAuthenticationError, RPCError, safeError } from "../core/protocol/transport.ts";
+import { awaitWithSignal, endpoint, isAuthenticationError, isTransientConnectionFailure, RPCError, safeError } from "../core/protocol/transport.ts";
 import { object, requiredString, tokenCount, type Credential, type JsonObject } from "../core/types.ts";
 import { createDevinAccountAuth } from "./auth.ts";
 import { DevinLifecycle, type RequestLease, type SessionBinding } from "./lifecycle.ts";
@@ -22,6 +22,11 @@ import { accountUsage, type AccountUsage } from "./usage.ts";
 type LoginConfiguration = NonNullable<Parameters<typeof createDevinAccountAuth>[0]>["loginOptions"];
 
 /** Like Pi's built-in providers: the caller option wins; otherwise only PI_CACHE_RETENTION=long (provider env first) means long retention. */
+/** Node and Connect report these failures as codes ("read ECONNRESET", "unavailable: …") that Pi's host retry does not match. */
+function hostRetryableMessage(error: unknown, message: string): string {
+  return isTransientConnectionFailure(error) ? `Connection error (${message})` : message;
+}
+
 function resolveCacheRetention(options: SimpleStreamOptions): NonNullable<SimpleStreamOptions["cacheRetention"]> {
   if (options.cacheRetention) return options.cacheRetention;
   return (options.env?.PI_CACHE_RETENTION || process.env.PI_CACHE_RETENTION) === "long" ? "long" : "short";
@@ -85,6 +90,7 @@ export function createDevinProvider(options: {
     loginOptions: { ...options.loginOptions, fetch: options.loginOptions?.fetch ?? options.fetch },
     createClient: (credential) => clientFor(credential, { profile: "login" }),
     getSignal: () => lifetime.signal,
+    isAccountChecked: (credential) => accounts.has(catalogScope(credential)),
     onValidated: rememberAccount,
     onInvalidated: (credential, error) => { accounts.delete(catalogScope(credential)); latestUsage = undefined; lifecycle.abort(error); },
     onLogin: () => {
@@ -141,18 +147,20 @@ export function createDevinProvider(options: {
           }
         };
         assertCacheRetention(selected);
+        // The per-request account check (permission and quota) runs here, outside Pi's shared credential lock.
         let account = accounts.get(catalogScope(credential));
-        if (!account) {
-          const probe = clientFor(credential, { profile: "login", fetch: requestOptions.fetch, timeoutMs: requestOptions.timeoutMs });
-          try {
-            const status = await probe.status(signal);
-            signal.throwIfAborted();
-            if (generation !== auth.generation) throw new DOMException("The Devin authentication generation changed.", "AbortError");
-            auth.assertUsable(credential);
-            rememberAccount(credential, requiredString(probe.accountIdentityHash, "Devin account scope"), status);
-            account = accounts.get(catalogScope(credential));
-          } finally { probe.transport.close(); }
-        }
+        const probe = clientFor(credential, { profile: "login", fetch: requestOptions.fetch, timeoutMs: requestOptions.timeoutMs });
+        try {
+          const status = await probe.status(signal);
+          signal.throwIfAborted();
+          if (generation !== auth.generation) throw new DOMException("The Devin authentication generation changed.", "AbortError");
+          auth.assertUsable(credential);
+          rememberAccount(credential, requiredString(probe.accountIdentityHash, "Devin account scope"), status);
+          account = accounts.get(catalogScope(credential));
+        } catch (error) {
+          // A check that cannot reach the server keeps the last known account; the model request reports its own failure.
+          if (!account || signal.aborted || !isTransientConnectionFailure(error)) throw error;
+        } finally { probe.transport.close(); }
         if (!account) throw new Error("The Devin account check was interrupted.");
         assertCanInfer(account.status);
         lease = await lifecycle.acquire(account.ownerHash, signal);
@@ -215,7 +223,7 @@ export function createDevinProvider(options: {
       } catch (error) {
         if (credential) authenticationFailed(credential, error, generation);
         accumulator.message.modelUid = actualUID || undefined;
-        response.fail(safeError(error, credential ? [credential.sessionToken] : []), error instanceof Error && error.name === "AbortError", isRedacted ? undefined : accumulator.message);
+        response.fail(hostRetryableMessage(error, safeError(error, credential ? [credential.sessionToken] : [])), error instanceof Error && error.name === "AbortError", isRedacted ? undefined : accumulator.message);
       } finally { client?.transport.close(); lease?.release(); }
     })();
     return response.stream;

package/src/pi/sidekick-report.ts

@@ -30,13 +30,18 @@ export function truncateReport(text: string, maxChars = SIDEKICK_REPORT_CHAR_LIM
 export async function boundReport(text: string, maxChars = SIDEKICK_REPORT_CHAR_LIMIT): Promise<BoundedReport> {
   const result = truncateReport(text, maxChars);
   if (!result.isTruncated) return { text };
-  const notice = `[The sidekick report exceeded about ${SIDEKICK_REPORT_TOKEN_LIMIT} tokens and was cut.`;
+  let notice = `\n\n[The sidekick report exceeded about ${SIDEKICK_REPORT_TOKEN_LIMIT} tokens and was cut.`;
+  let fullReportPath: string | undefined;
   try {
     const directory = await mkdtemp(join(tmpdir(), "pi-devin-sidekick-report-"));
-    const fullReportPath = join(directory, "report.md");
-    await writeFile(fullReportPath, text, { encoding: "utf8", mode: 0o600 });
-    return { text: `${result.text}\n\n${notice} Full report: ${fullReportPath}]`, fullReportPath };
+    const path = join(directory, "report.md");
+    await writeFile(path, text, { encoding: "utf8", mode: 0o600 });
+    fullReportPath = path;
+    notice += ` Full report: ${path}]`;
   } catch (error) {
-    return { text: `${result.text}\n\n${notice} The full report could not be saved: ${error instanceof Error ? error.message : String(error)}]` };
+    notice += ` The full report could not be saved: ${error instanceof Error ? error.message : String(error)}]`;
   }
+  // The notice is part of the same budget, including a filesystem error if preservation failed.
+  const suffix = truncateReport(notice, maxChars).text;
+  return { text: truncateReport(text, maxChars - suffix.length).text + suffix, ...(fullReportPath ? { fullReportPath } : {}) };
 }

package/src/pi/sidekick-runtime.ts

@@ -151,35 +151,38 @@ export class SidekickRuntime {
   }
 
   handoff(message: string): Handoff {
-    if (this.pending) {
+    const current = this.pending;
+    if (current) {
       this.send({ type: "steer", message });
-      return { id: this.pending.id, done: this.pending.done, isSteer: true };
+      return { id: current.id, done: current.done, isSteer: true };
     }
     if (!this.isAlive()) this.start();
     let resolve!: (report: HandoffReport) => void;
     const done = new Promise<HandoffReport>((settle) => { resolve = settle; });
     const id = randomUUID();
     this.pending = { id, startedAt: Date.now(), toolCalls: 0, recentTools: [], isAborted: false, resolve, done };
-    try { this.send({ id, type: "prompt", message }); }
-    catch (error) { this.finish("error", "", error instanceof Error ? error.message : String(error)); }
+    this.send({ id, type: "prompt", message });
     return { id, done, isSteer: false };
   }
 
   abort(): void {
     if (!this.pending) return;
     this.pending.isAborted = true;
-    try { this.send({ type: "abort" }); } catch { this.finish("aborted", ""); }
+    this.send({ type: "abort" });
   }
 
   close(): void {
     const child = this.child;
     this.child = undefined;
     if (this.pending) this.finish("aborted", "", "Stopped the sidekick process.");
+    for (const resolve of this.waiting.values()) resolve(undefined);
+    this.waiting.clear();
     if (!child || child.exitCode !== null || child.signalCode !== null) return;
     child.stdin?.end();
-    child.kill("SIGTERM");
     const timer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL"); }, KILL_GRACE_MS);
     timer.unref();
+    child.once("close", () => clearTimeout(timer));
+    child.kill("SIGTERM");
   }
 
   private start(): void {
@@ -195,6 +198,7 @@ export class SidekickRuntime {
     const decoder = new StringDecoder("utf8");
     let buffer = "";
     child.stdout?.on("data", (chunk: Buffer) => {
+      if (this.child !== child) return;
       buffer += decoder.write(chunk);
       let index: number;
       while ((index = buffer.indexOf("\n")) >= 0) {
@@ -205,28 +209,37 @@ export class SidekickRuntime {
         let record: Record<string, unknown>;
         try { record = JSON.parse(line) as Record<string, unknown>; } catch { continue; }
         this.handle(record);
+        if (this.child !== child) return;
       }
     });
-    child.stderr?.on("data", (chunk: Buffer) => { this.stderrTail = (this.stderrTail + chunk.toString("utf8")).slice(-STDERR_TAIL); });
-    child.on("error", (error) => { if (this.child === child) this.finish("error", "", error.message); });
-    child.on("close", () => {
-      if (this.child === child) this.child = undefined;
-      for (const resolve of this.waiting.values()) resolve(undefined);
-      this.waiting.clear();
-      if (this.pending) this.finish("error", "", this.stderrTail.trim() || "The sidekick process exited.");
-    });
+    child.stderr?.on("data", (chunk: Buffer) => { if (this.child === child) this.stderrTail = (this.stderrTail + chunk.toString("utf8")).slice(-STDERR_TAIL); });
+    child.stdin?.on("error", (error) => this.fail(child, error.message));
+    child.on("error", (error) => this.fail(child, error.message));
+    child.on("close", () => this.fail(child, this.stderrTail.trim() || "The sidekick process exited."));
+  }
+
+  /** Transport errors settle the handoff and all RPC waits once, even if the failed child closes after its replacement starts. */
+  private fail(child: ChildProcess | undefined, error: string): void {
+    if (this.child !== child) return;
+    this.finish(this.pending?.isAborted ? "aborted" : "error", "", error);
+    this.close();
   }
 
   private send(value: Record<string, unknown>): void {
-    if (!this.child?.stdin?.writable) throw new Error("Cannot write to the sidekick process.");
-    this.child.stdin.write(JSON.stringify(value) + "\n");
+    const child = this.child;
+    try {
+      if (!child?.stdin?.writable) throw new Error("Cannot write to the sidekick process.");
+      child.stdin.write(JSON.stringify(value) + "\n");
+    } catch (error) {
+      this.fail(child, error instanceof Error ? error.message : String(error));
+    }
   }
 
   private request(type: string): Promise<string | undefined> {
     const id = randomUUID();
     return new Promise((resolve) => {
       this.waiting.set(id, resolve);
-      try { this.send({ id, type }); } catch { this.waiting.delete(id); resolve(undefined); }
+      this.send({ id, type });
     });
   }
 
@@ -247,7 +260,7 @@ export class SidekickRuntime {
       case "extension_ui_request":
         // The sidekick never talks to the user. Dialogs that need an answer are returned as cancelled.
         if (["select", "confirm", "input", "editor"].includes(String(record.method))) {
-          try { this.send({ type: "extension_ui_response", id: record.id, cancelled: true }); } catch { /* shutting down */ }
+          this.send({ type: "extension_ui_response", id: record.id, cancelled: true });
         }
         return;
       case "tool_execution_start":

package/src/pi/sidekick.ts

@@ -51,12 +51,18 @@ export function fusionOf(provider: Pick<DevinProvider, "getModels">, model: Mode
 const launchKey = (launch: SidekickLaunch) => JSON.stringify([launch.cwd, launch.modelID, launch.thinking, launch.sessionFile, launch.tools]);
 const shortID = (id: string) => id.slice(0, 8);
 
-/** Report text for the lead. The sidekick's own text is bounded on every path: tool result, failure and background message. */
-async function reportText(report: HandoffReport): Promise<BoundedReport> {
-  const body = await boundReport(report.text.trim());
-  if (report.status === "completed") return { ...body, text: body.text || "(The sidekick finished without a report.)" };
+/** Bound and preserve the complete report, including status, errors and any background delivery heading. */
+async function reportText(report: HandoffReport, heading = ""): Promise<BoundedReport> {
+  const body = report.text.trim();
   const reason = report.error ?? (report.status === "aborted" ? "cancelled." : "failed.");
-  return { ...body, text: [`The sidekick task ${report.status === "aborted" ? "stopped" : "failed"}: ${reason}`, body.text].filter(Boolean).join("\n\n") };
+  const text = report.status === "completed" ? body || "(The sidekick finished without a report.)"
+    : [`The sidekick task ${report.status === "aborted" ? "stopped" : "failed"}: ${reason}`, body].filter(Boolean).join("\n\n");
+  return boundReport(heading + text);
+}
+
+interface ReportDelivery {
+  owner: "background" | "blocking" | "delivered";
+  scheduled: boolean;
 }
 
 const reportPath = (fullReportPath: string | undefined) => fullReportPath ? { fullReportPath } : {};
@@ -67,25 +73,28 @@ const reportPath = (fullReportPath: string | undefined) => fullReportPath ? { fu
  */
 export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, options: SidekickToolOptions) {
   const runtimes = new Map<string, SidekickRuntime>();
-  const scheduled = new Set<string>();
+  // Steers share the same done promise; completed handoffs must not be retained by delivery bookkeeping.
+  const deliveries = new WeakMap<Promise<HandoffReport>, ReportDelivery>();
   const waits = new Set<() => void>();
   let progressListener: (() => void) | undefined;
 
-  const deliverLater = (handoff: Handoff, runtime: SidekickRuntime) => {
-    if (scheduled.has(handoff.id)) return;
-    scheduled.add(handoff.id);
+  const deliverLater = (handoff: Handoff, runtime: SidekickRuntime, delivery: ReportDelivery) => {
+    if (delivery.scheduled || delivery.owner === "delivered") return;
+    delivery.scheduled = true;
     void handoff.done.then(async (report) => {
-      // Handoffs cleaned up by a session switch or shutdown, or cancelled by the lead, are not reported.
-      const isCurrent = () => [...runtimes.values()].includes(runtime);
-      if (report.status === "aborted" || !isCurrent()) return;
-      const { text, fullReportPath } = await reportText(report);
-      if (!isCurrent()) return;
-      pi.sendMessage({
-        customType: SIDEKICK_REPORT_MESSAGE, display: true,
-        content: `Sidekick report for background handoff ${shortID(report.id)}:\n\n${text}`,
-        details: { sidekickModel: runtime.launch.modelID, handoffId: report.id, status: report.status, toolCalls: report.toolCalls, durationMs: report.durationMs, isSteer: false,
-          ...reportPath(fullReportPath) } satisfies SidekickDetails,
-      }, { deliverAs: "followUp", triggerTurn: true });
+      try {
+        // A blocking call owns the report unless user input moves it back to the background.
+        const canDeliver = () => delivery.owner === "background" && [...runtimes.values()].includes(runtime);
+        if (report.status === "aborted" || !canDeliver()) return;
+        const { text, fullReportPath } = await reportText(report, `Sidekick report for background handoff ${shortID(report.id)}:\n\n`);
+        if (!canDeliver()) return;
+        delivery.owner = "delivered";
+        pi.sendMessage({
+          customType: SIDEKICK_REPORT_MESSAGE, display: true, content: text,
+          details: { sidekickModel: runtime.launch.modelID, handoffId: report.id, status: report.status, toolCalls: report.toolCalls, durationMs: report.durationMs, isSteer: false,
+            ...reportPath(fullReportPath) } satisfies SidekickDetails,
+        }, { deliverAs: "followUp", triggerTurn: true });
+      } finally { delivery.scheduled = false; }
     });
   };
 
@@ -109,6 +118,7 @@ export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, op
     defaultActive: false,
     executionMode: "sequential",
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      signal?.throwIfAborted();
       const fusion = fusionOf(provider, ctx.model);
       if (!fusion) throw new Error("The sidekick is only available with the Devin Fusion model.");
       const input = params as { message?: unknown; block?: unknown } | undefined;
@@ -131,18 +141,25 @@ export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, op
         runtime = new SidekickRuntime(launch, { ...options.runtime, childEnv: { [FUSION_CHILD_ENV]: "1" }, onProgress: () => progressListener?.() });
         runtimes.set(sessionId, runtime);
       }
+      signal?.throwIfAborted();
       const handoff = runtime.handoff(message);
+      let delivery = deliveries.get(handoff.done);
+      if (!delivery) {
+        delivery = { owner: "background", scheduled: false };
+        deliveries.set(handoff.done, delivery);
+      }
       const details = (status: SidekickDetails["status"], report?: HandoffReport): SidekickDetails => ({
         sidekickModel: launch.modelID, handoffId: handoff.id, status, toolCalls: report?.toolCalls ?? runtime!.progress()?.toolCalls ?? 0,
         ...(report ? { durationMs: report.durationMs } : {}), isSteer: handoff.isSteer,
       });
       const backgroundResult = (reason: string) => {
-        deliverLater(handoff, runtime!);
+        deliverLater(handoff, runtime!, delivery);
         return { content: [{ type: "text" as const, text: `${reason} The report will arrive as a message. (handoff ${shortID(handoff.id)})` }], details: details("background") };
       };
       if (input?.block === false) {
         return backgroundResult(handoff.isSteer ? "Added instructions to the running sidekick task." : "The sidekick started working in the background.");
       }
+      delivery.owner = "blocking";
       let settle!: (outcome: "done" | "aborted" | "interrupted") => void;
       const waiting = new Promise<"done" | "aborted" | "interrupted">((resolve) => { settle = resolve; });
       const interrupt = () => settle("interrupted"), abort = () => settle("aborted");
@@ -159,11 +176,15 @@ export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, op
         waits.delete(interrupt);
         signal?.removeEventListener("abort", abort);
       });
+      if (outcome === "interrupted") {
+        delivery.owner = "background";
+        return backgroundResult("A user message arrived, so the sidekick task moved to the background.");
+      }
+      delivery.owner = "delivered";
       if (outcome === "aborted") {
         runtime.abort();
         throw new Error("Cancelled the sidekick task.");
       }
-      if (outcome === "interrupted") return backgroundResult("A user message arrived, so the sidekick task moved to the background.");
       const report = await handoff.done;
       const { text, fullReportPath } = await reportText(report);
       if (report.status !== "completed") throw new Error(text);
@@ -184,7 +205,7 @@ export function createSidekickTool(pi: ExtensionAPI, provider: DevinProvider, op
     },
     reset(): void {
       for (const runtime of runtimes.values()) runtime.close();
-      runtimes.clear(); scheduled.clear();
+      runtimes.clear();
     },
   };
 }