Post-restart native session continuity fails: prompt timeout after restart and after resumeSession (opencode, 0.2.0)

[handfuloflight]

Summary

After restarting sandbox-agent, gateway, or rivetkit, native session continuity appears broken for prompt execution in our Sprite environment:

• promptSameHandleAfterRestart times out
• resumeSession + getEvents can succeed
• promptAfterResume still times out

Environment

• sandbox-agent CLI/server: 0.2.0
• SDK: sandbox-agent TypeScript package 0.2.0
• Agent under test: opencode
• Sandbox provider: Sprites (Fly)
• Gateway route: https://<sprite>.sprites.app/sandbox

Repro (phase-level)

1. Create session and prompt successfully.
2. Restart one target (sandbox-agent OR gateway OR rivetkit).
3. Prompt on same session handle (promptSameHandleAfterRestart) -> timeout.
4. Reconnect + call getEvents -> success.
5. Call resumeSession -> success.
6. Prompt after resume (promptAfterResume) -> timeout.

Observed signatures

• TypeError: terminated (unhandled rejection around restart window)
• ACP client is closed

Results (inline)

Native continuity diagnostic (1 run/target)

• total: 0/3 success
• failure boundary phase: promptSameHandleAfterRestart in 3/3
• per target:
  • sandbox-agent: same-handle prompt ❌, reconnect/getEvents ✅, resumeSession ✅, post-resume prompt ❌
  • gateway: same-handle prompt ❌, reconnect/getEvents ✅, resumeSession ✅, post-resume prompt ❌
  • rivet: same-handle prompt ❌, reconnect/getEvents ✅, resumeSession ✅, post-resume prompt ❌

Fallback contrast (recreate + rehydrate)

If we do not reuse the pre-restart session handle, and instead:

• create a fresh post-restart session
• rehydrate from a client-side transcript envelope

then matrix result is 6/6 success (sandbox-agent 2/2, gateway 2/2, rivet 2/2).

Minimal log excerpts

Error: promptSameHandleAfterRestart timed out after 60000ms
TypeError: terminated
ACP write error: Error: ACP client is closed

Error: promptAfterResume timed out after 60000ms

(recreate + rehydrate path)
createAfter: ok
promptRehydrate: ok (stopReason=end_turn)

Note on prior links

The previous issue body included links to a private repo by mistake. I removed those and pasted the key evidence inline here.

Ask

Can you confirm whether this is expected in 0.2.0 during restart transport churn, or a bug in native session continuity/rebind after restart? If helpful, I can provide a standalone public repro script with no private dependencies.

[linear]

RVT-5981

[handfuloflight]

Posted a standalone repro script below (no private repo dependency).

Quick setup

mkdir -p /tmp/sa-repro && cd /tmp/sa-repro
npm init -y
npm i sandbox-agent@0.2.0

Run sandbox-agent however you normally do (local, docker, sprite, etc.), then run:

SA_BASE_URL="http://127.0.0.1:2468" \
SA_AGENT="opencode" \
SA_TIMEOUT_MS="60000" \
SA_RESTART_WAIT_SEC="6" \
node repro-restart-continuity.mjs

Optional automation for restart step:

SA_RESTART_CMD='your restart command here'

If SA_RESTART_CMD is omitted, the script pauses and asks you to restart manually, then press Enter.

repro-restart-continuity.mjs

import { execSync } from "node:child_process";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";
import { SandboxAgent } from "sandbox-agent";

const baseUrl = process.env.SA_BASE_URL || "http://127.0.0.1:2468";
const token = process.env.SA_TOKEN || undefined;
const agent = process.env.SA_AGENT || "opencode";
const timeoutMs = Number(process.env.SA_TIMEOUT_MS || "60000");
const waitSec = Number(process.env.SA_RESTART_WAIT_SEC || "6");
const restartCmd = process.env.SA_RESTART_CMD || "";

const rl = readline.createInterface({ input, output });

function withTimeout(promise, label, ms) {
  return Promise.race([
    promise,
    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)),
  ]);
}

function serializeError(error) {
  if (error instanceof Error) {
    return { name: error.name, message: error.message, stack: error.stack };
  }
  return { message: String(error) };
}

async function restartGate(label) {
  if (restartCmd) {
    execSync(restartCmd, { stdio: "inherit", shell: true });
    await new Promise((r) => setTimeout(r, waitSec * 1000));
    return;
  }

  console.log(`\n[MANUAL STEP] Restart target now (${label}), then press Enter.`);
  await rl.question("> ");
  await new Promise((r) => setTimeout(r, waitSec * 1000));
}

async function runNativeContinuity() {
  const report = {
    scenario: "native_continuity",
    ok: false,
    phases: {},
  };

  let sdk1;
  let sdk2;
  let session;
  let resumed;

  const sid = `native-${Date.now()}`;

  try {
    sdk1 = await withTimeout(SandboxAgent.connect({ baseUrl, token }), "connect-primary", timeoutMs);
    session = await withTimeout(
      sdk1.createSession({
        id: sid,
        agent,
        sessionInit: { cwd: "/", mcpServers: [] },
      }),
      "createSession",
      timeoutMs,
    );
    report.phases.createSession = { ok: true };

    const before = await withTimeout(
      session.prompt([{ type: "text", text: "Return only PRE-OK" }]),
      "prompt-before-restart",
      timeoutMs,
    );
    report.phases.promptBeforeRestart = { ok: true, stopReason: before?.stopReason ?? null };

    await restartGate("native continuity");

    try {
      const same = await withTimeout(
        session.prompt([{ type: "text", text: "Return only SAME-HANDLE-OK" }]),
        "prompt-same-handle-after-restart",
        timeoutMs,
      );
      report.phases.promptSameHandleAfterRestart = { ok: true, stopReason: same?.stopReason ?? null };
    } catch (error) {
      report.phases.promptSameHandleAfterRestart = { ok: false, error: serializeError(error) };
    }

    sdk2 = await withTimeout(SandboxAgent.connect({ baseUrl, token }), "connect-secondary", timeoutMs);

    try {
      const events = await withTimeout(
        sdk2.getEvents({ sessionId: session.id, limit: 20 }),
        "getEvents",
        timeoutMs,
      );
      report.phases.getEvents = { ok: true, eventsObserved: events?.items?.length ?? null };
    } catch (error) {
      report.phases.getEvents = { ok: false, error: serializeError(error) };
    }

    try {
      resumed = await withTimeout(sdk1.resumeSession(session.id), "resumeSession", timeoutMs);
      report.phases.resumeSession = { ok: true };
    } catch (error) {
      report.phases.resumeSession = { ok: false, error: serializeError(error) };
    }

    if (resumed) {
      try {
        const after = await withTimeout(
          resumed.prompt([{ type: "text", text: "Return only POST-RESUME-OK" }]),
          "prompt-after-resume",
          timeoutMs,
        );
        report.phases.promptAfterResume = { ok: true, stopReason: after?.stopReason ?? null };
      } catch (error) {
        report.phases.promptAfterResume = { ok: false, error: serializeError(error) };
      }
    }

    report.ok = Boolean(
      report.phases.promptSameHandleAfterRestart?.ok && report.phases.promptAfterResume?.ok,
    );
  } finally {
    try {
      if (sdk1 && session) await sdk1.destroySession(session.id);
    } catch {}
    try {
      await sdk1?.dispose?.();
    } catch {}
    try {
      await sdk2?.dispose?.();
    } catch {}
  }

  return report;
}

async function runRecreateRehydrate() {
  const report = {
    scenario: "recreate_rehydrate",
    ok: false,
    phases: {},
  };

  let sdkBefore;
  let sdkAfter;
  let before;
  let after;

  const beforeId = `rehydrate-before-${Date.now()}`;
  const afterId = `rehydrate-after-${Date.now()}`;

  try {
    sdkBefore = await withTimeout(SandboxAgent.connect({ baseUrl, token }), "connect-before", timeoutMs);
    before = await withTimeout(
      sdkBefore.createSession({
        id: beforeId,
        agent,
        sessionInit: { cwd: "/", mcpServers: [] },
      }),
      "create-before",
      timeoutMs,
    );

    const p1 = "Nonce marker: NATIVE-RESTART-REPRO. Reply short.";
    const p2 = "Acknowledge restart test in one line.";

    await withTimeout(before.prompt([{ type: "text", text: p1 }]), "seed-prompt-1", timeoutMs);
    await withTimeout(before.prompt([{ type: "text", text: p2 }]), "seed-prompt-2", timeoutMs);
    report.phases.seedPrompts = { ok: true };

    await restartGate("recreate+rehydrate");

    sdkAfter = await withTimeout(SandboxAgent.connect({ baseUrl, token }), "connect-after", timeoutMs);
    after = await withTimeout(
      sdkAfter.createSession({
        id: afterId,
        agent,
        sessionInit: { cwd: "/", mcpServers: [] },
      }),
      "create-after",
      timeoutMs,
    );

    const rehydrate = [
      "Continuation context from pre-restart session:",
      `1) user: ${p1}`,
      `2) user: ${p2}`,
      "Continue with this context and reply with one short line.",
    ].join("\n");

    const out = await withTimeout(
      after.prompt([{ type: "text", text: rehydrate }]),
      "prompt-rehydrate",
      timeoutMs,
    );
    report.phases.promptRehydrate = { ok: true, stopReason: out?.stopReason ?? null };

    report.ok = true;
  } finally {
    try {
      if (sdkBefore && before) await sdkBefore.destroySession(before.id);
    } catch {}
    try {
      if (sdkAfter && after) await sdkAfter.destroySession(after.id);
    } catch {}
    try {
      await sdkBefore?.dispose?.();
    } catch {}
    try {
      await sdkAfter?.dispose?.();
    } catch {}
  }

  return report;
}

try {
  const native = await runNativeContinuity();
  const rehydrate = await runRecreateRehydrate();

  console.log(
    JSON.stringify(
      {
        baseUrl,
        agent,
        timeoutMs,
        waitSec,
        native,
        rehydrate,
      },
      null,
      2,
    ),
  );
} finally {
  await rl.close();
}

If useful, I can also provide this as a tiny public repo/gist with npm scripts.