Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

fix(coding-agent): don't block RLM subagent deletion on trace upload or a doomed kernel snapshot (#1954)

Sebastian Müller3da8c5a1c0ea
diff --git a/packages/coding-agent/.changes/eng-5837-detach-trace-flush-on-delete.md b/packages/coding-agent/.changes/eng-5837-detach-trace-flush-on-delete.md
new file mode 100644
index 0000000000..c9cae8526a
--- /dev/null
+++ b/packages/coding-agent/.changes/eng-5837-detach-trace-flush-on-delete.md
@@ -0,0 +1 @@
+- Session disposal no longer blocks on the final trace upload (uploads finish detached; daemon exit, update restarts, and worker archive-and-shutdown drain them through a single barrier), and deleting an RLM subagent no longer writes a kernel snapshot that the deletion sweep removes right away.
diff --git a/packages/coding-agent/src/core/agent-session-runtime.ts b/packages/coding-agent/src/core/agent-session-runtime.ts
index 6f1428474e..fd5465833e 100644
--- a/packages/coding-agent/src/core/agent-session-runtime.ts
+++ b/packages/coding-agent/src/core/agent-session-runtime.ts
@@ -7,7 +7,7 @@ import type {
AgentSessionRuntimeDiagnostic,
AgentSessionServices,
} from "./agent-session-services.js";
-import { flushAgentTraceUpload } from "./agent-traces.js";
+import { flushAgentTraceUpload, logDetachedAgentTraceFlushFailure } from "./agent-traces.js";
import { isNoModelsAvailableMessage } from "./auth-guidance.js";
import type { ReplacedSessionContext, SessionShutdownEvent, SessionStartEvent } from "./extensions/index.js";
import { emitSessionShutdownEvent } from "./extensions/runner.js";
@@ -61,6 +61,11 @@ function extractUserMessageText(content: string | Array<{ type: string; text?: s
.join("");
}
+export interface AgentSessionRuntimeDisposeOptions {
+ /** Set false when the session's artifact dir is deleted right after disposal (default true). */
+ kernelSnapshot?: boolean;
+}
+
export class AgentSessionRuntime implements SubagentRuntimeHost {
private rebindSession?: (session: AgentSession) => Promise<void>;
private readonly sessionReplacedListeners = new Set<(session: AgentSession) => void | Promise<void>>();
@@ -199,7 +204,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
reason,
targetSessionFile,
});
- await flushAgentTraceUpload(this.session.sessionManager).catch(() => undefined);
+ this.detachTraceFlush();
this.beforeSessionInvalidate?.();
// Await the kernel's final snapshot flush before invalidating the session.
await this.session.disposeAsync();
@@ -681,7 +686,14 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
return { cancelled: false };
}
- private async disposeOnce(): Promise<void> {
+ private detachTraceFlush(): void {
+ const sessionManager = this.session.sessionManager;
+ void flushAgentTraceUpload(sessionManager).catch((error) =>
+ logDetachedAgentTraceFlushFailure(sessionManager.getSessionFile(), error),
+ );
+ }
+
+ private async disposeOnce(options: AgentSessionRuntimeDisposeOptions): Promise<void> {
let disposeError: unknown;
try {
await emitSessionShutdownEvent(this.session.extensionRunner, {
@@ -691,11 +703,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
} catch (error) {
disposeError ??= error;
}
- try {
- await flushAgentTraceUpload(this.session.sessionManager);
- } catch (error) {
- disposeError ??= error;
- }
+ this.detachTraceFlush();
try {
this.beforeSessionInvalidate?.();
} catch (error) {
@@ -703,7 +711,7 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
}
try {
// Await the kernel's final snapshot flush before tearing the session down.
- await this.session.disposeAsync();
+ await this.session.disposeAsync({ kernelSnapshot: options.kernelSnapshot ?? true });
} catch (error) {
disposeError ??= error;
}
@@ -721,9 +729,9 @@ export class AgentSessionRuntime implements SubagentRuntimeHost {
}
}
- async dispose(): Promise<void> {
+ async dispose(options?: AgentSessionRuntimeDisposeOptions): Promise<void> {
if (!this.disposePromise) {
- this.disposePromise = this.disposeOnce();
+ this.disposePromise = this.disposeOnce(options ?? {});
}
await this.disposePromise;
}
diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.ts
index f2a7068e0a..39dab65732 100644
--- a/packages/coding-agent/src/core/agent-session.ts
+++ b/packages/coding-agent/src/core/agent-session.ts
@@ -3876,7 +3876,7 @@ export class AgentSession {
* (which flushes a final namespace snapshot) before the synchronous dispose, so
* the latest state reaches disk instead of racing process exit.
*/
- async disposeAsync(): Promise<void> {
+ async disposeAsync(options?: { kernelSnapshot?: boolean }): Promise<void> {
if (this._disposed) {
return this._disposeCallbacksPromise;
}
@@ -3885,6 +3885,7 @@ export class AgentSession {
if (this._disposeAsyncPromise) {
return this._disposeAsyncPromise;
}
+ const kernelSnapshot = options?.kernelSnapshot ?? true;
this._disposeAsyncPromise = (async () => {
// Drain before marking _disposing so a refine triggered at the final
// agent_end completes instead of being aborted by dispose().
@@ -3894,7 +3895,7 @@ export class AgentSession {
}
this._disposing = true;
this._sessionActionCommitDisposeAbortController.abort();
- await this._disposeAsyncOnce();
+ await this._disposeAsyncOnce(kernelSnapshot);
})();
return this._disposeAsyncPromise;
}
@@ -4031,7 +4032,7 @@ export class AgentSession {
}
}
- private async _disposeAsyncOnce(): Promise<void> {
+ private async _disposeAsyncOnce(kernelSnapshot: boolean): Promise<void> {
// Flush kernels/traces for both still-running and retained children; the sync
// dispose() below only tears them down synchronously.
for (const run of [...this._activeRlmChildRuns.values()]) {
@@ -4063,7 +4064,7 @@ export class AgentSession {
this._rlmChildCleanupFailures.clear();
this._deletedRlmChildIds.clear();
try {
- await this._ipythonKernelProvisioner?.dispose();
+ await this._ipythonKernelProvisioner?.dispose({ snapshot: kernelSnapshot });
} catch {
// a failed kernel startup already cleaned up after itself
}
diff --git a/packages/coding-agent/src/core/agent-traces.ts b/packages/coding-agent/src/core/agent-traces.ts
index 86479d2039..77b165b8d2 100644
--- a/packages/coding-agent/src/core/agent-traces.ts
+++ b/packages/coding-agent/src/core/agent-traces.ts
@@ -866,6 +866,7 @@ class AgentTraceUploadController {
schedule = (): void => {
this.pending = true;
+ pendingUploadControllers.add(this);
if (this.timeout) {
clearTimeout(this.timeout);
}
@@ -908,6 +909,9 @@ class AgentTraceUploadController {
return await this.flushPromise;
} finally {
this.flushPromise = undefined;
+ if (!this.pending) {
+ pendingUploadControllers.delete(this);
+ }
}
}
@@ -948,6 +952,8 @@ class AgentTraceUploadController {
}
const traceUploadControllers = new WeakMap<SessionManager, AgentTraceUploadController>();
+// Disposal never awaits uploads; exit paths drain this set instead.
+const pendingUploadControllers = new Set<AgentTraceUploadController>();
export function installAgentTraceUpload(sessionManager: SessionManager, options: AgentTraceUploadInstallOptions): void {
let controller = traceUploadControllers.get(sessionManager);
@@ -966,3 +972,17 @@ export async function flushAgentTraceUpload(
): Promise<AgentTraceUploadResult | undefined> {
return traceUploadControllers.get(sessionManager)?.flush();
}
+
+/** Exit barrier: drains every scheduled or in-flight trace upload. */
+export async function flushAllPendingAgentTraceUploads(): Promise<void> {
+ await Promise.allSettled([...pendingUploadControllers].map((controller) => controller.flush()));
+}
+
+/** Log a detached (fire-and-forget) flush rejection; upload outcomes themselves are already logged per attempt. */
+export function logDetachedAgentTraceFlushFailure(sessionFile: string | undefined, error: unknown): void {
+ const suffix = sessionFile ? ` [${sessionFile}]` : "";
+ appendRotatingLog(
+ getAgentTracesLogPath(),
+ `[${new Date().toISOString()}] detached flush failed: ${describeError(error)}${suffix}`,
+ );
+}
diff --git a/packages/coding-agent/src/core/tools/ipython.ts b/packages/coding-agent/src/core/tools/ipython.ts
index 485c236cc5..6c8501b928 100644
--- a/packages/coding-agent/src/core/tools/ipython.ts
+++ b/packages/coding-agent/src/core/tools/ipython.ts
@@ -311,6 +311,8 @@ export class IpythonKernelProvisioner {
private lastStartupMessage?: string;
private _lastRestore?: RestoreResult;
private readonly disposeController = new AbortController();
+ /** Snapshot policy of the dispose that aborted a startup, honored by startKernel's failure teardown. */
+ private disposeSnapshot = true;
constructor(
private readonly cwd: string,
@@ -351,7 +353,8 @@ export class IpythonKernelProvisioner {
}
/** Dispose the kernel owned by this provisioner, including one still starting up. */
- async dispose(): Promise<void> {
+ async dispose(options?: { snapshot?: boolean }): Promise<void> {
+ this.disposeSnapshot = options?.snapshot ?? true;
// Drops a still-queued boot out of the semaphore and short-circuits an
// in-flight startKernel before it spawns, so a disposed session's boot
// doesn't waste a slot during a fan-out.
@@ -362,7 +365,7 @@ export class IpythonKernelProvisioner {
if (!pending) return;
try {
const m = await pending;
- await m.shutdown({ snapshot: true, drainHostRequests: true });
+ await m.shutdown({ snapshot: this.disposeSnapshot, drainHostRequests: true });
} catch {
// a failed startup already cleaned up after itself
}
@@ -514,7 +517,7 @@ export class IpythonKernelProvisioner {
// surface the failure before the teardown (final snapshot flush included)
// finished, or a replacement provisioner gated on this dispose could
// race the still-flushing kernel over the same snapshot files.
- await m.shutdown({ snapshot: true, drainHostRequests: true }).catch(() => undefined);
+ await m.shutdown({ snapshot: this.disposeSnapshot, drainHostRequests: true }).catch(() => undefined);
throw error;
}
// Only tell the model what was revived once the kernel is actually usable —
diff --git a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
index b3d4986e28..9fc5851d1e 100644
--- a/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
+++ b/packages/coding-agent/src/modes/agent-connection/in-process-agent-connection.ts
@@ -3,6 +3,7 @@ import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core"
import type { ImageContent, ServiceTier, Transport } from "@earendil-works/pi-ai";
import type { AgentSessionMessageReceipt, AgentSessionMessageSafetyStatus } from "../../core/agent-messages.js";
import type { AgentSessionRuntime } from "../../core/agent-session-runtime.js";
+import { flushAllPendingAgentTraceUploads } from "../../core/agent-traces.js";
import type { AgentAutonomousStatus } from "../../core/autonomous.js";
import type { BashResult } from "../../core/bash-executor.js";
import type { CompactionResult } from "../../core/compaction/index.js";
@@ -633,7 +634,11 @@ export class InProcessAgentConnection implements AgentConnection {
this.runtimeHost.setBeforeSessionInvalidate(undefined);
}
this.runtimeHost.setRebindSession(undefined);
- await this.runtimeHost.dispose();
+ try {
+ await this.runtimeHost.dispose();
+ } finally {
+ await flushAllPendingAgentTraceUploads();
+ }
}
private get session() {
diff --git a/packages/coding-agent/src/modes/daemon/daemon-mode.ts b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
index 1fb2dbdac0..b99c047ccf 100644
--- a/packages/coding-agent/src/modes/daemon/daemon-mode.ts
+++ b/packages/coding-agent/src/modes/daemon/daemon-mode.ts
@@ -68,10 +68,12 @@ import { type PromptOptions, rlmChildLabel } from "../../core/agent-session.js";
import { type AgentSessionRuntimeConfig, mergeAgentSessionRuntimeConfig } from "../../core/agent-session-config.js";
import {
type AgentSessionRuntime,
+ type AgentSessionRuntimeDisposeOptions,
type AgentSessionRuntimeMetadata,
type CreateAgentSessionRuntimeFactory,
createAgentSessionRuntime,
} from "../../core/agent-session-runtime.js";
+import { flushAllPendingAgentTraceUploads } from "../../core/agent-traces.js";
import {
type AgentCronJob,
AgentCronJobStore,
@@ -2371,11 +2373,19 @@ export class AgentDaemon {
candidate.runtime.metadata.rlmChildId === options.id &&
candidate.runtime.session === runtime.session,
);
+ const disposal = status === "cancelled" ? { kernelSnapshot: false } : undefined;
try {
if (state) {
- await this.closeSession(state, status === "cancelled" ? "killed" : "completed");
+ await this.closeSession(
+ state,
+ status === "cancelled" ? "killed" : "completed",
+ true,
+ true,
+ undefined,
+ disposal,
+ );
} else {
- await runtime.session.disposeAsync();
+ await runtime.session.disposeAsync(disposal);
}
} finally {
// Sweep even when teardown throws (see deleteRlmSubagentRuntime);
@@ -2432,12 +2442,12 @@ export class AgentDaemon {
try {
try {
if (state) {
- await this.closeSession(state, "killed", false);
+ await this.closeSession(state, "killed", false, true, undefined, { kernelSnapshot: false });
} else {
- await session?.disposeAsync();
+ await session?.disposeAsync({ kernelSnapshot: false });
}
} finally {
- await staleSession?.disposeAsync();
+ await staleSession?.disposeAsync({ kernelSnapshot: false });
}
} finally {
// Runs even when teardown throws: the jobs-cancel rewrite and the
@@ -3662,6 +3672,7 @@ export class AgentDaemon {
for (const state of [...this.sessions.values()]) {
await this.closeSession(state, "killed");
}
+ await flushAllPendingAgentTraceUploads();
this.fencePeerTransports();
this.writeWorkerSuccess(client, command);
setImmediate(() => void this.shutdown(0));
@@ -6245,6 +6256,7 @@ export class AgentDaemon {
}
}
for (const state of [...this.sessions.values()]) await this.closeSession(state, "killed");
+ await flushAllPendingAgentTraceUploads();
return manifest;
}
@@ -6337,6 +6349,7 @@ export class AgentDaemon {
waitForAbort = true,
cascadeChildren = true,
descendantCollector?: Set<ActiveSessionState>,
+ disposal?: AgentSessionRuntimeDisposeOptions,
): Promise<void> {
this.abortWaitingPromptAdmissionsForSession(state.activeSessionId);
for (const client of state.clients) {
@@ -6375,7 +6388,7 @@ export class AgentDaemon {
}
const descendants = new Set<ActiveSessionState>();
const closePromise = Promise.resolve().then(() =>
- this.closeSessionOnce(state, reason, waitForAbort, cascadeChildren, descendants),
+ this.closeSessionOnce(state, reason, waitForAbort, cascadeChildren, descendants, disposal),
);
const close = { promise: closePromise, reason, descendants };
this.closingSessions.set(state.activeSessionId, close);
@@ -6448,6 +6461,7 @@ export class AgentDaemon {
waitForAbort: boolean,
cascadeChildren: boolean,
descendants: Set<ActiveSessionState>,
+ disposal?: AgentSessionRuntimeDisposeOptions,
): Promise<void> {
if (!this.sessions.has(state.activeSessionId)) {
return;
@@ -6461,7 +6475,7 @@ export class AgentDaemon {
// agent_status to a session being torn down.
this.summarizer.forget(state.activeSessionId);
const cascadeError = cascadeChildren
- ? await this.closeChildSessions(state, reason, waitForAbort, descendants)
+ ? await this.closeChildSessions(state, reason, waitForAbort, descendants, disposal)
: undefined;
// Empty draft (no messages, config, or jobs): discard rather than persist an
// empty session file. Mirrors the detach-time discard so a config-bearing
@@ -6496,7 +6510,7 @@ export class AgentDaemon {
state.unsubscribe?.();
let disposeError: unknown;
try {
- await state.runtime.dispose();
+ await state.runtime.dispose(disposal);
} catch (error) {
disposeError = error;
}
@@ -6538,12 +6552,13 @@ export class AgentDaemon {
reason: DaemonSessionClosedReason,
waitForAbort = true,
descendants = new Set<ActiveSessionState>(),
+ disposal?: AgentSessionRuntimeDisposeOptions,
): Promise<unknown> {
let cascadeError: unknown;
for (const childState of getChildActiveSessionStates(this.sessions, parentState)) {
descendants.add(childState);
try {
- await this.closeSession(childState, reason, waitForAbort, true, descendants);
+ await this.closeSession(childState, reason, waitForAbort, true, descendants, disposal);
} catch (error) {
cascadeError ??= error;
}
@@ -7289,8 +7304,12 @@ export class AgentDaemon {
cleanup();
}
this.cronScheduler.stop();
- for (const state of [...this.sessions.values()]) {
- await this.closeSession(state, closingReason);
+ try {
+ for (const state of [...this.sessions.values()]) {
+ await this.closeSession(state, closingReason);
+ }
+ } finally {
+ await flushAllPendingAgentTraceUploads();
}
for (const client of this.clients) {
client.detachInput();
diff --git a/packages/coding-agent/test/agent-connection-in-process.test.ts b/packages/coding-agent/test/agent-connection-in-process.test.ts
index beb868cb0c..aa36e58bc4 100644
--- a/packages/coding-agent/test/agent-connection-in-process.test.ts
+++ b/packages/coding-agent/test/agent-connection-in-process.test.ts
@@ -1,9 +1,17 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
import type { AgentMessage } from "@earendil-works/pi-agent-core";
import { getModel } from "@earendil-works/pi-ai";
import { describe, expect, it, vi } from "vitest";
import type { AgentSessionEvent, AgentSessionEventListener, PromptOptions } from "../src/core/agent-session.js";
import type { AgentSessionRuntime } from "../src/core/agent-session-runtime.js";
+import { installAgentTraceUpload } from "../src/core/agent-traces.js";
+import { AuthStorage } from "../src/core/auth-storage.js";
import { emptyGoalState } from "../src/core/goals.js";
+import { PRIME_AGENT_TRACES_PROVIDER_ID } from "../src/core/prime-inference-auth.js";
+import { SessionManager } from "../src/core/session-manager.js";
+import { SettingsManager } from "../src/core/settings-manager.js";
import { InProcessAgentConnection } from "../src/modes/agent-connection/in-process-agent-connection.js";
import type { AgentConnectionEvent, AgentConnectionState } from "../src/modes/agent-connection/types.js";
@@ -143,6 +151,56 @@ function createFakeSession(id: string, messages: AgentMessage[]): FakeSessionCon
}
describe("InProcessAgentConnection", () => {
+ it("drains pending trace uploads even when runtime disposal throws", async () => {
+ const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-in-process-dispose-"));
+ try {
+ const sessionManager = SessionManager.create(tempDir, join(tempDir, "sessions"));
+ sessionManager.newSession();
+ const calls: string[] = [];
+ let releaseFetch: () => void = () => {};
+ const gate = new Promise<void>((resolve) => {
+ releaseFetch = resolve;
+ });
+ installAgentTraceUpload(sessionManager, {
+ authStorage: AuthStorage.inMemory({
+ [PRIME_AGENT_TRACES_PROVIDER_ID]: { type: "api_key", key: "trace-key" },
+ }),
+ settingsManager: SettingsManager.inMemory({ agentTraces: { enabled: true } }),
+ baseUrl: "https://api.example.test",
+ fetchFn: (async (input: unknown) => {
+ calls.push(String(input));
+ await gate;
+ return new Response(JSON.stringify({ bytes_stored: 1 }), {
+ status: 200,
+ headers: { "content-type": "application/json" },
+ });
+ }) as typeof fetch,
+ });
+ sessionManager.appendMessage({ role: "user", content: "pending trace data", timestamp: 1 });
+ sessionManager.flushNow();
+
+ const control = createFakeSession("dispose-throws", []);
+ const runtime = new FakeRuntime(control.session);
+ runtime.dispose = async () => {
+ throw new Error("teardown failed");
+ };
+ const connection = new InProcessAgentConnection(asRuntime(runtime));
+
+ let settledError: Error | undefined;
+ const disposal = connection.dispose().catch((error: Error) => {
+ settledError = error;
+ return error;
+ });
+ await vi.waitFor(() => expect(calls).toHaveLength(1));
+ expect(settledError).toBeUndefined();
+ releaseFetch();
+ await expect(disposal).resolves.toMatchObject({ message: "teardown failed" });
+ expect(calls).toHaveLength(1);
+ } finally {
+ rmSync(tempDir, { recursive: true, force: true });
+ }
+ });
+
it.each([
{ accepted: true, promptResult: "pending", expectedError: undefined },
{ accepted: false, promptResult: "resolve", expectedError: "Prompt was not accepted by the session." },
diff --git a/packages/coding-agent/test/agent-session-concurrent.test.ts b/packages/coding-agent/test/agent-session-concurrent.test.ts
index d7b91eb638..1c8a6f950f 100644
--- a/packages/coding-agent/test/agent-session-concurrent.test.ts
+++ b/packages/coding-agent/test/agent-session-concurrent.test.ts
@@ -188,6 +188,15 @@ describe("AgentSession concurrent prompt guard", () => {
expect(disposed).toBe(true);
});
+ it("forwards kernelSnapshot: false to the kernel provisioner during disposal", async () => {
+ createSession();
+ const dispose = vi.fn(async () => {});
+ Reflect.set(session, "_ipythonKernelProvisioner", { dispose });
+
+ await session.disposeAsync({ kernelSnapshot: false });
+ expect(dispose).toHaveBeenCalledWith({ snapshot: false });
+ });
+
it("should throw when prompt() called while streaming", async () => {
createSession();
diff --git a/packages/coding-agent/test/agent-traces.test.ts b/packages/coding-agent/test/agent-traces.test.ts
index 1648e2812c..7694cd8e30 100644
--- a/packages/coding-agent/test/agent-traces.test.ts
+++ b/packages/coding-agent/test/agent-traces.test.ts
@@ -8,6 +8,7 @@ import { ENV_AGENT_DIR, getAgentTracesLogPath } from "../src/config.js";
import {
findAgentTraceFiles,
flushAgentTraceUpload,
+ flushAllPendingAgentTraceUploads,
installAgentTraceUpload,
previewAgentTraceFile,
uploadAgentTraceFile,
@@ -387,6 +388,55 @@ describe("agent trace upload", () => {
expect(calls).toHaveLength(1);
});
+ it("drains scheduled and in-flight uploads through the exit barrier", async () => {
+ const cwd = join(tempDir, "project");
+ const sessionDir = join(tempDir, "sessions");
+ mkdirSync(cwd, { recursive: true });
+ let releaseFetch: () => void = () => {};
+ const gate = new Promise<void>((resolve) => {
+ releaseFetch = resolve;
+ });
+ const calls: string[] = [];
+ const fetchFn: typeof fetch = async (input) => {
+ calls.push(String(input));
+ await gate;
+ return new Response(JSON.stringify({ bytes_stored: 1 }), {
+ status: 200,
+ headers: { "content-type": "application/json" },
+ });
+ };
+ const install = (sessionManager: SessionManager) => {
+ installAgentTraceUpload(sessionManager, {
+ authStorage: AuthStorage.inMemory({
+ [PRIME_AGENT_TRACES_PROVIDER_ID]: { type: "api_key", key: "trace-key" },
+ }),
+ settingsManager: SettingsManager.inMemory({ agentTraces: { enabled: true } }),
+ baseUrl: "https://api.example.test",
+ fetchFn,
+ });
+ sessionManager.appendMessage(createUserMessage("hello"));
+ sessionManager.appendMessage(createAssistantMessage("hi"));
+ };
+ const scheduled = SessionManager.create(cwd, sessionDir);
+ scheduled.newSession({ id: "barrier-scheduled" });
+ install(scheduled);
+ const inFlight = SessionManager.create(cwd, sessionDir);
+ inFlight.newSession({ id: "barrier-in-flight" });
+ install(inFlight);
+ const detached = flushAgentTraceUpload(inFlight);
+
+ let drained = false;
+ const barrier = flushAllPendingAgentTraceUploads().then(() => {
+ drained = true;
+ });
+ await vi.waitFor(() => expect(calls).toHaveLength(2));
+ expect(drained).toBe(false);
+ releaseFetch();
+ await barrier;
+ await detached;
+ expect(calls).toHaveLength(2);
+ });
+
it("schedules automatic uploads at most once per minute and only after new entries persist", async () => {
vi.useFakeTimers();
const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");
diff --git a/packages/coding-agent/test/daemon-mode.test.ts b/packages/coding-agent/test/daemon-mode.test.ts
index 21b469a3ee..2fe4077d06 100644
--- a/packages/coding-agent/test/daemon-mode.test.ts
+++ b/packages/coding-agent/test/daemon-mode.test.ts
@@ -24,7 +24,10 @@ import {
} from "../src/core/agent-messages.js";
import type { AgentObserveController } from "../src/core/agent-observe.js";
import type { CreateAgentSessionRuntimeFactory } from "../src/core/agent-session-runtime.js";
+import { flushAgentTraceUpload, installAgentTraceUpload } from "../src/core/agent-traces.js";
+import { AuthStorage } from "../src/core/auth-storage.js";
import type { AgentCronJob, AgentCronJobStore } from "../src/core/cron-jobs.js";
+import { PRIME_AGENT_TRACES_PROVIDER_ID } from "../src/core/prime-inference-auth.js";
import {
type CreateRlmSubagentRuntimeOptions,
createDefaultRlmSubagentSessionName,
@@ -32,6 +35,7 @@ import {
} from "../src/core/rlm-runtime.js";
import { canonicalSessionPath } from "../src/core/session-lease.js";
import { readSessionInfo, type SessionInfo, SessionManager } from "../src/core/session-manager.js";
+import { SettingsManager } from "../src/core/settings-manager.js";
import type { ActiveSessionState, DaemonSocketClient } from "../src/modes/daemon/active-session-state.js";
import {
AgentDaemon,
@@ -852,7 +856,7 @@ describe("daemon mode helpers", () => {
);
expect(recordDeletion).not.toHaveBeenCalled();
- expect(closeSession).toHaveBeenCalledWith(childState, "completed");
+ expect(closeSession).toHaveBeenCalledWith(childState, "completed", true, true, undefined, undefined);
internals.sessions.set(childState.activeSessionId, childState);
await internals
.createSubagentRuntimeHost(parentState)
@@ -863,7 +867,9 @@ describe("daemon mode helpers", () => {
);
expect(recordDeletion).toHaveBeenCalledWith(parentState, "child-1", "revoked");
expect(recordDeletion.mock.invocationCallOrder[0]).toBeLessThan(closeSession.mock.invocationCallOrder[1]!);
- expect(closeSession).toHaveBeenLastCalledWith(childState, "killed");
+ expect(closeSession).toHaveBeenLastCalledWith(childState, "killed", true, true, undefined, {
+ kernelSnapshot: false,
+ });
expect(internals.sessions.has(childState.activeSessionId)).toBe(false);
// A registry failure must not strand the cancelled child as a stale resident session.
@@ -880,7 +886,9 @@ describe("daemon mode helpers", () => {
"cancelled",
),
).rejects.toThrow("registry write failed");
- expect(closeSession).toHaveBeenLastCalledWith(childState, "killed");
+ expect(closeSession).toHaveBeenLastCalledWith(childState, "killed", true, true, undefined, {
+ kernelSnapshot: false,
+ });
expect(internals.sessions.has(childState.activeSessionId)).toBe(false);
});
@@ -1409,7 +1417,9 @@ describe("daemon mode helpers", () => {
await host.deleteRlmSubagentRuntime("child-1", staleParentReference);
expect(closeSession).toHaveBeenCalledOnce();
- expect(closeSession).toHaveBeenCalledWith(childState, "killed", false);
+ expect(closeSession).toHaveBeenCalledWith(childState, "killed", false, true, undefined, {
+ kernelSnapshot: false,
+ });
expect(closeSession).not.toHaveBeenCalledWith(foreignChildState, expect.anything());
expect(childSession.disposeAsync).not.toHaveBeenCalled();
expect(staleParentReference.disposeAsync).toHaveBeenCalledOnce();
@@ -6505,6 +6515,84 @@ describe("daemon mode helpers", () => {
}
});
+ it("deletes a resident child without awaiting its pending trace upload and skips the doomed kernel snapshot", async () => {
+ const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-delete-trace-flush-"));
+ try {
+ const fixture = makePersistedRlmDaemonFixture(tempDir);
+ const internals = fixture.daemon as unknown as {
+ createRuntime(command: Extract<DaemonCommand, { type: "create" }>): Promise<ActiveSessionState>;
+ createSubagentRuntimeHost(parent: ActiveSessionState): SubagentRuntimeHost;
+ };
+ const parentState = await internals.createRuntime({ type: "create", sessionPath: fixture.parentSessionFile });
+ const childState = await internals.createRuntime({ type: "create", sessionPath: fixture.childSessionFile });
+ const childManager = childState.runtime.session.sessionManager as SessionManager;
+ const { calls, releaseFetch } = installGatedTraceUpload(childManager);
+ childManager.appendMessage({ role: "user", content: "pending trace data", timestamp: 3 });
+ childManager.flushNow();
+
+ // The fetch gate is still held: the delete must not await the upload.
+ await internals
+ .createSubagentRuntimeHost(parentState)
+ .deleteRlmSubagentRuntime(fixture.childId, childState.runtime.session);
+
+ await vi.waitFor(() => expect(calls).toHaveLength(1));
+ expect(childState.runtime.session.disposeAsync).toHaveBeenCalledWith({ kernelSnapshot: false });
+ releaseFetch();
+ await flushAgentTraceUpload(childManager);
+ expect(calls).toHaveLength(1);
+ } finally {
+ rmSync(tempDir, { recursive: true, force: true });
+ }
+ });
+
+ it("resolves a delete that joins an in-flight passivation close without awaiting the trace upload", async () => {
+ const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-delete-passivation-flush-"));
+ let releaseDispose!: () => void;
+ const disposeGate = new Promise<void>((resolve) => {
+ releaseDispose = resolve;
+ });
+ let markDisposeStarted!: () => void;
+ const disposeStarted = new Promise<void>((resolve) => {
+ markDisposeStarted = resolve;
+ });
+ try {
+ const fixture = makePersistedRlmDaemonFixture(tempDir, {
+ childDisposeStarted: markDisposeStarted,
+ childDisposeGate: disposeGate,
+ });
+ const internals = fixture.daemon as unknown as {
+ createRuntime(command: Extract<DaemonCommand, { type: "create" }>): Promise<ActiveSessionState>;
+ createSubagentRuntimeHost(parent: ActiveSessionState): SubagentRuntimeHost;
+ passivateIdleChildren(threshold: number, now: number, limit: number): Promise<number>;
+ };
+ const parentState = await internals.createRuntime({ type: "create", sessionPath: fixture.parentSessionFile });
+ const childState = await internals.createRuntime({ type: "create", sessionPath: fixture.childSessionFile });
+ (
+ parentState.runtime.session as unknown as { releaseRlmChildSession: ReturnType<typeof vi.fn> }
+ ).releaseRlmChildSession = vi.fn(() => vi.fn());
+ const childManager = childState.runtime.session.sessionManager as SessionManager;
+ const { calls, releaseFetch } = installGatedTraceUpload(childManager);
+ childManager.appendMessage({ role: "user", content: "pending trace data", timestamp: 3 });
+ childManager.flushNow();
+
+ const passivation = internals.passivateIdleChildren(90, Date.parse("2036-08-01T12:00:00Z"), 1);
+ await disposeStarted;
+ const deletion = internals
+ .createSubagentRuntimeHost(parentState)
+ .deleteRlmSubagentRuntime(fixture.childId, childState.runtime.session);
+ releaseDispose();
+ // Both resolve while the fetch gate is still held.
+ await Promise.all([passivation, deletion]);
+ expect(calls).toHaveLength(1);
+ expect(childState.runtime.session.disposeAsync).toHaveBeenCalledWith({ kernelSnapshot: true });
+ releaseFetch();
+ await flushAgentTraceUpload(childManager);
+ } finally {
+ releaseDispose();
+ rmSync(tempDir, { recursive: true, force: true });
+ }
+ });
+
// chmod-based read-only dirs don't block root, so skip when running as uid 0.
it.skipIf(process.getuid?.() === 0)("does not fail a deletion when the artifact dir cannot be removed", async () => {
const tempDir = mkdtempSync(join(tmpdir(), "prime-agent-daemon-artifact-rm-failure-"));
@@ -8925,6 +9013,34 @@ function makeCronJob(input: {
};
}
+/** Gated fetch stub on a session's trace-upload controller: observes whether a close awaits the upload. */
+function installGatedTraceUpload(sessionManager: SessionManager): {
+ calls: string[];
+ releaseFetch: () => void;
+} {
+ const calls: string[] = [];
+ let releaseFetch: () => void = () => {};
+ const gate = new Promise<void>((resolveGate) => {
+ releaseFetch = resolveGate;
+ });
+ installAgentTraceUpload(sessionManager, {
+ authStorage: AuthStorage.inMemory({
+ [PRIME_AGENT_TRACES_PROVIDER_ID]: { type: "api_key", key: "trace-key" },
+ }),
+ settingsManager: SettingsManager.inMemory({ agentTraces: { enabled: true } }),
+ baseUrl: "https://api.example.test",
+ fetchFn: (async (input: unknown) => {
+ calls.push(String(input));
+ await gate;
+ return new Response(JSON.stringify({ bytes_stored: 1 }), {
+ status: 200,
+ headers: { "content-type": "application/json" },
+ });
+ }) as typeof fetch,
+ });
+ return { calls, releaseFetch };
+}
+
function makePersistedRlmDaemonFixture(
tempDir: string,
options: {
diff --git a/packages/coding-agent/test/ipython-provisioner.test.ts b/packages/coding-agent/test/ipython-provisioner.test.ts
index ed32aab28e..02bb0ef4a8 100644
--- a/packages/coding-agent/test/ipython-provisioner.test.ts
+++ b/packages/coding-agent/test/ipython-provisioner.test.ts
@@ -65,8 +65,21 @@ function createBusyKernelContext(
return { ctx, setWorkingMessage };
}
-function writeFakeReplRuntime(markerPath: string): string {
+function writeFakeReplRuntime(
+ markerPath: string,
+ options: { gatedExecute?: { startedPath: string; gatePath: string } } = {},
+): string {
const python = join(tempDir, "python-repl");
+ const refuse = `emit({ event: "error", id: request.id, ename: "RuntimeError", evalue: "bootstrap refused", traceback: [] });
+ emit({ event: "done", id: request.id, status: "error" });`;
+ const executeBranch = options.gatedExecute
+ ? `fs.writeFileSync(${JSON.stringify(options.gatedExecute.startedPath)}, "1");
+ const gate = setInterval(() => {
+ if (!fs.existsSync(${JSON.stringify(options.gatedExecute.gatePath)})) return;
+ clearInterval(gate);
+ ${refuse}
+ }, 10);`
+ : refuse;
writeFileSync(
python,
`#!/usr/bin/env node
@@ -89,8 +102,7 @@ input.on("line", (line) => {
return;
}
if (request.type === "execute") {
- emit({ event: "error", id: request.id, ename: "RuntimeError", evalue: "bootstrap refused", traceback: [] });
- emit({ event: "done", id: request.id, status: "error" });
+ ${executeBranch}
return;
}
if (request.type === "shutdown") {
@@ -186,6 +198,35 @@ describe("IpythonKernelProvisioner", () => {
expect(provisioner.manager).toBeUndefined();
});
+ it("skips the snapshot when dispose({ snapshot: false }) aborts a startup in flight", async () => {
+ const marker = join(tempDir, "snapshot-flushed");
+ const executeStarted = join(tempDir, "execute-started");
+ const executeGate = join(tempDir, "execute-gate");
+ const snapshotDir = join(tempDir, "snapshots");
+ mkdirSync(snapshotDir, { recursive: true });
+ const python = writeFakeReplRuntime(marker, {
+ gatedExecute: { startedPath: executeStarted, gatePath: executeGate },
+ });
+ const provisioner = new IpythonKernelProvisioner(tempDir, { python, snapshotDir });
+
+ const started = provisioner.ensure().catch(() => undefined);
+ await vi.waitFor(() => expect(existsSync(executeStarted)).toBe(true));
+ const disposed = provisioner.dispose({ snapshot: false });
+ writeFileSync(executeGate, "1");
+ await Promise.all([disposed, started]);
+ expect(existsSync(marker)).toBe(false);
+ });
+
+ it("dispose({ snapshot: false }) skips the kernel's final snapshot flush", async () => {
+ const { python } = writeFakePython();
+ const provisioner = new IpythonKernelProvisioner(tempDir, { python });
+ const shutdown = vi.fn(async () => {});
+ Reflect.set(provisioner, "managerPromise", Promise.resolve({ shutdown }));
+
+ await provisioner.dispose({ snapshot: false });
+ expect(shutdown).toHaveBeenCalledWith({ snapshot: false, drainHostRequests: true });
+ });
+
it("dispose() before the boot slot prevents the kernel from spawning", async () => {
const { python, countRuns } = writeFakePython();
let release: () => void = () => {};