Skip to content

armgit / alook

Public Imported from GitHub
0

Multi-Agent Collaboration for Team and Friends

fix(daemon): preserve queued delivery and migrate Pi runtime (#951)

Gener2aa1e0a6d6e6
diff --git a/.github/workflows/windows-runtime.yml b/.github/workflows/windows-runtime.yml
index 9688647f7..2f3f690d6 100644
--- a/.github/workflows/windows-runtime.yml
+++ b/.github/workflows/windows-runtime.yml
@@ -55,7 +55,7 @@ jobs:
$qaPrefix = Join-Path $env:RUNNER_TEMP 'Alook npm QA'
npm install --global --prefix "$qaPrefix" @openai/[email protected] [email protected] @anthropic-ai/[email protected]
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
- npm install --global --ignore-scripts --prefix "$qaPrefix" @earendil-works/[email protected]
+ npm install --global --ignore-scripts --prefix "$qaPrefix" @earendil-works/[email protected]
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
"ALOOK_NATIVE_NPM_PREFIX=$qaPrefix" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
- name: Install official native Cursor and Grok binaries
@@ -90,4 +90,85 @@ jobs:
Expand-Archive $agyZip -DestinationPath $env:ALOOK_NATIVE_NPM_PREFIX -Force
if (-not (Test-Path (Join-Path $env:ALOOK_NATIVE_NPM_PREFIX 'agy_acp_server.exe'))) { throw 'Missing Antigravity ACP entry' }
- name: Exercise real detection, persistent startup and cleanup
- run: pnpm --filter @alook/agent-driver exec vitest run src/internal/probe.test.ts src/internal/probe.windows.test.ts src/internal/killTree.windows-errors.test.ts src/adapters/antigravity/index.test.ts --no-file-parallelism
+ shell: pwsh
+ run: |
+ $evidenceDir = Join-Path $env:RUNNER_TEMP 'Alook runtime evidence'
+ New-Item -ItemType Directory -Force $evidenceDir | Out-Null
+ pnpm --filter @alook/agent-driver exec vitest run src/internal/probe.test.ts src/internal/probe.windows.test.ts src/internal/killTree.windows-errors.test.ts src/adapters/antigravity/index.test.ts --no-file-parallelism 2>&1 | Tee-Object -FilePath (Join-Path $evidenceDir 'native-suite.log')
+ $suiteExit = $LASTEXITCODE
+ @{ exitCode = $suiteExit; checkout = $env:GITHUB_SHA; runId = $env:GITHUB_RUN_ID; attempt = $env:GITHUB_RUN_ATTEMPT } | ConvertTo-Json | Set-Content -Path (Join-Path $evidenceDir 'native-suite-terminal.json') -Encoding utf8
+ exit $suiteExit
+ - name: Save the actual installed Pi dependency and public export evidence
+ if: always()
+ shell: pwsh
+ run: |
+ $evidenceDir = Join-Path $env:RUNNER_TEMP 'Alook runtime evidence'
+ New-Item -ItemType Directory -Force $evidenceDir | Out-Null
+ npm ls --global --prefix "$env:ALOOK_NATIVE_NPM_PREFIX" --all --json | Out-File -FilePath (Join-Path $evidenceDir 'native-dependencies.json') -Encoding utf8
+ $dependencyExit = $LASTEXITCODE
+ $piAudit = @'
+ import { createHash } from "node:crypto";
+ import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+ import { findPackageJSON } from "node:module";
+ import { dirname, join } from "node:path";
+ import { pathToFileURL } from "node:url";
+ import { execFileSync } from "node:child_process";
+ const evidence = join(process.env.RUNNER_TEMP, "Alook runtime evidence");
+ const output = join(evidence, "pi-installed-public-api.json");
+ const result = { node: process.version, checkout: execFileSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).trim(),
+ tree: execFileSync("git", ["rev-parse", "HEAD^{tree}"], { encoding: "utf8" }).trim(), packages: [], importStatus: "UNRUN" };
+ const sha = bytes => createHash("sha256").update(bytes).digest("hex");
+ const targets = value => typeof value === "string" ? [value] : value && typeof value === "object" ? Object.values(value).flatMap(targets) : [];
+ try {
+ const rootManifest = join(process.env.ALOOK_NATIVE_NPM_PREFIX, "node_modules", "@earendil-works", "pi-coding-agent", "package.json");
+ const root = JSON.parse(readFileSync(rootManifest, "utf8"));
+ const rootEntry = join(dirname(rootManifest), root.exports?.["."]?.import ?? root.main);
+ const consumer = pathToFileURL(rootEntry);
+ for (const name of [root.name, ...Object.keys(root.dependencies).filter(name => name.startsWith("@earendil-works/pi-"))]) {
+ const manifestPath = name === root.name ? rootManifest : findPackageJSON(name, consumer);
+ if (!manifestPath) throw new Error("Missing installed manifest: " + name);
+ const bytes = readFileSync(manifestPath);
+ const pkg = JSON.parse(bytes);
+ const required = name === root.name ? ["dist/index.js", "dist/index.d.ts", "dist/core/model-runtime.js", "dist/core/model-runtime.d.ts", "dist/core/sdk.js", "dist/core/sdk.d.ts", "dist/core/session-manager.js", "dist/core/session-manager.d.ts"] : [];
+ const paths = [...new Set([...targets(pkg.exports), pkg.main, pkg.types, ...required].filter(value => typeof value === "string"))];
+ const files = paths.map(target => {
+ const file = join(dirname(manifestPath), target);
+ if (!existsSync(file)) return { target, missing: true };
+ const bytes = readFileSync(file);
+ return { target, path: realpathSync(file), bytes: bytes.length, sha256: sha(bytes) };
+ });
+ result.packages.push({ name: pkg.name, version: pkg.version, manifestPath: realpathSync(manifestPath),
+ manifestSHA256: sha(bytes), dependencies: pkg.dependencies, exports: pkg.exports, files });
+ }
+ writeFileSync(output, JSON.stringify(result, null, 2) + "\n");
+ if (root.version !== "1.2.0") throw new Error("Unexpected Pi version: " + root.version);
+ const sdk = await import(consumer.href);
+ result.publicExports = Object.keys(sdk).sort();
+ result.requiredFunctions = { createModelRuntime: typeof sdk.ModelRuntime?.create,
+ getModel: typeof sdk.ModelRuntime?.prototype.getModel, setRuntimeApiKey: typeof sdk.ModelRuntime?.prototype.setRuntimeApiKey,
+ getAvailable: typeof sdk.ModelRuntime?.prototype.getAvailable, createAgentSession: typeof sdk.createAgentSession,
+ createBashToolDefinition: typeof sdk.createBashToolDefinition, createSessionManager: typeof sdk.SessionManager?.create,
+ openSessionManager: typeof sdk.SessionManager?.open, prompt: typeof sdk.AgentSession?.prototype.prompt,
+ dispose: typeof sdk.AgentSession?.prototype.dispose };
+ if (Object.values(result.requiredFunctions).some(value => value !== "function")) throw new Error("Pi public API does not match the adapter contract");
+ result.importStatus = "PASS";
+ } catch (error) {
+ result.importStatus = "FAIL";
+ result.error = error instanceof Error ? error.stack : String(error);
+ throw error;
+ } finally {
+ writeFileSync(output, JSON.stringify(result, null, 2) + "\n");
+ }
+ '@
+ $piAudit | node --input-type=module 2>&1 | Tee-Object -FilePath (Join-Path $evidenceDir 'pi-public-api.log')
+ $auditExit = $LASTEXITCODE
+ @{ dependencyExit = $dependencyExit; auditExit = $auditExit } | ConvertTo-Json | Set-Content -Path (Join-Path $evidenceDir 'dependency-audit-terminal.json') -Encoding utf8
+ if ($dependencyExit -ne 0) { exit $dependencyExit }
+ exit $auditExit
+ - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9
+ if: always()
+ with:
+ name: windows-native-runtime-${{ github.run_id }}-${{ github.run_attempt }}
+ path: ${{ runner.temp }}/Alook runtime evidence/
+ if-no-files-found: error
+ retention-days: 14
diff --git a/src/daemon/agent-driver/src/adapters/pi/index.test.ts b/src/daemon/agent-driver/src/adapters/pi/index.test.ts
index 7196afc2a..3fbc15acf 100644
--- a/src/daemon/agent-driver/src/adapters/pi/index.test.ts
+++ b/src/daemon/agent-driver/src/adapters/pi/index.test.ts
@@ -53,12 +53,11 @@ function fakeDeps() {
describe("PiDriver startup model catalog", () => {
function loader(getAvailable: () => unknown[] | Promise<unknown[]>): () => Promise<PiSdkModule> {
return async () => ({
- AuthStorage: { create: () => ({ setRuntimeApiKey: vi.fn() }) },
- ModelRegistry: { create: () => ({ find: vi.fn(), getAvailable }) },
+ ModelRuntime: { create: async () => ({ setRuntimeApiKey: vi.fn(), getModel: vi.fn(), getAvailable }) },
}) as unknown as PiSdkModule;
}
- it("uses authenticated ModelRegistry.getAvailable and formats provider/id", async () => {
+ it("uses authenticated ModelRuntime.getAvailable and formats provider/id", async () => {
const getAvailable = vi.fn(() => [
{ provider: "google", id: "gemini-2.5-pro" },
{ provider: "openai", id: "gpt-5" },
@@ -87,6 +86,16 @@ describe("PiDriver startup model catalog", () => {
expect(result).toEqual({ status: "healthy", version: "1.2.3", reasoning: undefined });
});
+ it("keeps the existing health policy when native model runtime creation fails", async () => {
+ const create = vi.fn().mockRejectedValue(new Error("runtime creation failed"));
+ const loadSdk = async () => ({ ModelRuntime: { create } }) as unknown as PiSdkModule;
+
+ const result = await new PiDriver(undefined, loadSdk, () => "1.2.3").probe();
+
+ expect(create).toHaveBeenCalledOnce();
+ expect(result).toEqual({ status: "healthy", version: "1.2.3", reasoning: undefined });
+ });
+
it("keeps runtime health healthy when SDK catalog discovery times out", async () => {
vi.useFakeTimers();
try {
diff --git a/src/daemon/agent-driver/src/adapters/pi/index.ts b/src/daemon/agent-driver/src/adapters/pi/index.ts
index 11276fec0..532ee6167 100644
--- a/src/daemon/agent-driver/src/adapters/pi/index.ts
+++ b/src/daemon/agent-driver/src/adapters/pi/index.ts
@@ -283,9 +283,8 @@ export class PiDriver implements BackendAdapter {
try {
const reasoning = await Promise.race([
this.loadSdk().then(async (sdk) => {
- const authStorage = sdk.AuthStorage.create();
- const registry = sdk.ModelRegistry.create(authStorage);
- return parsePiModelCatalog(await registry.getAvailable());
+ const modelRuntime = await sdk.ModelRuntime.create();
+ return parsePiModelCatalog(await modelRuntime.getAvailable());
}),
new Promise<undefined>((resolve) => {
timer = setTimeout(() => resolve(undefined), PI_MODEL_PROBE_TIMEOUT_MS);
diff --git a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.test.ts b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.test.ts
index 0c049e21e..3c6e0777f 100644
--- a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.test.ts
+++ b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, vi, afterEach } from "vitest";
import * as fs from "fs";
import * as os from "os";
import * as path from "path";
-import { createPiSessionDependencies, loadPiSdkModule, type PiSdkModule, type PiSdkLoader } from "./sessionDeps.js";
+import { createPiSessionDependencies, loadPiSdkModule, type PiSdkModule, type PiSdkLoader, type PiModelRuntime } from "./sessionDeps.js";
import type { AdapterLaunchContext } from "../../internal/adapter.js";
import type { PiConfig } from "../../contract.js";
import { fakeLaunchContext, fakePrepared } from "../../testing/adapter-fixture.js";
@@ -45,7 +45,9 @@ function fakeSdk(opts: {
} = {}): {
loader: PiSdkLoader;
setRuntimeApiKey: ReturnType<typeof vi.fn>;
- findModel: ReturnType<typeof vi.fn>;
+ getModel: ReturnType<typeof vi.fn>;
+ modelRuntime: PiModelRuntime;
+ createModelRuntime: ReturnType<typeof vi.fn>;
sessionManagerCreate: ReturnType<typeof vi.fn>;
sessionManagerOpen: ReturnType<typeof vi.fn>;
sessionManagerContinueRecent: ReturnType<typeof vi.fn>;
@@ -53,8 +55,8 @@ function fakeSdk(opts: {
createBashToolDefinition: ReturnType<typeof vi.fn>;
createAgentSession: ReturnType<typeof vi.fn>;
} {
- const setRuntimeApiKey = vi.fn();
- const findModel = vi.fn().mockReturnValue({ provider: "google", id: "gemini-2.5-pro" });
+ const setRuntimeApiKey = vi.fn().mockResolvedValue(undefined);
+ const getModel = vi.fn().mockReturnValue({ provider: "google", id: "gemini-2.5-pro" });
const sessionManagerCreate = vi.fn().mockReturnValue({ tag: "fresh" });
const sessionManagerOpen = vi.fn().mockReturnValue({ tag: "opened" });
const sessionManagerContinueRecent = vi.fn().mockReturnValue({ tag: "continued" });
@@ -68,9 +70,10 @@ function fakeSdk(opts: {
const createBashToolDefinition = vi.fn().mockReturnValue({ name: "bash" });
const createAgentSession = vi.fn().mockResolvedValue({ session: { sessionId: "sess-from-sdk" } });
+ const modelRuntime: PiModelRuntime = { setRuntimeApiKey, getModel, getAvailable: async () => [] };
+ const createModelRuntime = vi.fn().mockResolvedValue(modelRuntime);
const sdk: PiSdkModule = {
- AuthStorage: { create: () => ({ setRuntimeApiKey }) },
- ModelRegistry: { create: () => ({ find: findModel, getAvailable: () => [] }) },
+ ModelRuntime: { create: createModelRuntime },
SessionManager: {
create: sessionManagerCreate,
open: sessionManagerOpen,
@@ -83,8 +86,10 @@ function fakeSdk(opts: {
};
return {
loader: async () => sdk,
+ modelRuntime,
+ createModelRuntime,
setRuntimeApiKey,
- findModel,
+ getModel,
sessionManagerCreate,
sessionManagerOpen,
sessionManagerContinueRecent,
@@ -108,6 +113,99 @@ describe("createPiSessionDependencies — buildSpawnEnv", () => {
});
describe("createPiSessionDependencies — createAgentSession", () => {
+ it("waits for native runtime creation before credential, model or session access", async () => {
+ const fake = fakeSdk();
+ let release!: (runtime: PiModelRuntime) => void;
+ fake.createModelRuntime.mockReturnValue(new Promise<PiModelRuntime>((resolve) => { release = resolve; }));
+ const ctx = baseCtx({
+ config: { runtimeConfig: piConfig({ provider: { kind: "builtin", providerId: "google", apiKey: "held-key" } }) },
+ });
+ const pending = createPiSessionDependencies(ctx, fake.loader).createAgentSession({
+ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {},
+ });
+
+ await vi.waitFor(() => expect(fake.createModelRuntime).toHaveBeenCalledOnce());
+ expect(fake.setRuntimeApiKey).not.toHaveBeenCalled();
+ expect(fake.getModel).not.toHaveBeenCalled();
+ expect(fake.createAgentSession).not.toHaveBeenCalled();
+ release(fake.modelRuntime);
+ await pending;
+ expect(fake.createAgentSession).toHaveBeenCalledWith(expect.objectContaining({ modelRuntime: fake.modelRuntime }));
+ });
+
+ it("rejects failed runtime creation without creating an SDK session", async () => {
+ const fake = fakeSdk();
+ const failure = new Error("runtime creation failed");
+ fake.createModelRuntime.mockRejectedValue(failure);
+ const ctx = baseCtx();
+
+ await expect(createPiSessionDependencies(ctx, fake.loader).createAgentSession({
+ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {},
+ })).rejects.toBe(failure);
+ expect(fake.getModel).not.toHaveBeenCalled();
+ expect(fake.createAgentSession).not.toHaveBeenCalled();
+ });
+
+ it("waits for runtime credential synchronization before selecting a model and creating a session", async () => {
+ const fake = fakeSdk();
+ let release!: () => void;
+ fake.setRuntimeApiKey.mockReturnValue(new Promise<void>((resolve) => { release = resolve; }));
+ const ctx = baseCtx({
+ config: { runtimeConfig: piConfig({ provider: { kind: "builtin", providerId: "google", apiKey: "held-key" } }) },
+ });
+ const pending = createPiSessionDependencies(ctx, fake.loader).createAgentSession({
+ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {},
+ });
+
+ await vi.waitFor(() => expect(fake.setRuntimeApiKey).toHaveBeenCalledWith("google", "held-key"));
+ expect(fake.getModel).not.toHaveBeenCalled();
+ expect(fake.createAgentSession).not.toHaveBeenCalled();
+ release();
+ await pending;
+ expect(fake.getModel).toHaveBeenCalledWith("google", "gemini-2.5-pro");
+ const options = fake.createAgentSession.mock.calls[0][0];
+ expect(options.modelRuntime).toBe(fake.modelRuntime);
+ expect(options).not.toHaveProperty("authStorage");
+ expect(options).not.toHaveProperty("modelRegistry");
+ });
+
+ it("preserves a credential synchronization failure without creating an SDK session", async () => {
+ const fake = fakeSdk();
+ const failure = new Error("credential synchronization failed");
+ fake.setRuntimeApiKey.mockRejectedValue(failure);
+ const ctx = baseCtx({
+ config: { runtimeConfig: piConfig({ provider: { kind: "builtin", providerId: "google", apiKey: "rejected-key" } }) },
+ });
+
+ await expect(createPiSessionDependencies(ctx, fake.loader).createAgentSession({
+ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {},
+ })).rejects.toBe(failure);
+ expect(fake.getModel).not.toHaveBeenCalled();
+ expect(fake.createAgentSession).not.toHaveBeenCalled();
+ });
+
+ it("keeps concurrent launch credentials in distinct runtimes from the same SDK module", async () => {
+ const shared = fakeSdk();
+ const first = fakeSdk();
+ const second = fakeSdk();
+ shared.createModelRuntime.mockResolvedValueOnce(first.modelRuntime).mockResolvedValueOnce(second.modelRuntime);
+ const contexts = ["first-key", "second-key"].map((apiKey) => baseCtx({
+ config: { runtimeConfig: piConfig({ provider: { kind: "builtin", providerId: "google", apiKey } }) },
+ }));
+
+ await Promise.all(contexts.map((ctx) => createPiSessionDependencies(ctx, shared.loader).createAgentSession({
+ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {},
+ })));
+
+ expect(shared.createModelRuntime).toHaveBeenCalledTimes(2);
+ expect(first.setRuntimeApiKey).toHaveBeenCalledExactlyOnceWith("google", "first-key");
+ expect(second.setRuntimeApiKey).toHaveBeenCalledExactlyOnceWith("google", "second-key");
+ for (const [index, runtime] of [first.modelRuntime, second.modelRuntime].entries()) {
+ const call = shared.createAgentSession.mock.calls.find(([options]) => options.cwd === contexts[index]!.workingDirectory);
+ expect(call?.[0].modelRuntime).toBe(runtime);
+ }
+ });
+
it("sets the runtime API key when the runtime config carries a pi-builtin provider", async () => {
const fake = fakeSdk();
const ctx = baseCtx({
@@ -130,16 +228,16 @@ describe("createPiSessionDependencies — createAgentSession", () => {
expect(fake.setRuntimeApiKey).not.toHaveBeenCalled();
});
- it("resolves a 'provider/id' model string via modelRegistry.find", async () => {
+ it("resolves a 'provider/id' model string via modelRuntime.getModel", async () => {
const fake = fakeSdk();
const ctx = baseCtx();
const deps = createPiSessionDependencies(ctx, fake.loader);
await deps.createAgentSession({ cwd: ctx.workingDirectory, model: "google/gemini-2.5-pro", spawnEnv: {} });
- expect(fake.findModel).toHaveBeenCalledWith("google", "gemini-2.5-pro");
+ expect(fake.getModel).toHaveBeenCalledWith("google", "gemini-2.5-pro");
expect(fake.createAgentSession).toHaveBeenCalledWith(
- expect.objectContaining({ model: { provider: "google", id: "gemini-2.5-pro" } }),
+ expect.objectContaining({ model: { provider: "google", id: "gemini-2.5-pro" }, modelRuntime: fake.modelRuntime }),
);
});
@@ -150,7 +248,7 @@ describe("createPiSessionDependencies — createAgentSession", () => {
await deps.createAgentSession({ cwd: ctx.workingDirectory, model: "not-a-provider-id-pair", spawnEnv: {} });
- expect(fake.findModel).not.toHaveBeenCalled();
+ expect(fake.getModel).not.toHaveBeenCalled();
expect(fake.createAgentSession).toHaveBeenCalledWith(expect.objectContaining({ model: undefined }));
});
diff --git a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts
index bc6998706..087980b29 100644
--- a/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts
+++ b/src/daemon/agent-driver/src/adapters/pi/sessionDeps.ts
@@ -16,8 +16,7 @@ const PI_SDK_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
/** The slice of the vendor SDK's module exports this file actually calls. */
export interface PiSdkModule {
- AuthStorage: { create(authPath?: string): PiAuthStorage };
- ModelRegistry: { create(authStorage: PiAuthStorage, modelsPath?: string): PiModelRegistry };
+ ModelRuntime: { create(): Promise<PiModelRuntime> };
SessionManager: {
create(cwd: string, sessionDir?: string, options?: { id?: string }): unknown;
open(path: string, sessionDir?: string, cwdOverride?: string): unknown;
@@ -37,12 +36,10 @@ export interface PiSdkModule {
createBashToolDefinition(cwd: string, options?: PiBashToolOptions): unknown;
createAgentSession(options: Record<string, unknown>): Promise<{ session: unknown; sessionId?: string }>;
}
-export interface PiAuthStorage {
- setRuntimeApiKey(provider: string, apiKey: string): void;
-}
-export interface PiModelRegistry {
- find(provider: string, modelId: string): unknown | undefined;
- getAvailable(): unknown[] | Promise<unknown[]>;
+export interface PiModelRuntime {
+ setRuntimeApiKey(provider: string, apiKey: string): Promise<void>;
+ getModel(provider: string, modelId: string): unknown | undefined;
+ getAvailable(): Promise<readonly unknown[]>;
}
interface PiBashSpawnContext {
command: string;
@@ -177,18 +174,17 @@ export function createPiSessionDependencies(
async createAgentSession(opts: Record<string, unknown>): Promise<{ session: unknown; sessionId: string }> {
const sdk = await loadSdk();
- const authStorage = sdk.AuthStorage.create();
+ const modelRuntime = await sdk.ModelRuntime.create();
const runtimeConfig = ctx.config.runtimeConfig;
const provider = runtimeConfig && "provider" in runtimeConfig
? runtimeConfig.provider
: undefined;
if (provider?.kind === "builtin") {
- authStorage.setRuntimeApiKey(provider.providerId, provider.apiKey);
+ await modelRuntime.setRuntimeApiKey(provider.providerId, provider.apiKey);
}
- const modelRegistry = sdk.ModelRegistry.create(authStorage);
const parsed = parseModelString(opts.model as string | undefined);
- const model = parsed ? modelRegistry.find(parsed.provider, parsed.id) : undefined;
+ const model = parsed ? modelRuntime.getModel(parsed.provider, parsed.id) : undefined;
const cwd = opts.cwd as string;
// Three-branch session acquisition — see the plan's Designs section:
@@ -220,8 +216,7 @@ export function createPiSessionDependencies(
cwd,
model,
thinkingLevel: opts.thinkingLevel,
- authStorage,
- modelRegistry,
+ modelRuntime,
sessionManager,
customTools: [bashTool],
});
diff --git a/src/daemon/agent-driver/src/controller/logical-session.test.ts b/src/daemon/agent-driver/src/controller/logical-session.test.ts
index a8bd4abfe..e213223a4 100644
--- a/src/daemon/agent-driver/src/controller/logical-session.test.ts
+++ b/src/daemon/agent-driver/src/controller/logical-session.test.ts
@@ -415,6 +415,27 @@ describe.each(["claude", "codex", "cursor", "grok", "opencode", "pi"] as const)(
await session.stop({ reason: "shutdown", forceAfterMs: 10 });
});
+ it("replays an exact send receipt while rejecting changed input or start/send ownership", async () => {
+ const { session } = makeSession(backend);
+ const first = { id: "first-owned", kind: "user" as const, text: "first", sequence: 1 };
+ const started = await session.start(first);
+ expect(await session.start({ ...first })).toEqual(started);
+ expect(await session.send({ ...first })).toEqual({ status: "rejected", reason: "duplicate_conflict" });
+ const next = { id: "next-owned", kind: "user" as const, text: "[fixed time] next\n\nfooter", sequence: 2 };
+ const sent = await session.send(next);
+ expect(sent.status).not.toBe("rejected");
+ expect(await session.send({ ...next })).toEqual(sent);
+ for (const input of [
+ { ...next, text: "[later time] next\n\nfooter" },
+ { ...next, sequence: 3 },
+ { ...next, kind: "system" as const },
+ ]) {
+ expect(await session.send(input)).toEqual({ status: "rejected", reason: "duplicate_conflict" });
+ }
+ expect(await session.start({ ...next })).toEqual({ status: "rejected", reason: "duplicate_conflict" });
+ await session.stop({ reason: "shutdown", forceAfterMs: 10 });
+ });
+
it("attaches the iterator before start and loses no normalized event", async () => {
const { session, driver } = makeSession(backend);
const iterator = session.events[Symbol.asyncIterator]() as AsyncIterator<AgentEvent<BuiltinBackendSpecs, BuiltinBackendId>>;
diff --git a/src/daemon/agent-driver/src/internal/probe.windows.test.ts b/src/daemon/agent-driver/src/internal/probe.windows.test.ts
index 21793d1dd..9ecd27f58 100644
--- a/src/daemon/agent-driver/src/internal/probe.windows.test.ts
+++ b/src/daemon/agent-driver/src/internal/probe.windows.test.ts
@@ -7,6 +7,8 @@ import { createServer } from "node:net";
import { execFileSync, type ChildProcess } from "node:child_process";
import { afterEach, describe, expect, it, vi } from "vitest";
import { loadPiSdkModule } from "../adapters/pi/sessionDeps.js";
+import { PiDriver } from "../adapters/pi/index.js";
+import { fakeLaunchContext } from "../testing/adapter-fixture.js";
import { createAgentDriverSdk } from "../index.js";
import { scrubDriverErrorMessage } from "./errors.js";
import { isAlive, killProcessTree, spawnAgentProcess } from "./killTree.js";
@@ -318,14 +320,36 @@ describe.skipIf(!nativePrefix)("real npm and native providers from an isolated p
if (probe.status === "unhealthy") expect(probe.error.code).toBe("grok_acp_authentication_failed");
});
- it("imports the real Pi SDK and creates/disposes a persistent session without a model request", async () => {
+ it("creates and disposes a real persistent Pi session through the default adapter without a model request", async () => {
setPrefix(nativePrefix!);
- const piSdk = await loadPiSdkModule();
- const sessionManager = piSdk.SessionManager.create(nativePrefix!, join(nativePrefix!, "pi-sessions"));
- const { session } = await piSdk.createAgentSession({ cwd: nativePrefix!, agentDir: join(nativePrefix!, "pi-home"), sessionManager, tools: [] });
- const nativeSession = session as { sessionId: string; prompt: unknown; dispose(): void };
- expect(typeof nativeSession.sessionId).toBe("string");
- expect(typeof nativeSession.prompt).toBe("function");
- nativeSession.dispose();
+ vi.stubEnv("PI_OFFLINE", "1");
+ const piSdk = await loadPiSdkModule() as unknown as {
+ AgentSession: { prototype: { prompt(text: string): Promise<void>; dispose(): void } };
+ };
+ const prompt = vi.spyOn(piSdk.AgentSession.prototype, "prompt");
+ const dispose = vi.spyOn(piSdk.AgentSession.prototype, "dispose");
+ let lane: Awaited<ReturnType<PiDriver["openLane"]>> | undefined;
+ try {
+ const started = Date.now();
+ lane = await new PiDriver().openLane(fakeLaunchContext("pi", nativePrefix!));
+ expect(typeof lane.currentSessionId).toBe("string");
+ expect(lane.currentSessionId.length).toBeGreaterThan(0);
+ const sessionId = lane.currentSessionId;
+ expect(prompt).not.toHaveBeenCalled();
+ console.log(JSON.stringify({ backend: "pi", phase: "default-adapter-created", sessionId, elapsedMs: Date.now() - started }));
+ await lane.stop();
+ lane = undefined;
+ expect(dispose).toHaveBeenCalledOnce();
+ expect(dispose.mock.results[0]).toMatchObject({ type: "return" });
+ console.log(JSON.stringify({ backend: "pi", phase: "default-adapter-disposed", sessionId, promptCalls: prompt.mock.calls.length,
+ disposeCalls: dispose.mock.calls.length, elapsedMs: Date.now() - started, node: process.version }));
+ } finally {
+ try {
+ await lane?.stop();
+ } finally {
+ prompt.mockRestore();
+ dispose.mockRestore();
+ }
+ }
});
});
diff --git a/src/daemon/src/manager/managerPolicy.test.ts b/src/daemon/src/manager/managerPolicy.test.ts
index d52d2887c..8f58402a3 100644
--- a/src/daemon/src/manager/managerPolicy.test.ts
+++ b/src/daemon/src/manager/managerPolicy.test.ts
@@ -241,6 +241,110 @@ describe("reduceManager — steering a running persistent agent", () => {
});
describe("reduceManager — turn_end behavior", () => {
+ it("retains a failed admission through a stopping terminal and the replacement spawn", () => {
+ let s = register(createInitialManagerState(50), "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "first", text: "first" }, nowMs: 0 }).state;
+ s = spawnRoot(s, 0);
+ const message = {
+ id: "retry", seq: 2, text: "retry",
+ preparedInput: { id: "retry", kind: "user" as const, text: "[original time] retry\n\nfooter", sequence: 2 },
+ };
+ s = reduceManager(s, {
+ type: "admission_started", agentId: "a", sessionInstanceId: SESSION_INSTANCE,
+ commandId: message.id, exactAgentMsg: message, mode: "busy", requeueOnFailure: true, nowMs: 1,
+ }).state;
+ s = reduceManager(s, { type: "tick", nowMs: 100 }).state;
+ expect(s.agents.a.status).toBe("stopping");
+ const failed = reduceManager(s, {
+ type: "admission_settled", agentId: "a", sessionInstanceId: SESSION_INSTANCE,
+ commandId: message.id, outcome: "failed",
+ });
+ expect(failed.effects).toEqual([{ type: "requeue_delivery", agentId: "a", message, mode: "busy" }]);
+ s = reduceManager(failed.state, { type: "delivery_rejected", agentId: "a", message, mode: "busy" }).state;
+ const ended = completeRoot(s, "turn-a", 101);
+ expect(ended.effects).toEqual([]);
+ expect(ended.state.agents.a).toMatchObject({ status: "stopping", inbox: [message], idleSince: null, turnActive: false });
+ const duplicate = completeRoot(ended.state, "turn-a", 102);
+ expect(duplicate.state).toBe(ended.state);
+ expect(duplicate.effects).toEqual([]);
+ s = reduceManager(ended.state, { type: "session_closed", agentId: "a", sessionInstanceId: SESSION_INSTANCE }).state;
+ expect(s.agents.a.inbox).toEqual([message]);
+ const exited = reduceManager(s, { type: "exit", agentId: "a" });
+ expect(exited.effects).toEqual([{ type: "spawn", agentId: "a", messages: [message], resumeSessionId: null }]);
+ });
+
+ it("does not drain a matching terminal during reset or initial startup", () => {
+ for (const status of ["starting", "running"] as const) {
+ let s = register(createInitialManagerState(), "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "first", text: "first" }, nowMs: 0 }).state;
+ s = spawnRoot(s, 0);
+ const message = { id: "next", text: "next" };
+ s = { ...s, agents: { ...s.agents, a: { ...s.agents.a, status, resetting: status === "running", inbox: [message] } } };
+ const ended = completeRoot(s, "turn-a", 1);
+ expect(ended.effects).toEqual([]);
+ expect(ended.state.agents.a.inbox).toEqual([message]);
+ expect(ended.state.agents.a.idleSince).toBeNull();
+ }
+ });
+
+ it("lets a current reset replacement start and drain the common FIFO once", () => {
+ let s = register(createInitialManagerState(), "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "begin_reset", agentId: "a", nowMs: 0 }).state;
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "first", text: "reset" }, nowMs: 1 }).state;
+ const messages = [{ id: "second", text: "second" }, { id: "third", text: "third" }];
+ s = reduceManager(s, { type: "queue_delivery", agentId: "a", messages }).state;
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "fourth", text: "fourth" }, nowMs: 2 }).state;
+ s = reduceManager(s, { type: "attach_session", agentId: "a", sessionInstanceId: SESSION_INSTANCE, nowMs: 3 }).state;
+ s = reduceManager(s, {
+ type: "turn_started", agentId: "a", sessionInstanceId: SESSION_INSTANCE,
+ turnId: "new-root", commandIds: ["first"], nowMs: 3,
+ }).state;
+ expect(s.agents.a.resetting).toBe(true);
+ const started = reduceManager(s, { type: "spawned", agentId: "a", nowMs: 4 });
+ expect(started.state.agents.a).toMatchObject({ status: "running", resetting: false, resettingSince: null, inbox: [] });
+ expect(started.effects).toEqual([...messages, { id: "fourth", text: "fourth" }].map((message) => ({
+ type: "send", agentId: "a", message, mode: "busy",
+ })));
+ const repeated = reduceManager(started.state, { type: "spawned", agentId: "a", nowMs: 5 });
+ expect(repeated.state).toBe(started.state);
+ expect(repeated.effects).toEqual([]);
+ });
+
+ it("does not revive a stopping owner from a late start receipt", () => {
+ let s = register(createInitialManagerState(50), "a", PERSISTENT_GATED);
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "first", text: "first" }, nowMs: 0 }).state;
+ s = spawnRoot(s, 0);
+ s = reduceManager(s, { type: "tick", nowMs: 100 }).state;
+ s = reduceManager(s, { type: "wake", agentId: "a", message: { id: "next", text: "next" }, nowMs: 101 }).state;
+ const late = reduceManager(s, { type: "spawned", agentId: "a", nowMs: 102 });
+ expect(late.state).toBe(s);
+ expect(late.effects).toEqual([]);
+ expect(late.state.agents.a).toMatchObject({ status: "stopping", inbox: [{ id: "next", text: "next" }] });
+ });
+
+ it("preserves a deferred batch's FIFO and deduplicates existing IDs", () => {
+ let s = register(createInitialManagerState(), "a", PERSISTENT_GATED);
+ const later = { id: "later", text: "later" };
+ s = reduceManager(s, { type: "queue_delivery", agentId: "a", messages: [later] }).state;
+ const older = [{ id: "one", text: "one" }, { id: "two", text: "two" }];
+ const queued = reduceManager(s, { type: "queue_delivery", agentId: "a", messages: [...older, older[0]!, later] });
+ expect(queued.effects).toEqual([]);
+ expect(queued.state.agents.a.inbox).toEqual([...older, later]);
+ });
+
+ it("restores a failed batch in order while retaining the already requeued prepared input", () => {
+ let s = register(createInitialManagerState(), "a", PERSISTENT_GATED);
+ const raw = { id: "failed", seq: 2, text: "raw" };
+ const prepared = { ...raw, preparedInput: { id: "failed", kind: "user" as const, text: "original decorated input", sequence: 2 } };
+ const tail = { id: "tail", text: "tail" };
+ const newer = { id: "newer", text: "newer" };
+ s = reduceManager(s, { type: "queue_delivery", agentId: "a", messages: [prepared, newer] }).state;
+ const restored = reduceManager(s, { type: "queue_delivery", agentId: "a", messages: [raw, tail, raw] });
+ expect(restored.effects).toEqual([]);
+ expect(restored.state.agents.a.inbox).toEqual([prepared, tail, newer]);
+ expect(restored.state.agents.a.inbox[0]).toBe(prepared);
+ });
+
it("persistent with queued messages delivers them as a fresh idle turn", () => {
let s = createInitialManagerState();
s = register(s, "a", PERSISTENT_GATED);
diff --git a/src/daemon/src/manager/managerPolicy.ts b/src/daemon/src/manager/managerPolicy.ts
index ebb5291ae..588690f8a 100644
--- a/src/daemon/src/manager/managerPolicy.ts
+++ b/src/daemon/src/manager/managerPolicy.ts
@@ -1,3 +1,4 @@
+import type { AgentMessage } from "@alook/agent-driver";
export type AgentStatus = "idle" | "starting" | "running" | "stopping";
@@ -5,6 +6,7 @@ export interface AgentMsg {
id?: string;
seq?: number;
text: string;
+ readonly preparedInput?: AgentMessage;
}
export interface TurnIdentity {
@@ -117,6 +119,7 @@ export type ManagerEvent =
| { type: "register"; agentId: string }
| { type: "wake"; agentId: string; message: AgentMsg; nowMs: number }
| { type: "spawned"; agentId: string; nowMs: number }
+ | { type: "queue_delivery"; agentId: string; messages: readonly AgentMsg[] }
| { type: "backend_session"; agentId: string; sessionId: string; stalledBefore?: boolean }
| {
type: "attach_session";
@@ -263,10 +266,29 @@ export function reduceManager(state: ManagerState, event: ManagerEvent): ReduceR
case "wake":
return onWake(state, event.agentId, event.message);
- case "spawned":
+ case "spawned": {
+ const existing = state.agents[event.agentId];
+ if (!existing || existing.status !== "starting") return { state, effects: [] };
+ const agent = clone(existing);
+ enterStable(agent, "running");
+ syncExecutionProjection(agent);
+ const mode = leaseIsWorking(agent.execution.lease) || agent.pendingAdmissions.length > 0 ? "busy" : "idle";
+ const messages = drainInbox(agent);
+ return commit(state, agent, messages.map((message) => ({ type: "send", agentId: event.agentId, message, mode })));
+ }
+
+ case "queue_delivery":
return mutate(state, event.agentId, (a) => {
- enterStable(a, "running");
+ const queuedById = new Map(a.inbox.filter((message) => message.id).map((message) => [message.id, message]));
+ const restoredIds = new Set<string>();
+ const messages = event.messages.filter((message) => {
+ if (message.id && restoredIds.has(message.id)) return false;
+ if (message.id) restoredIds.add(message.id);
+ return true;
+ }).map((message) => message.id ? queuedById.get(message.id) ?? message : message);
+ a.inbox = [...messages, ...a.inbox.filter((message) => !message.id || !restoredIds.has(message.id))];
syncExecutionProjection(a);
+ a.idleSince = null;
});
case "backend_session":
@@ -644,7 +666,7 @@ function onTurnCompleted(
const clearEffects: ManagerEffect[] = clearedStallSessionId === null
? []
: [{ type: "clear_stall_recovery", agentId, sessionId: clearedStallSessionId }];
- if (agent.inbox.length > 0 && !agent.resetting) {
+ if (agent.status === "running" && agent.inbox.length > 0 && !agent.resetting) {
const messages = drainInbox(agent);
return commit(state, agent, [
...clearEffects,
@@ -652,7 +674,7 @@ function onTurnCompleted(
]);
}
- agent.idleSince = nowMs;
+ agent.idleSince = agent.status === "running" && !agent.resetting ? nowMs : null;
return commit(state, agent, clearEffects);
}
diff --git a/src/daemon/src/manager/managerRuntime.test.ts b/src/daemon/src/manager/managerRuntime.test.ts
index 834de940d..8eeda8d14 100644
--- a/src/daemon/src/manager/managerRuntime.test.ts
+++ b/src/daemon/src/manager/managerRuntime.test.ts
@@ -16,6 +16,7 @@ import {
type SessionFactory,
} from "./managerRuntime.js";
import type {
+ AgentMessage,
AgentEvent,
AgentSession,
AgentSessionResult,
@@ -4534,8 +4535,8 @@ function b1GatedDriver(): Driver {
} as Driver;
}
-function b1Session(order: string[], name = "s", turnId = "test-turn"): FakeSession {
- const session = fakeSession();
+function b1Session(order: string[], name = "s", turnId = "test-turn", sessionInstanceId = "test-instance"): FakeSession {
+ const session = fakeSession(sessionInstanceId);
session.start = vi.fn(async (input: { id: string; text: string }) => {
order.push(`${name}:start:${input.text}`);
void session.pushAgentEvent({ type: "command_accepted", commandId: input.id, turnId, delivery: "prompt" });
@@ -4566,6 +4567,9 @@ function b1Manager(opts: {
staleThresholdMs?: number;
stoppingStuckThresholdMs?: number;
onRuntimeSpawnFailed?: (runtimeId: string, reason: string) => void;
+ wakePromptFooter?: string;
+ stampWakePromptTime?: boolean;
+ onBotAuditEvent?: (agentId: string, event: unknown) => void;
} = {}) {
const sessions = opts.sessions ?? [b1Session([])];
let index = 0;
@@ -4588,12 +4592,208 @@ function b1Manager(opts: {
? { stoppingStuckThresholdMs: opts.stoppingStuckThresholdMs }
: {}),
onRuntimeSpawnFailed: opts.onRuntimeSpawnFailed,
+ wakePromptFooter: opts.wakePromptFooter,
+ stampWakePromptTime: opts.stampWakePromptTime,
+ onBotAuditEvent: opts.onBotAuditEvent,
});
if (opts.launchId === null) mgr.register("a1");
else mgr.register("a1", { launchId: opts.launchId ?? "launch-a" });
return { mgr, sessions };
}
+describe("AgentProcessManager — stopped delivery and original inputs", () => {
+ it("replays the complete decorated input in a new session after failed admission and an old terminal", async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(new Date("2026-10-13T07:00:00Z"));
+ const first = b1Session([], "first", "test-turn", "epoch-first");
+ const second = b1Session([], "second", "test-turn", "epoch-second");
+ const originalSnapshot = first.snapshot.bind(first);
+ let stopping = false;
+ first.snapshot = () => ({ ...originalSnapshot(), state: stopping ? "stopping" : "working" });
+ first.stop = vi.fn(async () => {
+ stopping = true;
+ return { status: "accepted" as const, requestId: "stop-first" };
+ });
+ first.send = vi.fn(async (input: AgentMessage) => ({ status: "queued" as const, reason: "runtime_busy" as const, commandId: input.id }));
+ const { mgr } = b1Manager({ sessions: [first, second], stampWakePromptTime: true, wakePromptFooter: "original footer" });
+ try {
+ mgr.deliver("a1", { id: "root", seq: 1, text: "root" });
+ await vi.advanceTimersByTimeAsync(0);
+ await first.fire("runtime_event", { kind: "session_init", sessionId: "first-backend" });
+ mgr.deliver("a1", { id: "retry", seq: 2, text: "retry text" });
+ await vi.advanceTimersByTimeAsync(0);
+ const input = vi.mocked(first.send).mock.calls[0]![0];
+ expect(input).toEqual({ id: "retry", kind: "user", text: expect.stringMatching(/^\[[^\]]+\] retry text\n\noriginal footer$/), sequence: 2 });
+ vi.setSystemTime(new Date("2026-10-13T07:00:30Z"));
+ await first.pushAgentEvent({
+ type: "command_failed", commandId: "retry",
+ error: { category: "process", code: "delivery_failed", message: "failed", retryable: true },
+ });
+ expect(first.stop).toHaveBeenCalledOnce();
+ expect(mgr.snapshot().agents.a1.inbox).toEqual([{ id: "retry", seq: 2, text: "retry text", preparedInput: input }]);
+ await first.fire("runtime_event", { kind: "turn_end" });
+ expect(first.send).toHaveBeenCalledOnce();
+ expect(second.start).not.toHaveBeenCalled();
+ expect(mgr.snapshot().agents.a1.inbox).toEqual([{ id: "retry", seq: 2, text: "retry text", preparedInput: input }]);
+ await first.fire("exit", { reason: "requested" });
+ await vi.advanceTimersByTimeAsync(0);
+ expect(second.start).toHaveBeenCalledExactlyOnceWith(input);
+ expect(second.send).not.toHaveBeenCalled();
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "running", inbox: [], execution: { sessionInstanceId: "epoch-second" } });
+ await second.fire("exit", { reason: "requested" });
+ } finally {
+ await mgr.stopAll();
+ vi.useRealTimers();
+ }
+ });
+
+ it("retains startup work until actual close when stop wins a late first receipt", async () => {
+ const first = fakeSession("start-old");
+ const second = b1Session([], "replacement", "test-turn", "start-new");
+ first.send = vi.fn(first.send);
+ const { mgr } = b1Manager({ sessions: [first, second] });
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "second", seq: 2, text: "second" });
+ mgr.deliver("a1", { id: "third", seq: 3, text: "third" });
+ await mgr.stop("a1");
+ first.startResolver?.();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(first.send).not.toHaveBeenCalled();
+ expect(second.start).not.toHaveBeenCalled();
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "starting", inbox: [
+ { id: "second", seq: 2, text: "second" }, { id: "third", seq: 3, text: "third" },
+ ] });
+ await first.fire("exit", { reason: "requested" });
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(second.start).toHaveBeenCalledExactlyOnceWith({ id: "second", kind: "user", text: "second", sequence: 2 });
+ expect(second.send).toHaveBeenCalledExactlyOnceWith({ id: "third", kind: "user", text: "third", sequence: 3 });
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "running", inbox: [], execution: { sessionInstanceId: "start-new" } });
+ await second.fire("exit", { reason: "requested" });
+ });
+
+ it("starts the current reset replacement while resetting is still true and fences the old epoch", async () => {
+ const first = b1Session([], "old", "test-turn", "reset-old");
+ const second = fakeSession("reset-new");
+ second.send = vi.fn(second.send);
+ const { mgr } = b1Manager({ sessions: [first, second] });
+ mgr.deliver("a1", { id: "old-root", text: "old" });
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ await mgr.resetSession("a1", { runtimeConfig: B1_RUNTIME_CONFIG, launchId: "new-launch", rewakePrompt: "new context" });
+ await first.fire("exit", { reason: "requested" });
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "starting", resetting: true, execution: { sessionInstanceId: "reset-new" } });
+ expect(second.startResolver).toBeDefined();
+ mgr.deliver("a1", { id: "current-work", text: "new work" });
+ await first.fire("runtime_event", { kind: "turn_end" });
+ expect(second.send).not.toHaveBeenCalled();
+ second.startResolver?.();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "running", resetting: false, resettingSince: null, inbox: [], execution: { sessionInstanceId: "reset-new" } });
+ expect(second.send).toHaveBeenCalledExactlyOnceWith({ id: "current-work", kind: "user", text: "new work", sequence: undefined });
+ await second.fire("exit", { reason: "requested" });
+ });
+
+ it("drains all wakes received during the current start once in FIFO order", async () => {
+ const session = fakeSession("fifo-start");
+ session.start = vi.fn(session.start);
+ session.send = vi.fn(session.send);
+ const { mgr } = b1Manager({ sessions: [session] });
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "second", seq: 2, text: "second" });
+ mgr.deliver("a1", { id: "third", seq: 3, text: "third" });
+ expect(session.send).not.toHaveBeenCalled();
+ session.startResolver?.();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(session.start).toHaveBeenCalledOnce();
+ expect(vi.mocked(session.send).mock.calls.map(([input]) => input)).toEqual([
+ { id: "second", kind: "user", text: "second", sequence: 2 },
+ { id: "third", kind: "user", text: "third", sequence: 3 },
+ ]);
+ expect(mgr.snapshot().agents.a1.inbox).toEqual([]);
+ await session.fire("exit", { reason: "requested" });
+ });
+
+ it("returns a whole blocked send batch ahead of newer work without reversing it", async () => {
+ const first = fakeSession("blocked-old");
+ const second = b1Session([], "new", "test-turn", "blocked-new");
+ first.send = vi.fn(first.send);
+ const snapshot = first.snapshot.bind(first);
+ let stopping = false;
+ first.snapshot = () => ({ ...snapshot(), state: stopping ? "stopping" : "working" });
+ const { mgr } = b1Manager({ sessions: [first, second], trace: (row) => {
+ if (row.event === "spawned") stopping = true;
+ } });
+ mgr.deliver("a1", { id: "first", text: "first" });
+ mgr.deliver("a1", { id: "second", text: "second" });
+ mgr.deliver("a1", { id: "third", text: "third" });
+ first.startResolver?.();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(first.send).not.toHaveBeenCalled();
+ expect(mgr.snapshot().agents.a1.inbox.map((message) => message.id)).toEqual(["second", "third"]);
+ await first.fire("exit", { reason: "requested" });
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(second.start).toHaveBeenCalledOnce();
+ expect(vi.mocked(second.start).mock.calls[0]![0].id).toBe("second");
+ expect(vi.mocked(second.send).mock.calls.map(([input]) => input.id)).toEqual(["third"]);
+ await second.fire("exit", { reason: "requested" });
+ });
+
+ it.each([1, 2])("restores only unfinished startup sends when send %i throws, then replays after actual close", async (failingSend) => {
+ vi.useFakeTimers({ toFake: ["Date"] });
+ vi.setSystemTime(new Date("2026-10-13T07:00:00Z"));
+ const first = fakeSession("throw-old");
+ const second = b1Session([], "replacement", "test-turn", "throw-new");
+ first.start = vi.fn(first.start);
+ const send = first.send.bind(first);
+ const snapshot = first.snapshot.bind(first);
+ const error = new Error("original synchronous send failure");
+ const onBotAuditEvent = vi.fn();
+ let attempts = 0;
+ let stopping = false;
+ first.snapshot = () => ({ ...snapshot(), state: stopping ? "stopping" : "working" });
+ first.stop = vi.fn(async () => {
+ stopping = true;
+ return { status: "accepted" as const, requestId: "stop-throw-old" };
+ });
+ first.send = vi.fn((input: AgentMessage) => {
+ if (++attempts === failingSend) throw error;
+ return send(input);
+ });
+ const { mgr } = b1Manager({ sessions: [first, second], stampWakePromptTime: true, wakePromptFooter: "original footer", onBotAuditEvent });
+ try {
+ mgr.deliver("a1", { id: "root", seq: 1, text: "root" });
+ mgr.deliver("a1", { id: "tail-a", seq: 2, text: "tail a" });
+ mgr.deliver("a1", { id: "tail-b", seq: 3, text: "tail b" });
+ first.startResolver?.();
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ const failedInput = vi.mocked(first.send).mock.calls[failingSend - 1]![0];
+ const pendingIds = ["tail-a", "tail-b"].slice(failingSend - 1);
+ expect(first.start).toHaveBeenCalledOnce();
+ expect(first.send).toHaveBeenCalledTimes(failingSend);
+ expect(mgr.snapshot().agents.a1.inbox.map((message) => message.id)).toEqual(pendingIds);
+ expect(mgr.snapshot().agents.a1.inbox[0]!.preparedInput).toBe(failedInput);
+ expect(onBotAuditEvent).toHaveBeenCalledWith("a1", expect.objectContaining({
+ kind: "error", payload: expect.objectContaining({ scope: "runtime", code: "send_failed", message: String(error) }),
+ }), expect.anything());
+ expect(first.stop).toHaveBeenCalledExactlyOnceWith({ reason: "shutdown", forceAfterMs: 2_000 });
+ mgr.deliver("a1", { id: "newer", seq: 4, text: "newer" });
+ await first.fire("runtime_event", { kind: "turn_end" });
+ expect(first.send).toHaveBeenCalledTimes(failingSend);
+ expect(second.start).not.toHaveBeenCalled();
+ expect(mgr.snapshot().agents.a1.inbox.map((message) => message.id)).toEqual([...pendingIds, "newer"]);
+ vi.setSystemTime(new Date("2026-10-13T07:01:00Z"));
+ await first.fire("exit", { reason: "requested" });
+ await new Promise<void>((resolve) => setImmediate(resolve));
+ expect(second.start).toHaveBeenCalledExactlyOnceWith(failedInput);
+ expect(vi.mocked(second.send).mock.calls.map(([input]) => input.id)).toEqual([...pendingIds.slice(1), "newer"]);
+ expect(mgr.snapshot().agents.a1).toMatchObject({ status: "running", inbox: [], execution: { sessionInstanceId: "throw-new" } });
+ await second.fire("exit", { reason: "requested" });
+ } finally {
+ await mgr.stopAll();
+ vi.useRealTimers();
+ }
+ });
+});
+
function b1SpanRows(rows: B1TraceRow[], event?: "turn_begin" | "turn_end" | "turn_abort"): B1TraceRow[] {
return rows.filter((row) => row.recordKind === "turn_span" && (event === undefined || row.event === event));
}
@@ -4999,13 +5199,8 @@ describe("B1 red gate — exact-once terminal matrix", () => {
error: { category: "process" as const, code: "queued_denied", message: "closed", retryable: true },
}));
const { mgr } = b1Manager({ sessions: [session] });
- const internal = mgr as unknown as {
- doSpawn(agentId: string, messages: Array<{ id: string; seq: number; text: string }>, resumeSessionId: null): void;
- };
- internal.doSpawn("a1", [
- { id: "first", seq: 1, text: "first" },
- { id: "queued", seq: 2, text: "queued" },
- ], null);
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "queued", seq: 2, text: "queued" });
session.startResolver?.();
await new Promise((resolve) => setTimeout(resolve, 0));
@@ -5016,13 +5211,8 @@ describe("B1 red gate — exact-once terminal matrix", () => {
const session = fakeSession();
session.send = vi.fn(() => Promise.reject(new Error("queued send rejected")));
const { mgr } = b1Manager({ sessions: [session] });
- const internal = mgr as unknown as {
- doSpawn(agentId: string, messages: Array<{ id: string; seq: number; text: string }>, resumeSessionId: null): void;
- };
- internal.doSpawn("a1", [
- { id: "first", seq: 1, text: "first" },
- { id: "queued", seq: 2, text: "queued" },
- ], null);
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "queued", seq: 2, text: "queued" });
session.startResolver?.();
await new Promise((resolve) => setTimeout(resolve, 0));
@@ -5215,7 +5405,10 @@ describe("B1 red gate — exact-once terminal matrix", () => {
internal.onAgentEvent("a1", failed as never, "codex", owner);
internal.onAgentEvent("a1", { ...failed, sequence: 301 } as never, "codex", owner);
- expect(mgr.snapshot().agents.a1.inbox).toEqual([{ id: "later", seq: 2, text: "later" }]);
+ expect(mgr.snapshot().agents.a1.inbox).toEqual([{
+ id: "later", seq: 2, text: "later",
+ preparedInput: { id: "later", kind: "user", text: "later", sequence: 2 },
+ }]);
expect(session.stop).toHaveBeenCalledTimes(1);
});
@@ -5599,24 +5792,22 @@ describe("AgentProcessManager — defensive owner fences", () => {
expect(first.superseded).toBe(true);
});
- it("abandons queued startup delivery when dispatch replaces its owner", async () => {
+ it("abandons queued startup delivery when its owner is replaced before admission effects", async () => {
const session = fakeSession();
session.send = vi.fn(session.send);
const { mgr } = b1Manager({ sessions: [session] });
const internal = mgr as unknown as {
doSpawn(agentId: string, messages: Array<{ id: string; seq: number; text: string }>, resumeSessionId: null): void;
- dispatch(event: { type: string }, owner?: object): void;
+ dispatch(event: { type: string }, owner?: object): unknown[];
activeSpawnState: Map<string, object>;
};
const dispatch = internal.dispatch.bind(mgr);
vi.spyOn(internal, "dispatch").mockImplementation((event, owner) => {
- dispatch(event, owner);
if (event.type === "spawned") internal.activeSpawnState.delete("a1");
+ return dispatch(event, owner);
});
- internal.doSpawn("a1", [
- { id: "first", seq: 1, text: "first" },
- { id: "queued", seq: 2, text: "queued" },
- ], null);
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "queued", seq: 2, text: "queued" });
session.startResolver?.();
await new Promise((resolve) => setTimeout(resolve, 0));
expect(session.send).not.toHaveBeenCalled();
@@ -5632,10 +5823,8 @@ describe("AgentProcessManager — defensive owner fences", () => {
doSpawn(agentId: string, messages: Array<{ id: string; seq: number; text: string }>, resumeSessionId: null): void;
activeSpawnState: Map<string, { torndown: boolean }>;
};
- internal.doSpawn("a1", [
- { id: "first", seq: 1, text: "first" },
- { id: "queued", seq: 2, text: "queued" },
- ], null);
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "queued", seq: 2, text: "queued" });
session.startResolver?.();
await Promise.resolve();
await Promise.resolve();
@@ -5662,10 +5851,8 @@ describe("AgentProcessManager — defensive owner fences", () => {
begin(...args);
});
const audit = vi.spyOn(internal, "emitErrorAudit");
- internal.doSpawn("a1", [
- { id: "first", seq: 1, text: "first" },
- { id: "queued", seq: 2, text: "queued" },
- ], null);
+ mgr.deliver("a1", { id: "first", seq: 1, text: "first" });
+ mgr.deliver("a1", { id: "queued", seq: 2, text: "queued" });
session.startResolver?.();
await new Promise((resolve) => setTimeout(resolve, 0));
expect(audit).toHaveBeenCalledWith("a1", "runtime", "send_failed", "Error: queued orchestration failed");
diff --git a/src/daemon/src/manager/managerRuntime.ts b/src/daemon/src/manager/managerRuntime.ts
index 545a6ef74..e78fc723e 100644
--- a/src/daemon/src/manager/managerRuntime.ts
+++ b/src/daemon/src/manager/managerRuntime.ts
@@ -1151,7 +1151,34 @@ export class AgentProcessManager {
}
}
}
- for (const effect of effects) this.applyEffect(effect);
+ const completed = new Set<ManagerEffect>();
+ const deferSends = (agentId?: string): void => {
+ const remaining = effects.filter((candidate): candidate is Extract<ManagerEffect, { type: "send" }> =>
+ candidate.type === "send" && !completed.has(candidate) && (agentId === undefined || candidate.agentId === agentId));
+ for (const id of new Set(remaining.map((candidate) => candidate.agentId))) {
+ const batch = remaining.filter((candidate) => candidate.agentId === id);
+ batch.forEach((candidate) => completed.add(candidate));
+ this.dispatch({
+ type: "queue_delivery",
+ agentId: id,
+ messages: batch.map((candidate) => candidate.message),
+ });
+ }
+ };
+ try {
+ for (const effect of effects) {
+ if (completed.has(effect)) continue;
+ if (effect.type === "send" && !this.canSend(effect.agentId)) {
+ deferSends(effect.agentId);
+ continue;
+ }
+ this.applyEffect(effect);
+ completed.add(effect);
+ }
+ } catch (error) {
+ deferSends();
+ throw error;
+ }
return effects;
}
private deriveActivitySnapshot(state: ManagerState): Record<string, AgentActivityState> {
@@ -1197,6 +1224,27 @@ export class AgentProcessManager {
private stampNow(text: string): string {
return this.opts.stampWakePromptTime ? `[${nowLocalISO()}] ${text}` : text;
}
+ private prepareDelivery(message: AgentMsg): AgentMsg & { preparedInput: NonNullable<AgentMsg["preparedInput"]> } {
+ return {
+ ...message,
+ preparedInput: message.preparedInput ?? {
+ id: message.id!,
+ kind: "user",
+ text: this.stampNow(this.withFooter(message.text)),
+ sequence: message.seq,
+ },
+ };
+ }
+ private canSend(agentId: string): boolean {
+ const session = this.sessions.get(agentId);
+ const owner = this.activeSpawnState.get(agentId);
+ const agent = this.state.agents[agentId];
+ if (!session || !owner || owner.session !== session || owner.torndown || owner.superseded
+ || agent?.status !== "running" || agent.resetting
+ || agent.execution.sessionInstanceId !== session.sessionInstanceId) return false;
+ const driverState = session.snapshot().state;
+ return driverState !== "stopping" && driverState !== "closed";
+ }
private beginPendingDelivery(
owner: ActiveSpawnState,
commandId: string,
@@ -1263,13 +1311,10 @@ export class AgentProcessManager {
break;
case "send": {
const session = this.sessions.get(effect.agentId);
- const input = {
- id: effect.message.id!,
- kind: "user" as const,
- text: this.stampNow(this.withFooter(effect.message.text)),
- sequence: effect.message.seq,
- };
- if (session) {
+ if (session && this.canSend(effect.agentId)) {
+ const message = this.prepareDelivery(effect.message);
+ effect.message = message;
+ const input = message.preparedInput;
const owner = this.activeSpawnState.get(effect.agentId);
const exactOwner = owner?.session === session ? owner : undefined;
const associatedSpan = exactOwner
@@ -1277,7 +1322,7 @@ export class AgentProcessManager {
? this.openTurn(exactOwner)
: exactOwner.activeSpan
: null;
- if (exactOwner) this.beginPendingDelivery(exactOwner, input.id, effect.message, effect.mode, associatedSpan);
+ if (exactOwner) this.beginPendingDelivery(exactOwner, input.id, message, effect.mode, associatedSpan);
let sent: ReturnType<DaemonAgentSession["send"]>;
try {
sent = session.send(input);
@@ -1514,8 +1559,10 @@ export class AgentProcessManager {
this.log.info("agent session ended", { agentId, sessionId, reason });
}
private doSpawn(agentId: string, messages: AgentMsg[], resumeSessionId: string | null): void {
- const [first, ...pending] = messages;
- if (!first) throw new Error(`AgentProcessManager: spawn for ${agentId} has no command`);
+ const [initial, ...pending] = messages;
+ if (!initial) throw new Error(`AgentProcessManager: spawn for ${agentId} has no command`);
+ this.dispatch({ type: "queue_delivery", agentId, messages: pending });
+ const first = this.prepareDelivery(initial);
const prompt = this.withFooter(first.text);
const driver = this.opts.driverFor(agentId, this.runtimeConfigs.get(agentId));
this.liveBackendIds.set(agentId, driver.id);
@@ -1743,12 +1790,7 @@ export class AgentProcessManager {
this.beginPendingDelivery(state, commandId, first, "idle", startedSpan, false);
let startResult: Promise<DeliveryReceipt>;
try {
- startResult = session.start({
- id: commandId,
- kind: "user",
- text: this.stampNow(prompt),
- sequence: first.seq,
- });
+ startResult = session.start(first.preparedInput);
this.markPendingDeliveryObserved(state, commandId);
} catch (error) {
this.settlePendingDelivery(state, commandId);
@@ -1756,7 +1798,8 @@ export class AgentProcessManager {
throw error;
}
void startResult.then((receipt) => {
- if (this.sessions.get(agentId) !== session || state.torndown) return;
+ if (this.sessions.get(agentId) !== session || state.torndown || state.superseded
+ || this.activeSpawnState.get(agentId) !== state) return;
if (receipt?.status === "rejected") {
this.settlePendingDelivery(state, commandId);
const reason = receipt.error?.code ?? receipt.reason;
@@ -1764,48 +1807,15 @@ export class AgentProcessManager {
void session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS });
return;
}
- this.dispatch({ type: "spawned", agentId, nowMs: this.now() }, state);
- void (async () => {
- for (const message of pending) {
- if (state.torndown || this.sessions.get(agentId) !== session || this.activeSpawnState.get(agentId) !== state) {
- return;
- }
- this.beginPendingDelivery(state, message.id!, message, "busy", state.activeSpan);
- let queuedReceipt: DeliveryReceipt;
- try {
- const queuedResult = session.send({
- id: message.id!,
- kind: "user",
- text: this.stampNow(this.withFooter(message.text)),
- sequence: message.seq,
- });
- this.markPendingDeliveryObserved(state, message.id!);
- queuedReceipt = await queuedResult;
- } catch (error) {
- this.settlePendingDelivery(state, message.id!);
- if (!state.torndown && this.sessions.get(agentId) === session && this.activeSpawnState.get(agentId) === state) {
- this.emitErrorAudit(agentId, "runtime", "send_failed", String(error));
- void session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS });
- }
- return;
- }
- if (state.torndown || this.sessions.get(agentId) !== session || this.activeSpawnState.get(agentId) !== state) {
- return;
- }
- if (queuedReceipt.status === "rejected") {
- if (!state.pendingDeliverySpans.has(message.id!)) return;
- this.settlePendingDelivery(state, message.id!);
- this.emitErrorAudit(
- agentId,
- "runtime",
- queuedReceipt.error?.code ?? queuedReceipt.reason,
- queuedReceipt.error?.message ?? `Delivery rejected (${queuedReceipt.reason})`,
- );
- void session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS });
- return;
- }
- }
- })().catch((error) => this.emitErrorAudit(agentId, "runtime", "send_failed", String(error)));
+ const driverState = session.snapshot().state;
+ if (this.state.agents[agentId]?.status !== "starting" || driverState === "stopping" || driverState === "closed") return;
+ try {
+ this.dispatch({ type: "spawned", agentId, nowMs: this.now() }, state);
+ } catch (error) {
+ this.emitErrorAudit(agentId, "runtime", "send_failed", String(error));
+ void session.stop({ reason: "shutdown", forceAfterMs: SESSION_STOP_GRACE_MS });
+ return;
+ }
if (state.hasEstablished || state.hasReportedSpawnFailure) return;
state.handshakeTimer = setTimeout(() => {
state.handshakeTimer = null;
diff --git a/src/daemon/src/manager/rootLeaseIntegration.test.ts b/src/daemon/src/manager/rootLeaseIntegration.test.ts
index ad14eed66..abf5697be 100644
--- a/src/daemon/src/manager/rootLeaseIntegration.test.ts
+++ b/src/daemon/src/manager/rootLeaseIntegration.test.ts
@@ -2,7 +2,7 @@ import { EventEmitter } from "node:events";
import { PassThrough } from "node:stream";
import { describe, expect, it, vi } from "vitest";
import type { ChildProcess } from "node:child_process";
-import type { BuiltinBackendSpecs, PreparedExecutionResource } from "@alook/agent-driver";
+import type { AgentMessage, BuiltinBackendSpecs, PreparedExecutionResource } from "@alook/agent-driver";
import { createBuiltinAgentDriverRegistry } from "@alook/agent-driver/adapter-author";
import { createFakeAgentDriverHost } from "@alook/agent-driver/testing";
import { CodexDriver } from "../../agent-driver/src/adapters/codex/index.js";
@@ -28,6 +28,106 @@ async function flushEvents(): Promise<void> {
}
describe("raw adapter → public session → manager root lease", () => {
+ it("keeps a native failed command queued through old terminal and cleanup, then replays its original input", async () => {
+ vi.useFakeTimers({ toFake: ["Date"] });
+ vi.setSystemTime(new Date("2026-10-13T07:00:00Z"));
+ let now = 0;
+ let releaseClose!: () => void;
+ const closeGate = new Promise<void>((resolve) => { releaseClose = resolve; });
+ const release = vi.fn(() => closeGate);
+ const host = createFakeAgentDriverHost();
+ const children = [fakeProcess(), fakeProcess()];
+ const sessions = children.map((childProcess, index) => {
+ const adapter = new CodexDriver();
+ vi.spyOn(adapter, "spawn").mockResolvedValue({ process: childProcess });
+ const prepared: PreparedExecutionResource = {
+ environmentLayers: {
+ base: {}, hostStatic: {}, identityProtected: {}, platformProtected: {},
+ runtimeProtected: {}, networkProtected: {}, credentialSensitive: {},
+ },
+ release: index === 0 ? release : async () => {},
+ };
+ return new LogicalAgentSession<BuiltinBackendSpecs, "codex">(
+ "codex", { model: { kind: "default" }, mode: "default" },
+ { workingDirectory: process.cwd(), instructions: "", launchId: `delivery-${index}` },
+ adapter, createBuiltinAgentDriverRegistry().get("codex").capabilities, host, prepared, 1_000,
+ );
+ });
+ const firstSend = vi.spyOn(sessions[0]!, "send");
+ const nextStart = vi.spyOn(sessions[1]!, "start");
+ const nextSend = vi.spyOn(sessions[1]!, "send");
+ const trace: Array<{ event?: string; status?: string; effects?: string[] }> = [];
+ let nextSession = 0;
+ const manager = new AgentProcessManager({
+ driverFor: () => ({ id: "codex" }),
+ baseContextFor: () => ({
+ workingDirectory: process.cwd(), agentId: "a1", standingPrompt: "",
+ config: {} as HostLaunchContext["config"], credentialProxy: {} as HostLaunchContext["credentialProxy"],
+ }),
+ sessionFactory: () => sessions[nextSession++]!,
+ now: () => now,
+ tickIntervalMs: 5,
+ stampWakePromptTime: true,
+ wakePromptFooter: "native delivery footer",
+ onFsmTransition: (row) => trace.push(row),
+ });
+ const raw = async (index: number, value: unknown) => {
+ children[index]!.stdout.write(`${JSON.stringify(value)}\n`);
+ await flushEvents();
+ };
+ try {
+ manager.register("a1");
+ manager.start();
+ manager.deliver("a1", { id: "root-command", seq: 1, text: "root" });
+ await flushEvents();
+ await raw(0, { jsonrpc: "2.0", id: 2, result: { thread: { id: "root-thread" } } });
+ await raw(0, { jsonrpc: "2.0", method: "turn/started", params: {
+ threadId: "root-thread", turn: { id: "root-vendor-turn", status: "inProgress" },
+ } });
+ await raw(0, { jsonrpc: "2.0", method: "item/started", params: {
+ threadId: "root-thread", turnId: "root-vendor-turn", item: { id: "compaction", type: "contextCompaction" },
+ } });
+ manager.deliver("a1", { id: "retry-command", seq: 2, text: "retry" });
+ await flushEvents();
+ expect(firstSend).toHaveBeenCalledOnce();
+ const original: AgentMessage = firstSend.mock.calls[0]![0];
+ expect(original).toEqual({ id: "retry-command", kind: "user", text: expect.stringMatching(/^\[[^\]]+\] retry\n\nnative delivery footer$/), sequence: 2 });
+ expect(manager.snapshot().agents.a1.pendingAdmissions.map((entry) => entry.commandId)).toEqual(["retry-command"]);
+ expect(sessions[0]!.snapshot().queuedCommands.map((command) => command.commandId)).toEqual(["retry-command"]);
+
+ now = 400_000;
+ vi.setSystemTime(new Date("2026-10-13T07:01:00Z"));
+ await vi.waitFor(() => {
+ expect(manager.snapshot().agents.a1).toMatchObject({ status: "stopping", inbox: [
+ { id: "retry-command", seq: 2, text: "retry", preparedInput: original },
+ ] });
+ expect(release).toHaveBeenCalledOnce();
+ });
+ expect(sessions[0]!.snapshot().state).toBe("stopping");
+ expect(firstSend).toHaveBeenCalledOnce();
+ expect(nextStart).not.toHaveBeenCalled();
+ expect(trace.some((row) => row.event === "turn_end" && row.status === "stopping" && !row.effects?.includes("send"))).toBe(true);
+
+ releaseClose();
+ await sessions[0]!.closed;
+ await flushEvents();
+ expect(nextStart).toHaveBeenCalledExactlyOnceWith(original);
+ expect(nextSend).not.toHaveBeenCalled();
+ await raw(1, { jsonrpc: "2.0", id: 2, result: { thread: { id: "replacement-thread" } } });
+ await raw(1, { jsonrpc: "2.0", method: "turn/started", params: {
+ threadId: "replacement-thread", turn: { id: "replacement-vendor-turn", status: "inProgress" },
+ } });
+ expect(manager.snapshot().agents.a1).toMatchObject({ status: "running", inbox: [], execution: {
+ sessionInstanceId: sessions[1]!.sessionInstanceId,
+ } });
+ await expect(sessions[1]!.send({ ...original, text: "changed retry" })).resolves.toEqual({ status: "rejected", reason: "duplicate_conflict" });
+ } finally {
+ releaseClose();
+ await manager.stopAll();
+ vi.useRealTimers();
+ }
+ });
+
it("contains a false terminal, ignores unowned work/duplicates, and permits a proven re-close", async () => {
let now = 0;
const adapter = new CodexDriver();