@selesai/code 0.13.11 → 0.13.13

package/dist/extensions/pi-intercom/broker/extension-state.ts

@@ -1,197 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import {
-  closeSync,
-  copyFileSync,
-  existsSync,
-  fsyncSync,
-  mkdirSync,
-  openSync,
-  readFileSync,
-  renameSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
-
-const MAX_STATE_BYTES = 64 * 1024;
-
-interface StateEnvelope {
-  formatVersion: 1;
-  namespace: string;
-  revision: number;
-  updatedAt: number;
-  payloadSha256: string;
-  payload: unknown;
-}
-
-export interface StateCommitResult {
-  committed: boolean;
-  revision: number;
-  reason?: string;
-  payload?: unknown;
-}
-
-function serializePayload(payload: unknown): string | null {
-  try {
-    const json = JSON.stringify(payload);
-    if (json === undefined || Buffer.byteLength(json, "utf8") > MAX_STATE_BYTES) {
-      return null;
-    }
-    return json;
-  } catch {
-    return null;
-  }
-}
-
-function payloadHash(payloadJson: string): string {
-  return createHash("sha256").update(payloadJson).digest("hex");
-}
-
-export class ExtensionStateManager {
-  private readonly states = new Map<string, { revision: number; payload: unknown }>();
-  private readonly stateDir: string;
-
-  constructor(runtimeDir: string) {
-    this.stateDir = join(runtimeDir, "extension-state");
-    mkdirSync(this.stateDir, { recursive: true, mode: 0o700 });
-  }
-
-  private statePath(namespace: string): string {
-    const hash = createHash("sha256").update(namespace).digest("hex");
-    return join(this.stateDir, `${hash}.json`);
-  }
-
-  private backupPath(namespace: string): string {
-    return `${this.statePath(namespace)}.bak`;
-  }
-
-  private readEnvelope(filePath: string, namespace: string): StateEnvelope | null {
-    if (!existsSync(filePath)) return null;
-
-    try {
-      const content = readFileSync(filePath, "utf8");
-      const value: unknown = JSON.parse(content);
-      if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-
-      const envelope = value as Record<string, unknown>;
-      const revision = envelope.revision;
-      const updatedAt = envelope.updatedAt;
-      const payloadSha256 = envelope.payloadSha256;
-      if (
-        envelope.formatVersion !== 1
-        || envelope.namespace !== namespace
-        || typeof revision !== "number"
-        || !Number.isSafeInteger(revision)
-        || revision < 0
-        || typeof updatedAt !== "number"
-        || typeof payloadSha256 !== "string"
-      ) {
-        return null;
-      }
-
-      const payloadJson = serializePayload(envelope.payload);
-      if (payloadJson === null || payloadHash(payloadJson) !== payloadSha256) {
-        return null;
-      }
-
-      return {
-        formatVersion: 1,
-        namespace,
-        revision,
-        updatedAt,
-        payloadSha256,
-        payload: envelope.payload,
-      };
-    } catch {
-      return null;
-    }
-  }
-
-  loadState(namespace: string): { revision: number; payload: unknown } | null {
-    const cached = this.states.get(namespace);
-    if (cached) return cached;
-
-    const envelope = this.readEnvelope(this.statePath(namespace), namespace)
-      ?? this.readEnvelope(this.backupPath(namespace), namespace);
-    if (!envelope) return null;
-
-    const state = { revision: envelope.revision, payload: envelope.payload };
-    this.states.set(namespace, state);
-    return state;
-  }
-
-  commitState(namespace: string, expectedRevision: number, payload: unknown): StateCommitResult {
-    const payloadJson = serializePayload(payload);
-    const current = this.loadState(namespace);
-    const currentRevision = current?.revision ?? 0;
-
-    if (payloadJson === null) {
-      return {
-        committed: false,
-        revision: currentRevision,
-        reason: "Invalid extension state or payload exceeds 64 KiB limit",
-      };
-    }
-    if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
-      return { committed: false, revision: currentRevision, reason: "Invalid expected revision" };
-    }
-    if (expectedRevision !== currentRevision) {
-      return {
-        committed: false,
-        revision: currentRevision,
-        reason: "Revision mismatch",
-        ...(current ? { payload: current.payload } : {}),
-      };
-    }
-
-    const envelope: StateEnvelope = {
-      formatVersion: 1,
-      namespace,
-      revision: currentRevision + 1,
-      updatedAt: Date.now(),
-      payloadSha256: payloadHash(payloadJson),
-      payload,
-    };
-    const statePath = this.statePath(namespace);
-    const backupPath = this.backupPath(namespace);
-    const tempPath = `${statePath}.tmp.${process.pid}.${randomUUID()}`;
-
-    try {
-      writeFileSync(tempPath, JSON.stringify(envelope), { mode: 0o600 });
-      const file = openSync(tempPath, "r");
-      try {
-        fsyncSync(file);
-      } finally {
-        closeSync(file);
-      }
-
-      if (this.readEnvelope(statePath, namespace)) {
-        copyFileSync(statePath, backupPath);
-      }
-      renameSync(tempPath, statePath);
-
-      try {
-        const directory = openSync(dirname(statePath), "r");
-        try {
-          fsyncSync(directory);
-        } finally {
-          closeSync(directory);
-        }
-      } catch {
-        // Directory fsync is unavailable on some platforms.
-      }
-
-      const state = { revision: envelope.revision, payload };
-      this.states.set(namespace, state);
-      return { committed: true, revision: envelope.revision };
-    } catch {
-      return { committed: false, revision: currentRevision, reason: "Failed to persist extension state" };
-    } finally {
-      rmSync(tempPath, { force: true });
-    }
-  }
-
-  getCurrentRevision(namespace: string): number {
-    return this.loadState(namespace)?.revision ?? 0;
-  }
-}

package/dist/extensions/pi-intercom/broker/extension.test.ts

@@ -1,486 +0,0 @@
-import assert from "node:assert/strict";
-import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
-import { once } from "node:events";
-import { mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import test from "node:test";
-import type { BrokerMessage, SessionRegistration } from "../types.ts";
-import { IntercomClient } from "./client.ts";
-import { getTsxCliPath } from "./spawn.ts";
-import { ExtensionStateManager } from "./extension-state.ts";
-
-const repoDir = process.cwd();
-
-function registration(name: string, startedAt: number, ownerEligible?: boolean): SessionRegistration {
-  return {
-    name,
-    cwd: "/test",
-    model: "test-model",
-    pid: process.pid,
-    startedAt,
-    lastActivity: Date.now(),
-    ...(ownerEligible === undefined
-      ? {}
-      : { extensions: [{ namespace: "test/v1", ownerEligible }] }),
-  };
-}
-
-async function waitFor(
-  messages: BrokerMessage[],
-  predicate: (message: BrokerMessage) => boolean,
-  timeoutMs = 3000,
-): Promise<BrokerMessage> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const message = messages.find(predicate);
-    if (message) return message;
-    await new Promise((resolve) => setTimeout(resolve, 10));
-  }
-  throw new Error("Timed out waiting for broker message");
-}
-
-async function startBroker(agentDir: string): Promise<ChildProcessWithoutNullStreams> {
-  const broker = spawn(
-    process.execPath,
-    [getTsxCliPath(repoDir), path.join(repoDir, "broker", "broker.ts")],
-    {
-      cwd: repoDir,
-      env: { ...process.env, SELESAI_CODING_AGENT_DIR: agentDir },
-      stdio: ["pipe", "pipe", "pipe"],
-    },
-  );
-  const ready = new Promise<void>((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error("Broker startup timed out")), 10_000);
-    broker.stdout.on("data", (chunk: Buffer) => {
-      if (chunk.toString().includes("Intercom broker started")) {
-        clearTimeout(timeout);
-        resolve();
-      }
-    });
-    broker.once("exit", (code, signal) => {
-      clearTimeout(timeout);
-      reject(new Error(`Broker exited before startup (${code ?? signal}): ${broker.stderr.read()?.toString() ?? ""}`));
-    });
-  });
-  await ready;
-  return broker;
-}
-
-async function withIntercomScope<T>(scopeId: string | undefined, fn: () => T | Promise<T>): Promise<T> {
-  const previous = process.env.PI_INTERCOM_SCOPE_ID;
-  if (scopeId === undefined) delete process.env.PI_INTERCOM_SCOPE_ID;
-  else process.env.PI_INTERCOM_SCOPE_ID = scopeId;
-  try {
-    return await fn();
-  } finally {
-    if (previous === undefined) delete process.env.PI_INTERCOM_SCOPE_ID;
-    else process.env.PI_INTERCOM_SCOPE_ID = previous;
-  }
-}
-
-async function connectScoped(client: IntercomClient, scopeId: string | undefined, session: SessionRegistration, sessionId: string): Promise<void> {
-  await withIntercomScope(scopeId, () => client.connect(session, sessionId));
-}
-
-async function stopBroker(broker: ChildProcessWithoutNullStreams): Promise<void> {
-  if (broker.exitCode !== null) return;
-  broker.kill("SIGTERM");
-  await once(broker, "exit");
-}
-
-test("extension bus negotiates, routes, elects an owner, and persists state", { concurrency: false, timeout: 30_000 }, async () => {
-  const agentDir = mkdtempSync(path.join(tmpdir(), "ic-unit-"));
-  const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
-  process.env.SELESAI_CODING_AGENT_DIR = agentDir;
-  const broker = await startBroker(agentDir);
-  const clients: IntercomClient[] = [];
-
-  try {
-    const invalidNamespace = new IntercomClient();
-    await assert.rejects(
-      invalidNamespace.connect({
-        ...registration("invalid", Date.now()),
-        extensions: [{ namespace: "Invalid Namespace", ownerEligible: true }],
-      }),
-    );
-
-    const tooManyExtensions = new IntercomClient();
-    await assert.rejects(
-      tooManyExtensions.connect({
-        ...registration("too-many", Date.now()),
-        extensions: Array.from({ length: 33 }, (_, index) => ({
-          namespace: `test-${index}/v1`,
-          ownerEligible: true,
-        })),
-      }),
-    );
-
-    const owner = new IntercomClient();
-    const peer = new IntercomClient();
-    const legacy = new IntercomClient();
-    const late = new IntercomClient();
-    const peerOnlyA = new IntercomClient();
-    const peerOnlyB = new IntercomClient();
-    clients.push(owner, peer, legacy, late, peerOnlyA, peerOnlyB);
-
-    const ownerMessages: BrokerMessage[] = [];
-    const peerMessages: BrokerMessage[] = [];
-    const legacyMessages: BrokerMessage[] = [];
-    const lateMessages: BrokerMessage[] = [];
-    const peerOnlyBMessages: BrokerMessage[] = [];
-    const ownerErrors: Error[] = [];
-    const legacyErrors: Error[] = [];
-    owner.onBrokerMessage((message) => ownerMessages.push(message));
-    peer.onBrokerMessage((message) => peerMessages.push(message));
-    legacy.onBrokerMessage((message) => legacyMessages.push(message));
-    late.onBrokerMessage((message) => lateMessages.push(message));
-    peerOnlyB.onBrokerMessage((message) => peerOnlyBMessages.push(message));
-    owner.on("error", (error) => ownerErrors.push(error));
-    peer.on("error", () => {});
-    legacy.on("error", (error) => legacyErrors.push(error));
-    late.on("error", () => {});
-    peerOnlyA.on("error", () => {});
-    peerOnlyB.on("error", () => {});
-
-    const now = Date.now();
-    await owner.connect(registration("owner", now - 1000, true), "owner-id");
-
-    const invalidReplacement = new IntercomClient();
-    await assert.rejects(invalidReplacement.connect({
-      ...registration("invalid-replacement", now),
-      extensions: [{ namespace: "Invalid Namespace", ownerEligible: true }],
-    }, "owner-id"));
-    assert.equal((await owner.listSessions()).some((session) => session.id === "owner-id"), true);
-    await invalidReplacement.disconnect().catch(() => undefined);
-
-    await peer.connect(registration("peer", now, false), "peer-id");
-    await legacy.connect(registration("legacy", now), "legacy-id");
-    await late.connect(registration("late", 0), "late-id");
-    await peerOnlyA.connect({
-      ...registration("peer-only-a", now + 2),
-      extensions: [{ namespace: "peer-only/v1", ownerEligible: false }],
-    }, "peer-only-a-id");
-    await peerOnlyB.connect({
-      ...registration("peer-only-b", now + 3),
-      extensions: [{ namespace: "peer-only/v1", ownerEligible: false }],
-    }, "peer-only-b-id");
-
-    assert.equal(owner.supportsFeature("extension-bus-v1"), true);
-    assert.equal(legacy.supportsFeature("extension-bus-v1"), true, "new broker advertises support even to clients without capabilities");
-
-    const ownerEvent = await waitFor(ownerMessages, (message) => message.type === "extension_owner");
-    assert.equal(ownerEvent.type, "extension_owner");
-    assert.equal(ownerEvent.ownerId, "owner-id");
-    assert.ok(ownerEvent.ownerEpoch);
-    const peerOwnerEvent = await waitFor(peerMessages, (message) => message.type === "extension_owner");
-    assert.equal(peerOwnerEvent.type, "extension_owner");
-    assert.equal(peerOwnerEvent.ownerId, "owner-id");
-
-    late.updateExtensionCapabilities([{ namespace: "test/v1", ownerEligible: true }]);
-    const lateOwnerEvent = await waitFor(lateMessages, (message) => message.type === "extension_owner");
-    assert.equal(lateOwnerEvent.type, "extension_owner");
-    assert.equal(lateOwnerEvent.ownerId, "owner-id", "backdated client must not seize namespace ownership");
-    late.updateExtensionCapabilities([{ namespace: "test/v1", ownerEligible: false }]);
-
-    legacy.updateExtensionCapabilities([{ namespace: "other/v1", ownerEligible: false }]);
-    legacy.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      payload: { unauthorized: true },
-    });
-    const unauthorizedDeadline = Date.now() + 3000;
-    while (Date.now() < unauthorizedDeadline && legacyErrors.length === 0) {
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    assert.match(legacyErrors[0]?.message ?? "", /does not have capability for this namespace/);
-    legacy.sendExtensionMessage({
-      type: "extension_state_commit",
-      namespace: "test/v1",
-      ownerEpoch: "unauthorized",
-      expectedRevision: 0,
-      payload: {},
-    });
-    const unauthorizedState = await waitFor(
-      legacyMessages,
-      (message) => message.type === "extension_state_result",
-    );
-    assert.equal(unauthorizedState.type, "extension_state_result");
-    assert.equal(unauthorizedState.committed, false);
-    assert.match(unauthorizedState.reason ?? "", /does not have capability for this namespace/);
-
-    owner.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      payload: "x".repeat(16 * 1024),
-    });
-    const oversizedDeadline = Date.now() + 3000;
-    while (Date.now() < oversizedDeadline && !ownerErrors.some((error) => /16 KiB/.test(error.message))) {
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    assert.equal(ownerErrors.some((error) => /16 KiB/.test(error.message)), true);
-    ownerErrors.length = 0;
-
-    peerOnlyA.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "peer-only/v1",
-      audience: "capable",
-      payload: { kind: "peer-broadcast" },
-    });
-    const peerBroadcast = await waitFor(peerOnlyBMessages, (message) => message.type === "extension_message");
-    assert.equal(peerBroadcast.type, "extension_message");
-    assert.equal(peerBroadcast.ownerId, undefined);
-    assert.equal(peerBroadcast.ownerEpoch, undefined);
-    assert.deepEqual(peerBroadcast.payload, { kind: "peer-broadcast" });
-
-    peer.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "owner",
-      payload: { kind: "owner-target" },
-    });
-    const ownerTarget = await waitFor(
-      ownerMessages,
-      (message) => message.type === "extension_message"
-        && (message.payload as { kind?: string }).kind === "owner-target",
-    );
-    assert.equal(ownerTarget.type, "extension_message");
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    assert.equal(
-      peerMessages.some((message) => message.type === "extension_message"
-        && (message.payload as { kind?: string }).kind === "owner-target"),
-      false,
-    );
-
-    owner.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      ownerOnly: true,
-      ownerEpoch: ownerEvent.ownerEpoch,
-      payload: { kind: "assignment" },
-    });
-    const received = await waitFor(peerMessages, (message) => message.type === "extension_message");
-    assert.equal(received.type, "extension_message");
-    assert.deepEqual(received.payload, { kind: "assignment" });
-    const lateReceived = await waitFor(lateMessages, (message) => message.type === "extension_message");
-    assert.equal(lateReceived.type, "extension_message");
-    assert.deepEqual(lateReceived.payload, { kind: "assignment" });
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    assert.equal(legacyMessages.some((message) => message.type === "extension_message"), false);
-
-    owner.sendExtensionMessage({
-      type: "extension_state_commit",
-      namespace: "test/v1",
-      ownerEpoch: ownerEvent.ownerEpoch!,
-      expectedRevision: 0,
-      payload: { groups: ["alpha"] },
-    });
-    const committed = await waitFor(ownerMessages, (message) => message.type === "extension_state_result");
-    assert.equal(committed.type, "extension_state_result");
-    assert.equal(committed.committed, true);
-    assert.equal(committed.revision, 1);
-    const state = await waitFor(peerMessages, (message) => message.type === "extension_state");
-    assert.equal(state.type, "extension_state");
-    assert.deepEqual(state.payload, { groups: ["alpha"] });
-
-    owner.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      ownerOnly: true,
-      payload: {},
-    });
-    const missingEpochDeadline = Date.now() + 3000;
-    while (Date.now() < missingEpochDeadline && !ownerErrors.some((error) => /ownerEpoch required/.test(error.message))) {
-      await new Promise((resolve) => setTimeout(resolve, 10));
-    }
-    assert.equal(ownerErrors.some((error) => /ownerEpoch required/.test(error.message)), true);
-    ownerErrors.length = 0;
-
-    owner.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      ownerOnly: true,
-      ownerEpoch: "stale",
-      payload: {},
-    });
-    await waitFor(
-      ownerMessages,
-      (message) => message.type === "error" && message.error === "Owner validation failed",
-    ).catch(async () => {
-      const deadline = Date.now() + 3000;
-      while (Date.now() < deadline && ownerErrors.length === 0) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
-      }
-      assert.match(ownerErrors[0]?.message ?? "", /Owner validation failed/);
-      return { type: "error", error: ownerErrors[0]!.message } as BrokerMessage;
-    });
-
-    await owner.disconnect();
-    const noOwner = await waitFor(
-      peerMessages,
-      (message) => message.type === "extension_owner" && message.ownerId === undefined,
-    );
-    assert.equal(noOwner.type, "extension_owner");
-
-    const replacement = new IntercomClient();
-    clients.push(replacement);
-    const replacementMessages: BrokerMessage[] = [];
-    replacement.onBrokerMessage((message) => replacementMessages.push(message));
-    replacement.on("error", () => {});
-    await replacement.connect(registration("replacement", now + 1, true), "owner-id");
-    const replacementOwner = await waitFor(replacementMessages, (message) => message.type === "extension_owner");
-    assert.equal(replacementOwner.type, "extension_owner");
-    assert.notEqual(replacementOwner.ownerEpoch, ownerEvent.ownerEpoch);
-    const restored = await waitFor(replacementMessages, (message) => message.type === "extension_state");
-    assert.equal(restored.type, "extension_state");
-    assert.equal(restored.revision, 1);
-  } finally {
-    await Promise.all(clients.map((client) => client.disconnect().catch(() => undefined)));
-    await stopBroker(broker);
-    if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
-    else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
-    rmSync(agentDir, { recursive: true, force: true });
-  }
-});
-
-test("extension bus owners, publish, and state are scoped", { concurrency: false, timeout: 30_000 }, async () => {
-  const agentDir = mkdtempSync(path.join(tmpdir(), "ic-scope-"));
-  const previousAgentDir = process.env.SELESAI_CODING_AGENT_DIR;
-  process.env.SELESAI_CODING_AGENT_DIR = agentDir;
-  const broker = await startBroker(agentDir);
-  const clients: IntercomClient[] = [];
-
-  try {
-    const alphaOwner = new IntercomClient();
-    const alphaPeer = new IntercomClient();
-    const betaOwner = new IntercomClient();
-    const betaPeer = new IntercomClient();
-    clients.push(alphaOwner, alphaPeer, betaOwner, betaPeer);
-
-    const alphaOwnerMessages: BrokerMessage[] = [];
-    const alphaPeerMessages: BrokerMessage[] = [];
-    const betaOwnerMessages: BrokerMessage[] = [];
-    const betaPeerMessages: BrokerMessage[] = [];
-    alphaOwner.onBrokerMessage((message) => alphaOwnerMessages.push(message));
-    alphaPeer.onBrokerMessage((message) => alphaPeerMessages.push(message));
-    betaOwner.onBrokerMessage((message) => betaOwnerMessages.push(message));
-    betaPeer.onBrokerMessage((message) => betaPeerMessages.push(message));
-    for (const client of clients) client.on("error", () => {});
-
-    const now = Date.now();
-    await connectScoped(alphaOwner, "alpha", registration("alpha-owner", now, true), "scoped-owner-id");
-    await connectScoped(betaOwner, "beta", registration("beta-owner", now, true), "scoped-owner-id");
-    await connectScoped(alphaPeer, "alpha", registration("alpha-peer", now + 1, false), "alpha-peer-id");
-    await connectScoped(betaPeer, "beta", registration("beta-peer", now + 1, false), "beta-peer-id");
-
-    const alphaOwnerEvent = await waitFor(alphaOwnerMessages, (message) => message.type === "extension_owner" && message.ownerId === "scoped-owner-id");
-    const betaOwnerEvent = await waitFor(betaOwnerMessages, (message) => message.type === "extension_owner" && message.ownerId === "scoped-owner-id");
-    assert.equal(alphaOwnerEvent.type, "extension_owner");
-    assert.equal(betaOwnerEvent.type, "extension_owner");
-    assert.notEqual(alphaOwnerEvent.ownerEpoch, betaOwnerEvent.ownerEpoch);
-
-    alphaOwner.sendExtensionMessage({
-      type: "extension_publish",
-      namespace: "test/v1",
-      audience: "capable",
-      payload: { scope: "alpha" },
-    });
-    const alphaPublish = await waitFor(alphaPeerMessages, (message) => message.type === "extension_message"
-      && (message.payload as { scope?: string }).scope === "alpha");
-    assert.equal(alphaPublish.type, "extension_message");
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    assert.equal(betaPeerMessages.some((message) => message.type === "extension_message"
-      && (message.payload as { scope?: string }).scope === "alpha"), false);
-
-    alphaOwner.sendExtensionMessage({
-      type: "extension_state_commit",
-      namespace: "test/v1",
-      ownerEpoch: alphaOwnerEvent.ownerEpoch!,
-      expectedRevision: 0,
-      payload: { scope: "alpha-state" },
-    });
-    const alphaState = await waitFor(alphaPeerMessages, (message) => message.type === "extension_state"
-      && (message.payload as { scope?: string }).scope === "alpha-state");
-    assert.equal(alphaState.type, "extension_state");
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    assert.equal(betaPeerMessages.some((message) => message.type === "extension_state"
-      && (message.payload as { scope?: string }).scope === "alpha-state"), false);
-
-    betaOwner.sendExtensionMessage({
-      type: "extension_state_commit",
-      namespace: "test/v1",
-      ownerEpoch: betaOwnerEvent.ownerEpoch!,
-      expectedRevision: 0,
-      payload: { scope: "beta-state" },
-    });
-    const betaCommitted = await waitFor(betaOwnerMessages, (message) => message.type === "extension_state_result"
-      && message.committed === true);
-    assert.equal(betaCommitted.type, "extension_state_result");
-    assert.equal(betaCommitted.revision, 1);
-  } finally {
-    await Promise.all(clients.map((client) => client.disconnect().catch(() => undefined)));
-    await stopBroker(broker);
-    rmSync(agentDir, { recursive: true, force: true });
-    if (previousAgentDir === undefined) delete process.env.SELESAI_CODING_AGENT_DIR;
-    else process.env.SELESAI_CODING_AGENT_DIR = previousAgentDir;
-  }
-});
-
-test("extension state compare-and-swap rejects stale and invalid revisions", () => {
-  const runtimeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-state-cas-"));
-  try {
-    const manager = new ExtensionStateManager(runtimeDir);
-    assert.deepEqual(manager.commitState("test/v1", 0, { version: 1 }), { committed: true, revision: 1 });
-    assert.deepEqual(manager.commitState("test/v1", 0, { version: 2 }), {
-      committed: false,
-      revision: 1,
-      reason: "Revision mismatch",
-      payload: { version: 1 },
-    });
-    assert.deepEqual(manager.commitState("test/v1", -1, { version: 2 }), {
-      committed: false,
-      revision: 1,
-      reason: "Invalid expected revision",
-    });
-    assert.deepEqual(manager.commitState("test/v1", 1, { version: 2 }), { committed: true, revision: 2 });
-    assert.deepEqual(manager.commitState("test/v1", 2, "x".repeat(64 * 1024)), {
-      committed: false,
-      revision: 2,
-      reason: "Invalid extension state or payload exceeds 64 KiB limit",
-    });
-    const circular: { self?: unknown } = {};
-    circular.self = circular;
-    assert.deepEqual(manager.commitState("test/v1", 2, circular), {
-      committed: false,
-      revision: 2,
-      reason: "Invalid extension state or payload exceeds 64 KiB limit",
-    });
-  } finally {
-    rmSync(runtimeDir, { recursive: true, force: true });
-  }
-});
-
-test("extension state falls back to a valid backup", () => {
-  const runtimeDir = mkdtempSync(path.join(tmpdir(), "pi-intercom-state-"));
-  try {
-    const manager = new ExtensionStateManager(runtimeDir);
-    assert.equal(manager.commitState("test/v1", 0, { version: 1 }).committed, true);
-    assert.equal(manager.commitState("test/v1", 1, { version: 2 }).committed, true);
-
-    const stateDir = path.join(runtimeDir, "extension-state");
-    const files = readdirSync(stateDir);
-    const primary = files.find((file) => file.endsWith(".json"));
-    assert.ok(primary);
-    writeFileSync(path.join(stateDir, primary!), "corrupt", "utf8");
-
-    const recovered = new ExtensionStateManager(runtimeDir).loadState("test/v1");
-    assert.deepEqual(recovered, { revision: 1, payload: { version: 1 } });
-  } finally {
-    rmSync(runtimeDir, { recursive: true, force: true });
-  }
-});