sailfork / t3code-github / packages/ provider-pi/ src/ server/ adapter.test.ts

import { assert, describe, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import {
  CheckpointId,
  ChatAttachmentId,
  EnvironmentId,
  NodeId,
  ProviderInstanceId,
  ProviderSessionId,
  ProviderThreadId,
  ProviderTurnId,
  RunAttemptId,
  RunId,
  ThreadId,
  type ChatAttachment,
  type ModelSelection,
  type OrchestrationV2AppThread,
  type OrchestrationV2ProviderThread,
  OrchestrationV2UserInputQuestion,
  type OrchestrationV2ProviderTurn,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Queue from "effect/Queue";
import * as Schema from "effect/Schema";
import * as Sink from "effect/Sink";
import * as Stream from "effect/Stream";
import * as ChildProcess from "effect/process/ChildProcess";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";

import * as TestProviderHost from "@t3tools/provider-testing/TestProviderHost";
import * as ProviderContinuationRequests from "@t3tools/provider-core/server/ProviderContinuationRequests";
import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions";
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
import * as ProviderAdapter from "@t3tools/provider-core/server/ProviderAdapter";
import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost";
import { handoffBudget } from "@t3tools/provider-core/server/handoffBudget";
import * as HostProcess from "@t3tools/shared/HostProcess";
import { AgentScope } from "@t3tools/shared/AgentScope";
import { toolOutputImages, compactDynamicToolOutput } from "@t3tools/shared/toolOutput";
import {
  makePiAdapterV2,
  PiAdapterV2Driver,
  PI_PROVIDER,
  type PiAdapterV2Options,
} from "./adapter.ts";
import { makePiRpcConnection, type PiRpcRecord } from "./rpc.ts";
import { loadMcpBridge } from "./mcpBridge.testkit.ts";
import { turnItemOutputText } from "../../../client-runtime/src/work-log/itemDetail.ts";

const layerTest = Layer.mergeAll(
  NodeServices.layer,
  IdAllocator.layer,
  McpProviderSessions.layer,
  TestProviderHost.layer().pipe(Layer.provide(NodeServices.layer)),
);

const decodeUserInputQuestions = Schema.decodeUnknownSync(
  Schema.Array(OrchestrationV2UserInputQuestion),
);

const decodeJsonLine = Schema.decodeSync(Schema.fromJsonString(Schema.Unknown));
const encodeJsonLine = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));

const PI_INSTANCE_ID = ProviderInstanceId.make("pi");
const THREAD_ID = ThreadId.make("thread-pi-test");
const SESSION_ID = ProviderSessionId.make("provider-session-pi-test");
const FAKE_SESSION_FILE = "/fake/.pi/agent/sessions/--workspace--/0001_abc.jsonl";
/** Deliberately outside the valid pid range so a group-kill can never land. */
const FAKE_PID = 999_999_999;

const at = (seconds: number) => DateTime.makeUnsafe(seconds * 1000);

const sessionMessage = (
  id: string,
  parentId: string | null,
  role: "user" | "assistant",
  seconds: number,
) => ({
  type: "message",
  id,
  parentId,
  timestamp: DateTime.formatIso(at(seconds)),
  message: { role, content: [] },
});

const TURN_ONE_ENTRIES = [
  sessionMessage("u1", null, "user", 10),
  sessionMessage("a1", "u1", "assistant", 20),
  sessionMessage("steer1", "a1", "user", 30),
  sessionMessage("a1b", "steer1", "assistant", 40),
];
const UNCAPTURED_TURN_TREE = {
  entries: [
    ...TURN_ONE_ENTRIES,
    sessionMessage("u2", "a1b", "user", 110),
    sessionMessage("a2", "u2", "assistant", 120),
    sessionMessage("steer2", "a2", "user", 130),
    sessionMessage("a2b", "steer2", "assistant", 140),
  ],
  leafId: "a2b",
};

function uncapturedTurns(
  providerThreadId: ProviderThreadId,
  window = { startedAt: 150, completedAt: 200 },
): ReadonlyArray<OrchestrationV2ProviderTurn> {
  const turn = (
    ordinal: number,
    nativeTurnRef: OrchestrationV2ProviderTurn["nativeTurnRef"],
    status: OrchestrationV2ProviderTurn["status"],
    startedAt: number,
    completedAt: number,
  ): OrchestrationV2ProviderTurn => ({
    id: ProviderTurnId.make(`turn-${ordinal}`),
    providerThreadId,
    nodeId: NodeId.make(`node-${ordinal}`),
    runAttemptId: null,
    nativeTurnRef,
    ordinal,
    status,
    startedAt: at(startedAt),
    completedAt: at(completedAt),
  });
  return [
    turn(1, { driver: PI_PROVIDER, nativeId: "u1", strength: "strong" }, "completed", 0, 50),
    turn(
      2,
      { driver: PI_PROVIDER, nativeId: "synthetic-2", strength: "weak" },
      "cancelled",
      window.startedAt,
      window.completedAt,
    ),
  ];
}

const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({
  runtimeMode: "full-access",
  interactionMode: "default",
  cwd: null,
});

const modelSelection = (model: string): ModelSelection => ({
  instanceId: PI_INSTANCE_ID,
  model,
});

interface FakePi {
  readonly spawner: ChildProcessSpawner.ChildProcessSpawner["Service"];
  readonly emit: (record: PiRpcRecord, chunkBytes?: number) => Effect.Effect<void>;
  readonly takeRequest: (type: string) => Effect.Effect<PiRpcRecord>;
  readonly queueEntries: (data: unknown) => void;
  readonly queueMessages: (data: unknown) => void;
  readonly vetoNextSwitch: () => void;
  readonly queueState: (data: Record<string, unknown>) => void;
  readonly setStreaming: (streaming: boolean) => void;
  readonly setCompacting: (compacting: boolean) => void;
  readonly deferNextState: () => void;
  readonly resolveDeferredState: (data: unknown) => Effect.Effect<void>;
  readonly failNextState: () => void;
  readonly deferNextLifecycle: (type: "switch_session" | "new_session" | "fork" | "abort") => void;
  readonly deferNextModelSelection: () => void;
  readonly queueModels: (models: ReadonlyArray<unknown>) => void;
  readonly vetoNextNewSession: () => void;
  readonly allRequests: () => ReadonlyArray<PiRpcRecord>;
  readonly queueStats: (data: unknown) => void;
  /** Pi before 0.84.4 answers clear_queue as an unknown command. */
  readonly setClearQueue: (
    result:
      | { readonly steering: ReadonlyArray<string>; readonly followUp: ReadonlyArray<string> }
      | "unknown_command",
  ) => void;
  readonly closeStdout: Effect.Effect<void>;
  readonly lastSpawn: () => {
    readonly args: ReadonlyArray<string>;
    readonly env: NonNullable<ChildProcess.CommandOptions["env"]>;
  };
}

/** Pi omits `model` when none is selected and `sessionName` until one is set. */
const recordedIdleState = (sessionFile: string) => ({
  thinkingLevel: "high",
  isStreaming: false,
  isCompacting: false,
  steeringMode: "one-at-a-time",
  followUpMode: "one-at-a-time",
  sessionFile,
  sessionId: "00000000-0000-4000-8000-000000000002",
  autoCompactionEnabled: true,
  messageCount: 0,
  pendingMessageCount: 0,
});

/** Pi 1.4.0 rejects every prompt while compaction runs, including steers. */
const PI_COMPACTING_PROMPT_ERROR =
  "Cannot submit a prompt while compaction is in progress. Wait for compaction to finish and retry.";

const makeFakePi: Effect.Effect<FakePi> = Effect.gen(function* () {
  const stdout = yield* Queue.unbounded<Uint8Array, Cause.Done>();
  const requests = yield* Queue.unbounded<PiRpcRecord>();
  const entriesQueue: Array<unknown> = [];
  const messagesQueue: Array<unknown> = [];
  const stateQueue: Array<Record<string, unknown>> = [];
  const statsQueue: Array<unknown> = [];
  const allRequests: Array<PiRpcRecord> = [];
  let deferState = false;
  let deferredStateRequest: PiRpcRecord | undefined;
  let failState = false;
  let vetoSwitch = false;
  let vetoNewSession = false;
  let deferredLifecycle: string | undefined;
  let sessionFile = FAKE_SESSION_FILE;
  let sessionGeneration = 0;
  let models: ReadonlyArray<unknown> = [];
  let isStreaming: boolean | null = null;
  let isCompacting = false;
  let clearQueue: Parameters<FakePi["setClearQueue"]>[0] = { steering: [], followUp: [] };
  let stdinBuffer = "";

  const emit = (record: PiRpcRecord, chunkBytes?: number) =>
    Effect.gen(function* () {
      const bytes = new TextEncoder().encode(`${encodeJsonLine(record)}\n`);
      const size = chunkBytes ?? bytes.byteLength;
      for (let offset = 0; offset < bytes.byteLength; offset += size) {
        yield* Queue.offer(stdout, bytes.subarray(offset, offset + size));
      }
    });

  const respondTo = (record: PiRpcRecord): PiRpcRecord | null => {
    if (
      typeof record["id"] !== "string" &&
      !(record["type"] === "prompt" && (isStreaming !== null || isCompacting))
    )
      return null;
    const base = {
      type: "response",
      id: record["id"],
      command: String(record["type"]),
      success: true,
    };
    switch (record["type"]) {
      case "get_state":
        if (failState) {
          failState = false;
          return { ...base, success: false, error: "state unavailable" };
        }
        return {
          ...base,
          data: {
            ...recordedIdleState(sessionFile),
            isStreaming: isStreaming ?? false,
            ...stateQueue.shift(),
          },
        };
      case "prompt":
        if (isCompacting) {
          return { ...base, success: false, error: PI_COMPACTING_PROMPT_ERROR };
        }
        if (isStreaming && record["streamingBehavior"] === undefined) {
          return {
            ...base,
            success: false,
            error:
              "Agent is already processing. Specify streamingBehavior ('steer' or 'followUp') to queue the message.",
          };
        }
        return base;
      case "get_available_models":
        return { ...base, data: { models } };
      case "new_session": {
        const cancelled = vetoNewSession;
        vetoNewSession = false;
        if (!cancelled) sessionFile = `/fake/new-${++sessionGeneration}.jsonl`;
        return { ...base, data: { cancelled } };
      }
      case "switch_session": {
        const cancelled = vetoSwitch;
        vetoSwitch = false;
        return { ...base, data: { cancelled } };
      }
      case "get_entries":
        return { ...base, data: entriesQueue.shift() ?? { entries: [], leafId: null } };
      case "get_messages":
        return { ...base, data: messagesQueue.shift() ?? { messages: [] } };
      case "get_session_stats":
        return { ...base, data: statsQueue.shift() ?? {} };
      case "fork":
        return { ...base, data: { text: "Hello pi", cancelled: false } };
      case "clear_queue":
        return clearQueue === "unknown_command"
          ? { ...base, success: false, error: "Unknown command: clear_queue" }
          : { ...base, data: clearQueue };
      default:
        return base;
    }
  };

  const handleStdinChunk = (chunk: Uint8Array) =>
    Effect.gen(function* () {
      stdinBuffer += new TextDecoder().decode(chunk);
      while (true) {
        const newline = stdinBuffer.indexOf("\n");
        if (newline === -1) return;
        const line = stdinBuffer.slice(0, newline);
        stdinBuffer = stdinBuffer.slice(newline + 1);
        if (line.length === 0) continue;
        const record = decodeJsonLine(line) as PiRpcRecord;
        allRequests.push(record);
        yield* Queue.offer(requests, record);
        if (record["type"] === "get_state" && deferState) {
          deferState = false;
          deferredStateRequest = record;
          continue;
        }
        if (record["type"] === deferredLifecycle) {
          deferredLifecycle = undefined;
          continue;
        }
        const response = respondTo(record);
        if (response !== null) yield* emit(response);
      }
    });

  let lastSpawn: ReturnType<FakePi["lastSpawn"]> = {
    args: [],
    env: {},
  };
  const spawner = ChildProcessSpawner.make((command) =>
    Effect.sync(() => {
      if (ChildProcess.isStandardCommand(command)) {
        lastSpawn = {
          args: command.args.map(String),
          env: command.options.env ?? {},
        };
      }
      return ChildProcessSpawner.makeHandle({
        pid: ChildProcessSpawner.ProcessId(FAKE_PID),
        exitCode: Effect.never,
        isRunning: Effect.succeed(true),
        kill: () => Effect.void,
        unref: Effect.succeed(Effect.void),
        stdin: Sink.forEach(handleStdinChunk),
        stdout: Stream.fromQueue(stdout),
        stderr: Stream.empty,
        all: Stream.empty,
        getInputFd: () => Sink.drain,
        getOutputFd: () => Stream.empty,
      });
    }),
  );

  const takeRequest = (type: string): Effect.Effect<PiRpcRecord> =>
    Effect.gen(function* () {
      while (true) {
        const record = yield* Queue.take(requests);
        if (record["type"] === type) return record;
      }
    });

  return {
    spawner,
    emit,
    takeRequest,
    queueEntries: (data) => entriesQueue.push(data),
    queueMessages: (data) => messagesQueue.push(data),
    deferNextState: () => {
      deferState = true;
    },
    resolveDeferredState: (data) =>
      Effect.gen(function* () {
        const record = deferredStateRequest;
        assert.isDefined(record);
        deferredStateRequest = undefined;
        yield* emit({
          type: "response",
          id: record!["id"],
          command: "get_state",
          success: true,
          data,
        });
      }),
    failNextState: () => {
      failState = true;
    },
    deferNextLifecycle: (type) => {
      deferredLifecycle = type;
    },
    deferNextModelSelection: () => {
      deferredLifecycle = "set_model";
    },
    queueModels: (value) => {
      models = value;
    },
    vetoNextNewSession: () => {
      vetoNewSession = true;
    },
    allRequests: () => allRequests,
    vetoNextSwitch: () => {
      vetoSwitch = true;
    },
    queueState: (data) => stateQueue.push(data),
    setStreaming: (streaming) => {
      isStreaming = streaming;
    },
    setCompacting: (compacting) => {
      isCompacting = compacting;
    },
    queueStats: (data) => statsQueue.push(data),
    setClearQueue: (result) => {
      clearQueue = result;
    },
    closeStdout: Queue.end(stdout),
    lastSpawn: () => lastSpawn,
  } satisfies FakePi;
});

const makeAdapter = Effect.fnUntraced(function* (
  fake: FakePi,
  launchArgs = "",
  forkFake?: FakePi,
  continuationRequests?: PiAdapterV2Options["continuationRequests"],
) {
  const spawner =
    forkFake === undefined
      ? fake.spawner
      : ChildProcessSpawner.make((command) =>
          ChildProcess.isStandardCommand(command) && command.args.includes("--fork")
            ? forkFake.spawner.spawn(command)
            : fake.spawner.spawn(command),
        );
  if (continuationRequests !== undefined) {
    return yield* PiAdapterV2Driver.create({
      instanceId: PI_INSTANCE_ID,
      displayName: undefined,
      enabled: true,
      environment: [],
      config: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
    }).pipe(
      Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
      Effect.provideService(HostProcess.Environment, {}),
      Effect.provideService(ProviderContinuationRequests.ProviderContinuationRequests, {
        ...continuationRequests,
        take: Effect.never,
      }),
    );
  }
  return yield* makePiAdapterV2({
    instanceId: PI_INSTANCE_ID,
    settings: { enabled: true, binaryPath: "pi", launchArgs, customModels: [] },
    environment: {},
  }).pipe(Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner));
});

const openRuntime = Effect.fnUntraced(function* (
  fake: FakePi,
  model = "default",
  threadId = THREAD_ID,
  providerSessionId = SESSION_ID,
  forkFake?: FakePi,
  continuationRequests?: PiAdapterV2Options["continuationRequests"],
) {
  const adapter = yield* makeAdapter(fake, "", forkFake, continuationRequests);
  const runtime = yield* adapter.openSession({
    threadId,
    providerSessionId,
    modelSelection: modelSelection(model),
    runtimePolicy,
  });
  const emitted = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
  yield* runtime.events.pipe(
    Stream.runForEach((event) => Queue.offer(emitted, event)),
    Effect.forkScoped,
  );
  const takeEvent = (predicate: (event: ProviderAdapter.ProviderAdapterV2Event) => boolean) =>
    Effect.gen(function* () {
      while (true) {
        const event = yield* Queue.take(emitted);
        if (predicate(event)) return event;
      }
    });
  return { runtime, takeEvent };
});

const makeAppThread = Effect.fnUntraced(function* (model: string, threadId = THREAD_ID) {
  const now = yield* DateTime.now;
  return {
    createdBy: "user",
    creationSource: "web",
    id: threadId,
    projectId: "project:fixture:pi" as OrchestrationV2AppThread["projectId"],
    title: "Pi test thread",
    providerInstanceId: PI_INSTANCE_ID,
    modelSelection: modelSelection(model),
    runtimeMode: "full-access",
    interactionMode: "default",
    branch: null,
    worktreePath: null,
    activeProviderThreadId: null,
    lineage: { parentThreadId: null, relationshipToParent: null, rootThreadId: threadId },
    forkedFrom: null,
    createdAt: now,
    updatedAt: now,
    archivedAt: null,
    settledOverride: null,
    settledAt: null,
    lastVisitedAt: null,
    deletedAt: null,
  } satisfies OrchestrationV2AppThread;
});

const startTurn = Effect.fnUntraced(function* (
  runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime,
  providerThread: OrchestrationV2ProviderThread,
  model = "default",
  attachments: ReadonlyArray<ChatAttachment> = [],
  text = "Hello pi",
  selection?: ModelSelection,
  runOrdinal = 1,
  threadId = THREAD_ID,
  continuation = false,
) {
  const appThread = yield* makeAppThread(model, threadId);
  const runId = RunId.make(`run:${threadId}:${runOrdinal}`);
  yield* runtime.startTurn({
    appThread,
    threadId,
    runId,
    runOrdinal,
    providerTurnOrdinal: runOrdinal,
    attemptId: RunAttemptId.make(`run-attempt:${runId}:1`),
    rootNodeId: NodeId.make(`node:${runId}:root`),
    providerThread,
    message: {
      messageId: `message:${threadId}:${runOrdinal}` as never,
      text,
      attachments,
      createdBy: continuation ? "agent" : "user",
      creationSource: continuation ? "provider" : "web",
    },
    modelSelection: selection ?? modelSelection(model),
    runtimePolicy,
  });
});

describe("PiAdapterV2", () => {
  it.effect(
    "replaces keyed extension statuses while idle without producing conversation items",
    () =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const updates = [
          { statusKey: "watch", statusText: "\u001b[32mWatching 3 files\u001b[0m\u0007" },
          { statusKey: "lint", statusText: "Lint clean" },
          { statusKey: "watch", statusText: "Watching 4 files" },
          { statusKey: "watch", statusText: "Watching 4 files" },
          { statusKey: "watch", statusText: "\u001b[32mWatching 4 files\u001b[0m" },
          { statusKey: "lint", statusText: "" },
          { statusKey: "missing" },
          { statusKey: "watch" },
          { statusKey: "watch", statusText: "Watching 4 files" },
        ];
        for (const update of updates) {
          yield* fake.emit({ type: "extension_ui_request", method: "setStatus", ...update });
        }
        // The following dialog is an observable milestone after the preceding native notifications.
        yield* fake.emit({
          type: "extension_ui_request",
          id: "status-barrier",
          method: "input",
          title: "Continue?",
        });
        const observed: ProviderAdapter.ProviderAdapterV2Event[] = [];
        yield* takeEvent((event) => {
          observed.push(event);
          return event.type === "runtime_request.updated";
        });
        assert.deepInclude(runtime.providerSession, {
          extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
        });
        const snapshots = observed.filter((event) => event.type === "provider_session.updated");
        assert.lengthOf(snapshots, 6);
        assert.deepInclude(snapshots[0]?.providerSession, {
          extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
        });
        assert.deepInclude(snapshots[2]?.providerSession, {
          extensionStatuses: [
            { key: "watch", text: "Watching 4 files" },
            { key: "lint", text: "Lint clean" },
          ],
        });
        assert.isFalse(observed.some((event) => event.type === "message.updated"));
        assert.isFalse(
          observed.some(
            (event) =>
              event.type === "turn_item.updated" && event.turnItem.type !== "user_input_request",
          ),
        );
        assert.isFalse(
          fake.allRequests().some((request) => request["type"] === "extension_ui_response"),
        );
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("bounds native extension statuses and lets cleared keys free capacity", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const { runtime, takeEvent } = yield* openRuntime(fake);
      for (let index = 0; index < 35; index++) {
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: `key-${index}`,
          statusText: index === 1 ? "w".repeat(20000) : "Watching",
        });
      }
      for (const update of [
        { statusKey: "" },
        { statusKey: "x".repeat(257) },
        { statusKey: "malformed", statusText: null },
      ]) {
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusText: "Invalid",
          ...update,
        });
      }
      yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "key-0" });
      yield* fake.emit({
        type: "extension_ui_request",
        method: "setStatus",
        statusKey: "replacement",
        statusText: "New status",
      });
      yield* fake.emit({
        type: "extension_ui_request",
        id: "status-barrier",
        method: "input",
        title: "Continue?",
      });
      yield* takeEvent((event) => event.type === "runtime_request.updated");
      const statuses = runtime.providerSession.extensionStatuses ?? [];
      assert.lengthOf(statuses, 32);
      assert.equal(statuses[0]?.key, "key-1");
      assert.equal(statuses[0]?.text.length, 4096);
      assert.deepEqual(statuses.at(-1), { key: "replacement", text: "New status" });
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("publishes extension status while native work awaits adoption", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const offers =
        yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
      const { runtime, takeEvent } = yield* openRuntime(
        fake,
        "default",
        THREAD_ID,
        SESSION_ID,
        undefined,
        { offer: (offer) => Queue.offer(offers, offer).pipe(Effect.asVoid) },
      );
      yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({ type: "agent_start" });
      yield* Queue.take(offers);
      yield* fake.emit({
        type: "extension_ui_request",
        method: "setStatus",
        statusKey: "watch",
        statusText: "Native wake",
      });
      yield* fake.emit({
        type: "extension_ui_request",
        id: "status-barrier",
        method: "input",
        title: "Continue?",
      });
      yield* takeEvent((event) => event.type === "runtime_request.updated");
      assert.deepEqual(runtime.providerSession.extensionStatuses, [
        { key: "watch", text: "Native wake" },
      ]);
      assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect(
    "keeps extension status through turn settlement and clears it on native session replacement",
    () =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* startTurn(runtime, providerThread);
        yield* fake.takeRequest("prompt");
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: "watch",
          statusText: "Watching",
        });
        yield* fake.emit({ type: "agent_settled" });
        yield* takeEvent((event) => event.type === "turn.terminal");
        assert.deepInclude(runtime.providerSession, {
          status: "ready",
          extensionStatuses: [{ key: "watch", text: "Watching" }],
        });
        yield* startTurn(
          runtime,
          providerThread,
          "anthropic/other-model",
          [],
          "Hello again",
          undefined,
          2,
        );
        assert.deepEqual(runtime.providerSession.extensionStatuses, [
          { key: "watch", text: "Watching" },
        ]);
        yield* fake.emit({ type: "agent_settled" });
        yield* takeEvent((event) => event.type === "turn.terminal");
        yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each(["model error", "rejected prompt", "failed compact"] as const)(
    "keeps extension status through a reusable %s and the next turn",
    (failure) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: "watch",
          statusText: "Watching 3 files",
        });
        const command = failure === "failed compact" ? "compact" : "prompt";
        yield* startTurn(
          runtime,
          providerThread,
          "default",
          [],
          command === "compact" ? "/compact" : "Hello pi",
        );
        yield* fake.takeRequest(command);
        if (failure === "model error") {
          yield* fake.emit({
            type: "message_end",
            message: { role: "assistant", stopReason: "error", errorMessage: "Rate limited" },
          });
          yield* fake.emit({ type: "agent_settled" });
        } else {
          yield* fake.emit({
            type: "response",
            command,
            success: false,
            error: "Request rejected",
          });
        }
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "failed");
        assert.deepInclude(runtime.providerSession, {
          status: "error",
          extensionStatuses: [{ key: "watch", text: "Watching 3 files" }],
        });

        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: "watch",
          statusText: "Watching 4 files",
        });
        yield* fake.emit({
          type: "extension_ui_request",
          id: "failed-turn-status-barrier",
          method: "input",
          title: "Continue?",
        });
        yield* takeEvent((event) => event.type === "runtime_request.updated");
        assert.deepInclude(runtime.providerSession, {
          status: "error",
          extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
        });

        yield* startTurn(runtime, providerThread, "default", [], "Hello again", undefined, 2);
        yield* fake.takeRequest("prompt");
        yield* fake.emit({ type: "agent_settled" });
        const nextTerminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(nextTerminal.type === "turn.terminal" && nextTerminal.status === "completed");
        assert.deepInclude(runtime.providerSession, {
          id: SESSION_ID,
          status: "ready",
          extensionStatuses: [{ key: "watch", text: "Watching 4 files" }],
        });
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("preserves extension statuses when a native session switch is vetoed", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const { runtime, takeEvent } = yield* openRuntime(fake);
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({
        type: "extension_ui_request",
        method: "setStatus",
        statusKey: "watch",
        statusText: "Watching",
      });
      yield* fake.emit({
        type: "extension_ui_request",
        id: "status-barrier",
        method: "input",
        title: "Continue?",
      });
      yield* takeEvent((event) => event.type === "runtime_request.updated");
      fake.vetoNextSwitch();
      const exit = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
      assert.isTrue(Exit.isFailure(exit));
      assert.deepEqual(runtime.providerSession.extensionStatuses, [
        { key: "watch", text: "Watching" },
      ]);
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each(["success", "cancelled", "error"] as const)(
    "handles native status publications during session switch hooks, outcome=%s",
    (outcome) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        for (const key of ["watch", "lint"])
          yield* fake.emit({
            type: "extension_ui_request",
            method: "setStatus",
            statusKey: key,
            statusText: key === "lint" ? "Lint clean" : "Watching",
          });
        fake.deferNextLifecycle("switch_session");
        const switching = yield* runtime
          .resumeThread({ providerThread })
          .pipe(Effect.exit, Effect.forkScoped);
        const request = yield* fake.takeRequest("switch_session");
        yield* fake.emit({ type: "extension_ui_request", method: "setStatus", statusKey: "watch" });
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: "startup",
          statusText: "Fresh status",
        });
        yield* fake.emit({
          type: "extension_ui_request",
          id: "switch-hook",
          method: "input",
          title: "Continue?",
        });
        yield* takeEvent((event) => event.type === "runtime_request.updated");
        yield* fake.emit({
          type: "response",
          id: request["id"],
          command: "switch_session",
          success: outcome !== "error",
          data: { cancelled: outcome === "cancelled" },
          ...(outcome === "error" ? { error: "Session replacement failed" } : {}),
        });
        const exit = yield* Fiber.join(switching);
        assert.equal(Exit.isFailure(exit), outcome !== "success");
        if (outcome === "error") {
          const reuse = yield* runtime.resumeThread({ providerThread }).pipe(Effect.exit);
          assert.isTrue(Exit.isFailure(reuse));
          yield* takeEvent(
            (event) =>
              event.type === "provider_session.updated" && event.providerSession.status === "error",
          );
          assert.deepEqual(runtime.providerSession.extensionStatuses, []);
          return;
        }
        assert.deepEqual(runtime.providerSession.extensionStatuses, [
          ...(outcome === "cancelled" ? [{ key: "lint", text: "Lint clean" }] : []),
          { key: "startup", text: "Fresh status" },
        ]);
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each(["stop", "transport death"] as const)(
    "clears extension statuses on %s",
    (retirement) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* startTurn(runtime, providerThread);
        const turnStarted = yield* takeEvent((event) => event.type === "provider_turn.updated");
        assert.equal(turnStarted.type, "provider_turn.updated");
        if (turnStarted.type !== "provider_turn.updated") return;
        yield* fake.emit({
          type: "extension_ui_request",
          method: "setStatus",
          statusKey: "watch",
          statusText: "Watching",
        });
        yield* fake.emit({
          type: "extension_ui_request",
          id: "status-barrier",
          method: "input",
          title: "Continue?",
        });
        yield* takeEvent((event) => event.type === "runtime_request.updated");
        assert.deepInclude(runtime.providerSession, {
          extensionStatuses: [{ key: "watch", text: "Watching" }],
        });
        if (retirement === "stop") {
          yield* runtime.interruptTurn({
            providerThread,
            providerTurnId: turnStarted.providerTurn.id,
            requestRuntimeRestart: true,
          });
        } else yield* fake.closeStdout;
        yield* takeEvent(
          (event) =>
            event.type === "provider_session.updated" &&
            event.providerSession.status === (retirement === "stop" ? "stopped" : "error"),
        );
        assert.deepInclude(runtime.providerSession, { extensionStatuses: [] });
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("keeps native image bytes and the saved path in the prompt", () =>
    Effect.gen(function* () {
      const host = yield* ProviderHost.ProviderHost;
      const fileSystem = yield* FileSystem.FileSystem;
      const attachment: ChatAttachment = {
        id: ChatAttachmentId.make("image"),
        type: "image",
        name: "image.png",
        mimeType: "image/png",
        sizeBytes: 3,
      };
      const path = host.resolveAttachmentPath(attachment)!;
      yield* fileSystem.writeFile(path, new Uint8Array([1, 2, 3]));
      const fake = yield* makeFakePi;
      const { runtime } = yield* openRuntime(fake);
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* startTurn(runtime, providerThread, "default", [attachment]);
      const prompt = yield* fake.takeRequest("prompt");
      assert.include(String(prompt["message"]), path);
      assert.deepEqual(prompt["images"], [{ type: "image", data: "AQID", mimeType: "image/png" }]);
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("lists unavailable attachments alongside resolvable files in the native prompt", () =>
    Effect.gen(function* () {
      const host = yield* ProviderHost.ProviderHost;
      const fake = yield* makeFakePi;
      const { runtime } = yield* openRuntime(fake).pipe(
        Effect.provideService(ProviderHost.ProviderHost, {
          ...host,
          resolveAttachmentPath: (attachment) =>
            attachment.id === "available" ? host.resolveAttachmentPath(attachment) : null,
        }),
      );
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      const attachments: ReadonlyArray<ChatAttachment> = [
        {
          id: ChatAttachmentId.make("available"),
          type: "file",
          name: "notes.txt",
          mimeType: "text/plain",
          sizeBytes: 1,
        },
        {
          id: ChatAttachmentId.make("missing-file"),
          type: "file",
          name: "missing.txt",
          mimeType: "text/plain",
          sizeBytes: 1,
        },
        {
          id: ChatAttachmentId.make("missing-image"),
          type: "image",
          name: "missing.png",
          mimeType: "image/png",
          sizeBytes: 1,
        },
        {
          id: ChatAttachmentId.make("missing-future"),
          type: "future",
          name: "future.bin",
          mimeType: "application/octet-stream",
          sizeBytes: 1,
        },
      ];
      yield* startTurn(runtime, providerThread, "default", attachments);
      const prompt = yield* fake.takeRequest("prompt");
      assert.isString(prompt["message"]);
      const message = String(prompt["message"]);
      assert.include(message, host.resolveAttachmentPath(attachments[0]!)!);
      for (const attachment of attachments.slice(1)) {
        assert.include(message, attachment.name);
        assert.include(message, attachment.id);
      }
      assert.equal((message.match(/unavailable/g) ?? []).length, 3);
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([false, true])(
    "completes a resumed user turn before native wake events arrive, Pi streaming=%s",
    (streaming) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const { runtime, takeEvent } = yield* openRuntime(fake);
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        fake.setStreaming(streaming);
        yield* runtime.resumeThread({ providerThread });
        yield* startTurn(runtime, providerThread);
        yield* fake.takeRequest("prompt");
        yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({
          type: "message_end",
          message: {
            role: "assistant",
            content: [{ type: "text", text: "Resumed prompt completed" }],
            stopReason: "stop",
          },
        });
        fake.queueState({ isStreaming: false });
        yield* fake.emit({ type: "agent_settled" });
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([false, true])(
    "serializes rollback fork hooks with native wake ownership, wake=%s",
    (nativeWake) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const offers =
          yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
        const { runtime, takeEvent } = yield* openRuntime(
          fake,
          "default",
          THREAD_ID,
          SESSION_ID,
          undefined,
          {
            offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
          },
        );
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        fake.deferNextLifecycle("fork");
        const rollingBack = yield* runtime
          .rollbackThread({
            providerThread,
            target: {
              type: "thread_start",
              checkpointId: CheckpointId.make("checkpoint-start"),
              appRunOrdinal: 0,
            },
            providerThreadTurns: [
              {
                id: ProviderTurnId.make("previous-turn"),
                providerThreadId: providerThread.id,
                nodeId: NodeId.make("previous-node"),
                runAttemptId: null,
                nativeTurnRef: {
                  driver: PI_PROVIDER,
                  nativeId: "user-before-wake",
                  strength: "strong",
                },
                ordinal: 1,
                status: "completed",
                startedAt: providerThread.createdAt,
                completedAt: providerThread.createdAt,
              },
            ],
          })
          .pipe(Effect.result, Effect.forkScoped);
        const fork = yield* fake.takeRequest("fork");
        const overlappingTurn = yield* startTurn(runtime, providerThread).pipe(Effect.result);
        assert.equal(overlappingTurn._tag, "Failure");
        const overlappingRegistration = yield* runtime
          .ensureThread({
            threadId: THREAD_ID,
            modelSelection: modelSelection("default"),
            runtimePolicy,
          })
          .pipe(Effect.result);
        assert.equal(overlappingRegistration._tag, "Failure");
        yield* fake.emit({
          type: "extension_ui_request",
          id: "fork-hook-dialog",
          method: "confirm",
          title: "Restore this branch?",
        });
        const forkDialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
        assert.isTrue(forkDialog.type === "runtime_request.updated");
        if (forkDialog.type !== "runtime_request.updated") return;
        assert.isNull(forkDialog.runtimeRequest.providerTurnId);
        yield* runtime.respondToRuntimeRequest({
          requestId: forkDialog.runtimeRequest.id,
          decision: "accept",
        });
        yield* fake.takeRequest("extension_ui_response");
        if (nativeWake) {
          yield* fake.emit({ type: "agent_start" });
          yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
          yield* fake.emit({
            type: "message_update",
            assistantMessageEvent: {
              type: "text_end",
              contentIndex: 0,
              content: "Discarded branch wake output",
            },
          });
          yield* fake.emit({ type: "agent_settled" });
          const retired = yield* takeEvent(
            (event) =>
              event.type === "provider_session.updated" &&
              event.providerSession.status === "stopped",
          ).pipe(Effect.as(true), Effect.raceFirst(Queue.take(offers).pipe(Effect.as(false))));
          assert.isTrue(retired, "Pi offered native work while rollback was changing its binding");
          const result = yield* Fiber.join(rollingBack);
          assert.equal(result._tag, "Failure");
          assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
          const staleTurn = yield* startTurn(
            runtime,
            providerThread,
            "default",
            [],
            "Synthetic wake",
            undefined,
            1,
            THREAD_ID,
            true,
          ).pipe(Effect.result);
          assert.equal(staleTurn._tag, "Failure");
          assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
          return;
        }
        fake.queueState({ sessionFile: "/fake/rolled-back-session.jsonl" });
        yield* fake.emit({
          type: "response",
          id: fork["id"],
          command: "fork",
          success: true,
          data: { cancelled: false },
        });
        const result = yield* Fiber.join(rollingBack);
        assert.equal(result._tag, "Success");
        if (result._tag !== "Success") return;
        assert.equal(
          result.success.providerThread.nativeThreadRef?.nativeId,
          "/fake/rolled-back-session.jsonl",
        );
        yield* startTurn(runtime, result.success.providerThread);
        const prompt = yield* fake.takeRequest("prompt");
        assert.equal(prompt["message"], "Hello pi");
        yield* fake.emit({ type: "response", command: "prompt", success: true });
        yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({ type: "agent_settled" });
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([false, true])(
    "retains native wake ownership and delivers a joining prompt held through compaction, aborted=%s",
    (aborted) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const offers =
          yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
        const { runtime, takeEvent } = yield* openRuntime(
          fake,
          "default",
          THREAD_ID,
          SESSION_ID,
          undefined,
          {
            offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
          },
        );
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* fake.takeRequest("get_state");
        yield* fake.emit({ type: "agent_start" });
        yield* Queue.take(offers);
        yield* fake.emit({ type: "agent_settled" });
        yield* fake.emit({ type: "compaction_start", reason: "manual" });
        yield* startTurn(runtime, providerThread);
        yield* fake.emit({
          type: "extension_ui_request",
          id: "native-compaction-dialog",
          method: "confirm",
          title: "Continue native work?",
        });
        const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
        assert.isTrue(dialog.type === "runtime_request.updated");
        if (dialog.type !== "runtime_request.updated") return;
        assert.isNotNull(dialog.runtimeRequest.providerTurnId);
        yield* runtime.respondToRuntimeRequest({
          requestId: dialog.runtimeRequest.id,
          decision: "accept",
        });
        yield* fake.takeRequest("extension_ui_response");
        assert.isFalse(fake.allRequests().some((request) => request["type"] === "prompt"));
        yield* fake.emit(
          aborted
            ? { type: "compaction_end", result: null, aborted: true }
            : {
                type: "compaction_end",
                result: { summary: "Native compaction finished" },
                willRetry: true,
              },
        );
        const prompt = yield* fake.takeRequest("prompt");
        assert.equal(prompt["message"], "Hello pi");
        fake.queueState({ isStreaming: true });
        yield* fake.emit({ type: "response", command: "prompt", success: true });
        yield* fake.takeRequest("get_state");
        yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
        yield* fake.emit({
          type: "message_update",
          assistantMessageEvent: {
            type: "text_end",
            contentIndex: 0,
            content: "Native work completed",
          },
        });
        const message = yield* takeEvent((event) => event.type === "message.updated");
        assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
        yield* fake.emit({ type: "agent_settled" });
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
        assert.equal(
          fake.allRequests().filter((request) => request["type"] === "prompt").length,
          1,
        );
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("rejects rollback while native wake output is awaiting ownership", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const offers =
        yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
      const { runtime, takeEvent } = yield* openRuntime(
        fake,
        "default",
        THREAD_ID,
        SESSION_ID,
        undefined,
        {
          offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
        },
      );
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({ type: "agent_start" });
      yield* Queue.take(offers);
      yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
      yield* fake.emit({
        type: "message_update",
        assistantMessageEvent: {
          type: "text_end",
          contentIndex: 0,
          content: "Current branch wake output",
        },
      });
      yield* fake.emit({ type: "agent_settled" });
      yield* takeEvent(
        (event) =>
          event.type === "provider_session.updated" && event.providerSession.status === "ready",
      );
      const rolledBack = yield* runtime
        .rollbackThread({
          providerThread,
          target: {
            type: "thread_start",
            checkpointId: CheckpointId.make("checkpoint-start"),
            appRunOrdinal: 0,
          },
          providerThreadTurns: [
            {
              id: ProviderTurnId.make("previous-turn"),
              providerThreadId: providerThread.id,
              nodeId: NodeId.make("previous-node"),
              runAttemptId: null,
              nativeTurnRef: {
                driver: PI_PROVIDER,
                nativeId: "user-before-wake",
                strength: "strong",
              },
              ordinal: 1,
              status: "completed",
              startedAt: providerThread.createdAt,
              completedAt: providerThread.createdAt,
            },
          ],
        })
        .pipe(Effect.result);
      assert.equal(
        rolledBack._tag,
        "Failure",
        "Rollback changed the native session while its wake was still buffered",
      );
      assert.isFalse(fake.allRequests().some((request) => request["type"] === "fork"));
      assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
      yield* startTurn(
        runtime,
        providerThread,
        "default",
        [],
        "Synthetic wake",
        undefined,
        1,
        THREAD_ID,
        true,
      );
      const message = yield* takeEvent((event) => event.type === "message.updated");
      assert.equal(
        message.type === "message.updated" && message.message.text,
        "Current branch wake output",
      );
      yield* takeEvent((event) => event.type === "turn.terminal");
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("answers model-selection dialogs before a user turn claims a native wake", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const offers =
        yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
      const { runtime, takeEvent } = yield* openRuntime(
        fake,
        "default",
        THREAD_ID,
        SESSION_ID,
        undefined,
        { offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid) },
      );
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({ type: "agent_start" });
      yield* Queue.take(offers);
      const requests: Array<
        Extract<ProviderAdapter.ProviderAdapterV2Event, { type: "runtime_request.updated" }>
      > = [];
      fake.deferNextModelSelection();
      const starting = yield* startTurn(
        runtime,
        providerThread,
        "default",
        [],
        "Continue the review",
        modelSelection("xai/grok-4.6"),
      ).pipe(Effect.forkScoped);
      const modelRequest = yield* fake.takeRequest("set_model");
      yield* fake.emit({
        type: "extension_ui_request",
        id: "model-selection-dialog",
        method: "confirm",
        title: "Use this model?",
      });
      yield* fake.emit({ type: "agent_settled" });
      yield* takeEvent((event) => {
        if (event.type === "runtime_request.updated") requests.push(event);
        return (
          event.type === "provider_session.updated" && event.providerSession.status === "ready"
        );
      });
      const dialog = requests[0]?.runtimeRequest;
      assert.isDefined(dialog, "Pi buffered the dialog needed to finish model selection");
      assert.equal(requests[0]?.threadId, THREAD_ID);
      assert.isNull(dialog!.providerTurnId);
      yield* runtime.respondToRuntimeRequest({ requestId: dialog!.id, decision: "accept" });
      const response = yield* fake.takeRequest("extension_ui_response");
      assert.equal(response["id"], "model-selection-dialog");
      assert.isTrue(response["confirmed"]);
      yield* fake.emit({
        type: "response",
        id: modelRequest["id"],
        command: "set_model",
        success: true,
        data: { provider: "xai", id: "grok-4.6" },
      });
      yield* Fiber.join(starting);
      const prompt = yield* fake.takeRequest("prompt");
      assert.equal(prompt["message"], "Continue the review");
      assert.equal(prompt["streamingBehavior"], "steer");
      const resolved = yield* takeEvent(
        (event) =>
          event.type === "runtime_request.updated" && event.runtimeRequest.id === dialog!.id,
      );
      assert.isTrue(
        resolved.type === "runtime_request.updated" &&
          resolved.runtimeRequest.status === "resolved",
      );
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("adopts a completed native wake without sending a synthetic prompt", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const offers =
        yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
      const { runtime, takeEvent } = yield* openRuntime(
        fake,
        "default",
        THREAD_ID,
        SESSION_ID,
        undefined,
        {
          offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
        },
      );
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({ type: "agent_start" });
      const offer = yield* Queue.take(offers).pipe(
        Effect.raceFirst(
          takeEvent(
            (event) =>
              event.type === "provider_session.updated" && event.providerSession.status === "error",
          ).pipe(
            Effect.andThen(Effect.sync(() => assert.fail("Pi killed a routable native wake"))),
          ),
        ),
      );
      assert.equal(offer.threadId, THREAD_ID);
      assert.equal(offer.providerThreadId, providerThread.id);
      assert.equal(offer.delivery, "adapter_buffered");
      assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
      let dispatchCommitted = false;
      yield* offer.dispatchIfCurrent!(
        Effect.sync(() => {
          dispatchCommitted = true;
        }),
      );
      assert.isTrue(dispatchCommitted);
      assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
      yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
      yield* fake.emit({
        type: "message_update",
        assistantMessageEvent: {
          type: "text_delta",
          contentIndex: 0,
          delta: "Background review finished",
        },
      });
      yield* fake.emit({ type: "message_end", message: { role: "assistant" } });
      yield* fake.emit({ type: "agent_settled" });
      yield* takeEvent(
        (event) =>
          event.type === "provider_session.updated" && event.providerSession.status === "ready",
      );
      assert.isTrue(yield* runtime.hasPendingBackgroundWork!);
      yield* startTurn(
        runtime,
        providerThread,
        "default",
        [],
        "Synthetic wake",
        undefined,
        1,
        THREAD_ID,
        true,
      );
      const message = yield* takeEvent((event) => event.type === "message.updated");
      assert.equal(
        message.type === "message.updated" && message.message.text,
        "Background review finished",
      );
      yield* takeEvent((event) => event.type === "turn.terminal");
      assert.equal(fake.allRequests().filter((request) => request["type"] === "prompt").length, 0);
      assert.isFalse(yield* runtime.hasPendingBackgroundWork!);
      let dispatched = false;
      yield* offer.dispatchIfCurrent!(
        Effect.sync(() => {
          dispatched = true;
        }),
      );
      assert.isFalse(dispatched);
    }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([false, true])(
    "a user prompt takes the wake without premature settlement, native wake settled=%s",
    (settled) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const offers =
          yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
        const { runtime, takeEvent } = yield* openRuntime(
          fake,
          "default",
          THREAD_ID,
          SESSION_ID,
          undefined,
          {
            offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
          },
        );
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* fake.emit({ type: "agent_start" });
        const offer = yield* Queue.take(offers);
        if (settled) {
          yield* fake.emit({ type: "agent_settled" });
          yield* takeEvent(
            (event) =>
              event.type === "provider_session.updated" && event.providerSession.status === "ready",
          );
        }
        yield* startTurn(runtime, providerThread);
        const prompt = yield* fake.takeRequest("prompt");
        assert.equal(prompt["message"], "Hello pi");
        assert.equal(prompt["streamingBehavior"], "steer");
        yield* fake.emit({ type: "response", command: "prompt", success: true });
        yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({
          type: "extension_ui_request",
          id: "owned-dialog",
          method: "confirm",
          title: "Continue?",
        });
        const dialog = yield* takeEvent((event) => event.type === "runtime_request.updated");
        assert.isTrue(dialog.type === "runtime_request.updated");
        if (dialog.type !== "runtime_request.updated") return;
        assert.isNotNull(dialog.runtimeRequest.providerTurnId);
        yield* offer.clearIfCurrent!();
        yield* runtime.respondToRuntimeRequest({
          requestId: dialog.runtimeRequest.id,
          decision: "accept",
        });
        const response = yield* fake.takeRequest("extension_ui_response");
        assert.isTrue(response["confirmed"]);
        yield* fake.emit({ type: "message_start", message: { role: "assistant" } });
        yield* fake.emit({
          type: "message_update",
          assistantMessageEvent: {
            type: "text_end",
            contentIndex: 0,
            content: "User prompt completed",
          },
        });
        yield* fake.emit({ type: "agent_settled" });
        const message = yield* takeEvent(
          (event) =>
            event.type === "message.updated" && event.message.text === "User prompt completed",
        );
        assert.isTrue(message.type === "message.updated" && message.message.runId !== null);
        yield* takeEvent((event) => event.type === "turn.terminal");
        let dispatched = false;
        yield* offer.dispatchIfCurrent!(
          Effect.sync(() => {
            dispatched = true;
          }),
        );
        assert.isFalse(dispatched);
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([false, true])(
    "defers a wake's late settlement until the joined user prompt is acknowledged, aborted=%s",
    (aborted) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const offers =
          yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
        const { runtime, takeEvent } = yield* openRuntime(
          fake,
          "default",
          THREAD_ID,
          SESSION_ID,
          undefined,
          {
            offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
          },
        );
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* fake.emit({ type: "agent_start" });
        yield* Queue.take(offers);
        yield* startTurn(runtime, providerThread);
        yield* fake.takeRequest("prompt");
        yield* fake.emit({ type: "agent_settled", aborted });
        yield* fake.emit({
          type: "extension_ui_request",
          method: "notify",
          message: "Ordering barrier",
        });
        yield* takeEvent(
          (event) => event.type === "turn_item.updated" && event.turnItem.type === "system_notice",
        );
        assert.equal(runtime.providerSession.status, "running");
        fake.queueState({ isStreaming: true });
        yield* fake.emit({ type: "response", command: "prompt", success: true });
        yield* fake.takeRequest("get_state");
        yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({ type: "agent_settled" });
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === "completed");
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect.each([
    { aborted: false, resumes: false, expected: "completed" },
    { aborted: true, resumes: false, expected: "interrupted" },
    { aborted: true, resumes: true, expected: "completed" },
  ])(
    "settles a completed wake, aborted=$aborted, resumes=$resumes",
    ({ aborted, resumes, expected }) =>
      Effect.gen(function* () {
        const fake = yield* makeFakePi;
        const offers =
          yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
        const { runtime, takeEvent } = yield* openRuntime(
          fake,
          "default",
          THREAD_ID,
          SESSION_ID,
          undefined,
          {
            offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
          },
        );
        const providerThread = yield* runtime.ensureThread({
          threadId: THREAD_ID,
          modelSelection: modelSelection("default"),
          runtimePolicy,
        });
        yield* fake.emit({ type: "agent_start" });
        yield* Queue.take(offers);
        yield* fake.emit({ type: "agent_settled", aborted });
        yield* takeEvent(
          (event) =>
            event.type === "provider_session.updated" && event.providerSession.status === "ready",
        );
        yield* startTurn(runtime, providerThread, "default", [], "/hello");
        yield* fake.takeRequest("prompt");
        if (resumes) yield* fake.emit({ type: "agent_start" });
        yield* fake.emit({ type: "response", command: "prompt", success: true });
        if (resumes) yield* fake.emit({ type: "agent_settled", aborted: false });
        const terminal = yield* takeEvent((event) => event.type === "turn.terminal");
        assert.isTrue(terminal.type === "turn.terminal" && terminal.status === expected);
        yield* startTurn(
          runtime,
          providerThread,
          "default",
          [],
          "Stale continuation",
          undefined,
          2,
          THREAD_ID,
          true,
        );
        yield* takeEvent((event) => event.type === "turn.terminal");
        assert.equal(
          fake.allRequests().filter((request) => request["type"] === "prompt").length,
          1,
        );
      }).pipe(Effect.scoped, Effect.provide(layerTest)),
  );

  it.effect("keeps a pending wake on its thread and lets Stop retire its process", () =>
    Effect.gen(function* () {
      const fake = yield* makeFakePi;
      const offers =
        yield* Queue.unbounded<ProviderContinuationRequests.ProviderContinuationRequest>();
      const { runtime, takeEvent } = yield* openRuntime(
        fake,
        "default",
        THREAD_ID,
        SESSION_ID,
        undefined,
        {
          offer: (request) => Queue.offer(offers, request).pipe(Effect.asVoid),
        },
      );
      const providerThread = yield* runtime.ensureThread({
        threadId: THREAD_ID,
        modelSelection: modelSelection("default"),
        runtimePolicy,
      });
      yield* fake.emit({ type: "agent_start" });