flavor-code 1.4.1 → 1.4.3-beta.2

package/dist/chunk-RBAZLFKB.js

@@ -0,0 +1,1022 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  BrokerRequestSchema,
+  BrokerResponseSchema,
+  CoWorkPlanSchema,
+  CoWorkProposalParticipantsSchema,
+  CoWorkSnapshotSchema,
+  DeliveryReceiptSchema,
+  MAX_ACTIVE_PALS,
+  MAX_CONTROL_FRAME_BYTES,
+  MIN_UUID_PREFIX_LENGTH,
+  PalPresenceSchema,
+  encodeControlFrame,
+  normalizePalIdentity
+} from "./chunk-IQEEFDEE.js";
+
+// src/pals/broker-cli.ts
+import { createHash as createHash2 } from "crypto";
+import { Socket as Socket2 } from "net";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { spawn } from "child_process";
+
+// src/pals/broker.ts
+import { createHash, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
+import { chmod as chmod2, lstat, mkdir as mkdir3, unlink as unlink3 } from "fs/promises";
+import { createServer, Socket } from "net";
+import { dirname as dirname2 } from "path";
+
+// src/pals/auth.ts
+import { randomBytes, randomUUID } from "crypto";
+import { chmod, link, mkdir, open, readFile, unlink } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var PAL_AUTH_TOKEN_BYTES = 32;
+var TOKEN_PATTERN = /^[a-f0-9]{64}$/;
+async function loadOrCreatePalAuthToken(options = {}) {
+  const directory = join(options.home ?? homedir(), ".flavor-code", "pals");
+  const tokenPath = join(directory, "auth-token");
+  await mkdir(directory, { recursive: true, mode: 448 });
+  await chmod(directory, 448);
+  const token = (options.random ?? randomBytes)(PAL_AUTH_TOKEN_BYTES).toString("hex");
+  const temporaryPath = join(directory, `.auth-token-${process.pid}-${randomUUID()}.tmp`);
+  let handle;
+  try {
+    handle = await open(temporaryPath, "wx", 384);
+    try {
+      await handle.writeFile(`${token}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+      handle = void 0;
+    }
+    try {
+      await link(temporaryPath, tokenPath);
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+    }
+  } finally {
+    await handle?.close();
+    await unlink(temporaryPath).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
+  const stored = (await readFile(tokenPath, "utf8")).trim();
+  if (!TOKEN_PATTERN.test(stored)) throw new Error("Pals authentication token store is invalid");
+  await chmod(tokenPath, 384);
+  return stored;
+}
+function validatePalAuthToken(token) {
+  if (!TOKEN_PATTERN.test(token)) throw new Error("Pals authentication token must be 32 bytes encoded as lowercase hex");
+  return token;
+}
+
+// src/pals/lifecycle.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdir as mkdir2, open as open2, readFile as readFile2, rename, stat, unlink as unlink2 } from "fs/promises";
+import { dirname } from "path";
+function defaultProcessAlive(pid) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+function parseMetadata(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (!Number.isSafeInteger(parsed.pid) || parsed.pid <= 0 || !Number.isFinite(parsed.createdAt) || typeof parsed.nonce !== "string" || parsed.nonce.length < 1 || parsed.nonce.length > 128) return void 0;
+    return { pid: parsed.pid, createdAt: parsed.createdAt, nonce: parsed.nonce };
+  } catch {
+    return void 0;
+  }
+}
+async function acquirePalFileLock(options) {
+  if (await options.endpointLive()) return void 0;
+  await mkdir2(dirname(options.path), { recursive: true, mode: 448 });
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const nonce = randomUUID2();
+  const metadata = { pid, createdAt: now(), nonce };
+  let handle;
+  try {
+    handle = await open2(options.path, "wx", 384);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const [contents, info] = await Promise.all([readFile2(options.path, "utf8").catch(() => ""), stat(options.path).catch(() => void 0)]);
+    if (await options.endpointLive()) return void 0;
+    const existing = parseMetadata(contents);
+    if (existing !== void 0 && (options.processAlive ?? defaultProcessAlive)(existing.pid)) return void 0;
+    if (existing === void 0 && (info === void 0 || now() - info.mtimeMs <= (options.corruptGraceMs ?? 5e3))) return void 0;
+    const tombstone = `${options.path}.reclaim-${pid}-${nonce}`;
+    try {
+      await rename(options.path, tombstone);
+    } catch (renameError) {
+      if (["ENOENT", "EEXIST"].includes(renameError.code ?? "")) return void 0;
+      throw renameError;
+    }
+    try {
+      handle = await open2(options.path, "wx", 384);
+    } catch (openError) {
+      if (openError.code !== "EEXIST") throw openError;
+      return void 0;
+    } finally {
+      await unlink2(tombstone).catch((unlinkError) => {
+        if (unlinkError.code !== "ENOENT") throw unlinkError;
+      });
+    }
+  }
+  try {
+    await handle.writeFile(JSON.stringify(metadata), "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  const release = async () => {
+    const current = parseMetadata(await readFile2(options.path, "utf8").catch(() => ""));
+    if (current?.nonce !== nonce) return;
+    await unlink2(options.path).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  };
+  if (await options.endpointLive()) {
+    await release();
+    return void 0;
+  }
+  return { path: options.path, release };
+}
+
+// src/pals/broker.ts
+var BrokerStateError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BrokerStateError";
+  }
+  code;
+};
+var WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
+function canConnect(address) {
+  return new Promise((resolve) => {
+    const socket = new Socket();
+    const finish = (connected) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(connected);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.connect(address);
+  });
+}
+function isWindowsPipeAddress(address, platform = process.platform) {
+  return platform === "win32" && address.toLowerCase().startsWith(WINDOWS_PIPE_PREFIX);
+}
+var PalBrokerServer = class {
+  address;
+  lastActivityAt = Date.now();
+  platform;
+  state;
+  maxFrameBytes;
+  server;
+  connections = /* @__PURE__ */ new Set();
+  palConnections = /* @__PURE__ */ new Map();
+  started = false;
+  ownsAddress = false;
+  closing;
+  authToken;
+  authHome;
+  processAlive;
+  probeAddress;
+  endpointLock;
+  constructor(options) {
+    this.address = options.address;
+    this.platform = options.platform ?? process.platform;
+    this.state = options.state ?? new PalBrokerState();
+    this.maxFrameBytes = options.maxFrameBytes ?? MAX_CONTROL_FRAME_BYTES;
+    if (!Number.isSafeInteger(this.maxFrameBytes) || this.maxFrameBytes <= 0 || this.maxFrameBytes > MAX_CONTROL_FRAME_BYTES) {
+      throw new Error(`maxFrameBytes must be a positive integer not exceeding ${MAX_CONTROL_FRAME_BYTES}`);
+    }
+    this.authToken = options.authToken === void 0 ? void 0 : validatePalAuthToken(options.authToken);
+    this.authHome = options.authHome;
+    this.processAlive = options.processAlive;
+    this.probeAddress = options.probeAddress ?? canConnect;
+    this.server = createServer((socket) => this.accept(socket));
+  }
+  get connectionCount() {
+    return this.connections.size;
+  }
+  async start() {
+    if (this.started) return;
+    this.authToken ??= await loadOrCreatePalAuthToken(this.authHome === void 0 ? {} : { home: this.authHome });
+    try {
+      await this.prepareAddress();
+      await new Promise((resolve, reject) => {
+        const onError = (error) => {
+          this.server.off("listening", onListening);
+          reject(error);
+        };
+        const onListening = () => {
+          this.server.off("error", onError);
+          this.started = true;
+          this.ownsAddress = true;
+          resolve();
+        };
+        this.server.once("error", onError);
+        this.server.once("listening", onListening);
+        this.server.listen(this.address);
+      });
+    } catch (error) {
+      await this.releaseEndpointLock();
+      throw error;
+    }
+  }
+  sweep() {
+    const active = new Set(this.state.list().map(({ id }) => id));
+    for (const [palId, connection] of this.palConnections) {
+      if (active.has(palId)) continue;
+      this.palConnections.delete(palId);
+      connection.socket.destroy();
+    }
+  }
+  close() {
+    if (this.closing !== void 0) return this.closing;
+    this.closing = this.closeOnce();
+    return this.closing;
+  }
+  async closeOnce() {
+    const ownsAddress = this.ownsAddress;
+    for (const connection of this.connections) connection.socket.destroy();
+    if (this.started) {
+      await new Promise((resolve) => this.server.close(() => resolve()));
+      this.started = false;
+    }
+    this.ownsAddress = false;
+    if (ownsAddress && !isWindowsPipeAddress(this.address, this.platform)) await this.unlinkKnownSocket();
+    await this.releaseEndpointLock();
+  }
+  async prepareAddress() {
+    if (isWindowsPipeAddress(this.address, this.platform)) return;
+    const parent = dirname2(this.address);
+    await mkdir3(parent, { recursive: true, mode: 448 });
+    await chmod2(parent, 448);
+    this.endpointLock = await acquirePalFileLock({
+      path: `${this.address}.owner.lock`,
+      endpointLive: () => this.probeAddress(this.address),
+      ...this.processAlive === void 0 ? {} : { processAlive: this.processAlive }
+    });
+    if (this.endpointLock === void 0) throw new Error(`Pals endpoint '${this.address}' is active or owned`);
+    try {
+      const stat2 = await lstat(this.address);
+      if (!stat2.isSocket()) throw new Error(`Refusing to unlink '${this.address}' because it is not a socket`);
+      await unlink3(this.address);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  async releaseEndpointLock() {
+    const lock = this.endpointLock;
+    this.endpointLock = void 0;
+    await lock?.release();
+  }
+  async unlinkKnownSocket() {
+    try {
+      const stat2 = await lstat(this.address);
+      if (stat2.isSocket()) await unlink3(this.address);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+  accept(socket) {
+    const connection = { socket, buffer: Buffer.alloc(0) };
+    this.connections.add(connection);
+    this.lastActivityAt = Date.now();
+    socket.on("data", (chunk) => this.receive(connection, chunk));
+    socket.on("error", () => void 0);
+    socket.once("close", () => this.remove(connection));
+  }
+  remove(connection) {
+    this.connections.delete(connection);
+    if (connection.palId !== void 0 && this.palConnections.get(connection.palId) === connection) {
+      this.palConnections.delete(connection.palId);
+      this.state.disconnect(connection.palId);
+    }
+    this.lastActivityAt = Date.now();
+  }
+  receive(connection, chunk) {
+    this.lastActivityAt = Date.now();
+    connection.buffer = Buffer.concat([connection.buffer, chunk]);
+    while (!connection.socket.destroyed) {
+      const newline = connection.buffer.indexOf(10);
+      if (newline < 0) {
+        if (connection.buffer.byteLength > this.maxFrameBytes) connection.socket.destroy();
+        return;
+      }
+      if (newline > this.maxFrameBytes) {
+        connection.socket.destroy();
+        return;
+      }
+      const frame = connection.buffer.subarray(0, newline).toString("utf8");
+      connection.buffer = connection.buffer.subarray(newline + 1);
+      this.handleFrame(connection, frame);
+    }
+  }
+  handleFrame(connection, frame) {
+    let raw;
+    try {
+      raw = JSON.parse(frame);
+    } catch {
+      connection.socket.destroy();
+      return;
+    }
+    const parsed = BrokerRequestSchema.safeParse(raw);
+    if (!parsed.success) {
+      const requestId = typeof raw === "object" && raw !== null && "requestId" in raw ? raw.requestId : void 0;
+      if (typeof requestId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(requestId)) {
+        connection.socket.destroy();
+        return;
+      }
+      this.send(connection, { version: 1, type: "error", requestId, code: "invalid-request", message: "Invalid request" });
+      return;
+    }
+    void this.dispatch(connection, parsed.data);
+  }
+  dispatch(connection, request) {
+    try {
+      if (request.type === "register") {
+        if (!this.authenticates(request.authToken)) {
+          this.send(connection, { version: 1, type: "error", requestId: request.requestId, code: "authentication-failed", message: "Local authentication failed" });
+          return;
+        }
+        const id = request.presence.id.toLowerCase();
+        if (connection.palId !== void 0 && connection.palId !== id) {
+          throw new BrokerStateError("invalid-transition", "A connection cannot change its pal identity");
+        }
+        const occupied = this.palConnections.get(id);
+        if (occupied !== void 0 && occupied !== connection) {
+          throw new BrokerStateError("alias-conflict", `Pal '${id}' is already connected`);
+        }
+        const presence = this.state.register({ id, alias: request.presence.alias, projectPath: request.presence.projectPath });
+        connection.palId = id;
+        this.palConnections.set(id, connection);
+        this.ok(connection, request.requestId, presence);
+        return;
+      }
+      const actorId = this.requireRegistered(connection);
+      switch (request.type) {
+        case "heartbeat":
+          this.ok(connection, request.requestId, this.state.heartbeat(actorId));
+          return;
+        case "list":
+          this.ok(connection, request.requestId, this.state.list());
+          return;
+        case "disconnect":
+          this.state.disconnect(actorId);
+          if (this.palConnections.get(actorId) === connection) this.palConnections.delete(actorId);
+          this.ok(connection, request.requestId, null);
+          connection.socket.end();
+          return;
+        case "chat": {
+          const result = this.state.routeChat(actorId, request);
+          this.deliver(result.deliveries);
+          this.ok(connection, request.requestId, result.receipt);
+          return;
+        }
+        case "task": {
+          const result = this.state.routeTask(actorId, request);
+          this.deliver(result.deliveries);
+          this.ok(connection, request.requestId, result.receipt);
+          return;
+        }
+        case "cowork-propose": {
+          const result = this.state.proposeCoWork(actorId, request);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-accept": {
+          const result = this.state.acceptCoWork(actorId, request.coWorkId, request.epoch);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-plan": {
+          const result = this.state.submitCoWorkPlan(actorId, request.plan);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-plan-accept": {
+          const result = this.state.acceptCoWorkPlan(actorId, request);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-ready": {
+          const result = this.state.markCoWorkReady(actorId, request);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-complete": {
+          const result = this.state.completeCoWork(actorId, request.detail === void 0 ? {
+            coWorkId: request.coWorkId,
+            epoch: request.epoch,
+            planHash: request.planHash,
+            passed: request.passed
+          } : {
+            coWorkId: request.coWorkId,
+            epoch: request.epoch,
+            planHash: request.planHash,
+            passed: request.passed,
+            detail: request.detail
+          });
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-integration": {
+          const result = this.state.integrateCoWork(actorId, {
+            coWorkId: request.coWorkId,
+            epoch: request.epoch,
+            planHash: request.planHash,
+            passed: request.passed,
+            evidence: request.evidence
+          });
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+        case "cowork-get":
+          this.ok(connection, request.requestId, this.state.getCoWork(request.coWorkId));
+          return;
+        case "cowork-cancel": {
+          const result = this.state.cancelCoWork(actorId, request.coWorkId, request.reason);
+          this.deliverCoWork(result.events, result.snapshot.participants.map(({ palId }) => palId));
+          this.ok(connection, request.requestId, result.snapshot);
+          return;
+        }
+      }
+    } catch (error) {
+      const stateError = error instanceof BrokerStateError ? error : void 0;
+      const code = stateError?.code === "capacity" ? "invalid-transition" : stateError?.code ?? "invalid-request";
+      this.send(connection, {
+        version: 1,
+        type: "error",
+        requestId: request.requestId,
+        code,
+        message: error instanceof Error ? error.message : "Request failed"
+      });
+    }
+  }
+  requireRegistered(connection) {
+    if (connection.palId === void 0) throw new BrokerStateError("invalid-transition", "Register before sending requests");
+    return connection.palId;
+  }
+  authenticates(candidate) {
+    if (candidate === void 0 || this.authToken === void 0) return false;
+    const expected = Buffer.from(this.authToken, "hex");
+    const received = Buffer.from(candidate, "hex");
+    return received.byteLength === expected.byteLength && timingSafeEqual(received, expected);
+  }
+  ok(connection, requestId, data) {
+    this.send(connection, { version: 1, type: "ok", requestId, data });
+  }
+  send(connection, response) {
+    if (connection.socket.destroyed || !connection.socket.writable) return;
+    try {
+      connection.socket.write(encodeControlFrame(BrokerResponseSchema.parse(response)));
+    } catch {
+      connection.socket.destroy();
+    }
+  }
+  deliver(deliveries) {
+    for (const delivery of deliveries) {
+      const recipient = this.palConnections.get(delivery.recipientId);
+      if (recipient !== void 0) this.send(recipient, { version: 1, type: "event", event: delivery.event });
+    }
+  }
+  deliverCoWork(events, participantIds) {
+    for (const event of events) {
+      this.deliver(participantIds.map((recipientId) => ({ recipientId, event })));
+    }
+  }
+};
+var DEFAULT_HEARTBEAT_TIMEOUT_MS = 3e4;
+var DEFAULT_DEDUP_LIMIT = 2048;
+var DEFAULT_MAX_PALS = MAX_ACTIVE_PALS;
+var DEFAULT_MAX_COWORKS = 64;
+function positiveInteger(value, name) {
+  if (!Number.isInteger(value) || value <= 0) throw new Error(`${name} must be a positive integer`);
+  return value;
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, canonicalize(child)])
+    );
+  }
+  return value;
+}
+function canonicalPlanHash(input) {
+  const plan = CoWorkPlanSchema.parse(input);
+  return createHash("sha256").update(JSON.stringify(canonicalize(plan)), "utf8").digest("hex");
+}
+function sameParticipants(left, right) {
+  const normalize = (participants) => participants.map((participant) => `${participant.palId.toLowerCase()}:${participant.required ? "1" : "0"}`).sort();
+  return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right));
+}
+function includesAll(values, required) {
+  const present = new Set(values);
+  return required.every((id) => present.has(id));
+}
+function appendUnique(values, value) {
+  return values.includes(value) ? [...values] : [...values, value];
+}
+var PalBrokerState = class {
+  now;
+  idFactory;
+  heartbeatTimeoutMs;
+  dedupLimit;
+  maxPals;
+  maxCoWorks;
+  pals = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  delivered = /* @__PURE__ */ new Map();
+  coWorks = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.now = options.now ?? Date.now;
+    this.idFactory = options.idFactory ?? randomUUID3;
+    this.heartbeatTimeoutMs = positiveInteger(options.heartbeatTimeoutMs ?? DEFAULT_HEARTBEAT_TIMEOUT_MS, "heartbeatTimeoutMs");
+    this.dedupLimit = positiveInteger(options.dedupLimit ?? DEFAULT_DEDUP_LIMIT, "dedupLimit");
+    this.maxPals = positiveInteger(options.maxPals ?? DEFAULT_MAX_PALS, "maxPals");
+    if (this.maxPals > MAX_ACTIVE_PALS) throw new Error(`maxPals must not exceed ${MAX_ACTIVE_PALS}`);
+    this.maxCoWorks = positiveInteger(options.maxCoWorks ?? DEFAULT_MAX_COWORKS, "maxCoWorks");
+  }
+  register(registration) {
+    this.sweepExpired();
+    const id = registration.id.toLowerCase();
+    const aliasKey = normalizePalIdentity(registration.alias);
+    const claimedBy = this.aliases.get(aliasKey);
+    if (claimedBy !== void 0 && claimedBy !== id) {
+      throw new BrokerStateError("alias-conflict", `Alias '${registration.alias}' is already active`);
+    }
+    if (!this.pals.has(id) && this.pals.size >= this.maxPals) {
+      throw new BrokerStateError("capacity", "Pal capacity reached");
+    }
+    const existing = this.pals.get(id);
+    if (existing !== void 0) this.aliases.delete(existing.presence.alias.toLocaleLowerCase("en-US"));
+    const now = this.now();
+    const presence = PalPresenceSchema.parse({
+      version: 1,
+      id,
+      alias: registration.alias,
+      projectPath: registration.projectPath,
+      connectedAt: existing?.presence.connectedAt ?? new Date(now).toISOString(),
+      lastSeenAt: new Date(now).toISOString()
+    });
+    this.pals.set(id, { presence, lastSeenMs: now });
+    this.aliases.set(aliasKey, id);
+    return clone(presence);
+  }
+  list() {
+    this.sweepExpired();
+    return [...this.pals.values()].map(({ presence }) => clone(presence)).sort((left, right) => left.id.localeCompare(right.id));
+  }
+  resolveTarget(target) {
+    this.sweepExpired();
+    const normalized = normalizePalIdentity(target);
+    const aliasId = this.aliases.get(normalized);
+    if (aliasId !== void 0) return clone(this.pals.get(aliasId).presence);
+    const exact = this.pals.get(normalized);
+    if (exact !== void 0) return clone(exact.presence);
+    if (normalized.length >= MIN_UUID_PREFIX_LENGTH) {
+      const matches = [...this.pals.entries()].filter(([id]) => id.startsWith(normalized));
+      if (matches.length === 1) return clone(matches[0][1].presence);
+      if (matches.length > 1) {
+        throw new BrokerStateError("ambiguous-target", `Target '${target}' matches multiple active pals`);
+      }
+    }
+    throw new BrokerStateError("not-found", `No active pal matches '${target}'`);
+  }
+  heartbeat(palId) {
+    this.sweepExpired();
+    const key = palId.toLowerCase();
+    const record = this.pals.get(key);
+    if (record === void 0) throw new BrokerStateError("not-found", `Pal '${palId}' is not active`);
+    const now = this.now();
+    record.lastSeenMs = now;
+    record.presence = { ...record.presence, lastSeenAt: new Date(now).toISOString() };
+    return clone(record.presence);
+  }
+  disconnect(palId) {
+    const key = palId.toLowerCase();
+    const record = this.pals.get(key);
+    if (record === void 0) return;
+    this.pals.delete(key);
+    this.aliases.delete(record.presence.alias.toLocaleLowerCase("en-US"));
+  }
+  routeChat(senderId, input) {
+    const sender = this.requirePal(senderId);
+    const recipient = this.resolveTarget(input.target);
+    const duplicate = this.duplicateReceipt(input.messageId);
+    if (duplicate !== void 0) return { receipt: duplicate, deliveries: [] };
+    const event = {
+      version: 1,
+      type: "chat-event",
+      messageId: input.messageId,
+      senderId: sender.id,
+      recipientId: recipient.id,
+      message: input.message
+    };
+    const receipt = this.rememberDelivery(input.messageId, [recipient.id]);
+    return { receipt, deliveries: [{ recipientId: recipient.id, event }] };
+  }
+  routeTask(senderId, input) {
+    const sender = this.requirePal(senderId);
+    const recipient = this.resolveTarget(input.target);
+    const duplicate = this.duplicateReceipt(input.messageId);
+    if (duplicate !== void 0) return { receipt: duplicate, deliveries: [] };
+    const event = {
+      version: 1,
+      type: "task-event",
+      messageId: input.messageId,
+      taskId: this.idFactory(),
+      senderId: sender.id,
+      recipientId: recipient.id,
+      status: "accepted",
+      detail: input.goal
+    };
+    const receipt = this.rememberDelivery(input.messageId, [recipient.id]);
+    return { receipt, deliveries: [{ recipientId: recipient.id, event }] };
+  }
+  proposeCoWork(actorId, input) {
+    const actor = this.requirePal(actorId);
+    if (this.coWorks.has(input.coWorkId)) throw new BrokerStateError("invalid-transition", "Co-work already exists");
+    const roster = CoWorkProposalParticipantsSchema.safeParse(input.participants);
+    if (!roster.success) {
+      throw new BrokerStateError("invalid-transition", "Co-work requires at least two distinct participants");
+    }
+    for (const participant of roster.data) this.requirePal(participant.palId);
+    if (!roster.data.some((participant) => participant.palId === actor.id)) {
+      throw new BrokerStateError("invalid-transition", "Proposer must be a participant");
+    }
+    const integrationOwner = roster.data.find(({ required }) => required);
+    if (integrationOwner === void 0) {
+      throw new BrokerStateError("invalid-transition", "Co-work requires at least one required participant");
+    }
+    const acceptedParticipantIds = [actor.id];
+    const requiredParticipantIds = roster.data.filter(({ required }) => required).map(({ palId }) => palId);
+    const snapshot = CoWorkSnapshotSchema.parse({
+      version: 1,
+      coWorkId: input.coWorkId,
+      epoch: 1,
+      phase: includesAll(acceptedParticipantIds, requiredParticipantIds) ? "planning" : "proposed",
+      goal: input.goal,
+      participants: roster.data,
+      integrationOwnerId: integrationOwner.palId,
+      acceptedParticipantIds,
+      planHash: null,
+      plan: null,
+      planAcceptedParticipantIds: [],
+      readyParticipantIds: [],
+      completedParticipantIds: [],
+      completionAssertions: [],
+      integration: null
+    });
+    const transition = this.transition(snapshot, actorId, "PROPOSE");
+    const evictionCandidate = this.coWorkEvictionCandidate();
+    const committed = new Map(this.coWorks);
+    if (evictionCandidate !== void 0) committed.delete(evictionCandidate);
+    committed.set(input.coWorkId, { snapshot });
+    this.coWorks = committed;
+    return transition;
+  }
+  acceptCoWork(actorId, coWorkId, epoch) {
+    const record = this.requireCoWork(coWorkId);
+    this.assertEpoch(record.snapshot, epoch);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase !== "proposed") throw new BrokerStateError("invalid-transition", "Co-work is not awaiting acceptance");
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.acceptedParticipantIds = appendUnique(snapshot.acceptedParticipantIds, actorId);
+      if (includesAll(snapshot.acceptedParticipantIds, this.requiredIds(snapshot))) snapshot.phase = "planning";
+    });
+  }
+  submitCoWorkPlan(actorId, input) {
+    const plan = CoWorkPlanSchema.parse(input);
+    const record = this.requireCoWork(plan.coWorkId);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase !== "planning" && record.snapshot.phase !== "prepared") {
+      throw new BrokerStateError("invalid-transition", "Co-work is not accepting a plan");
+    }
+    const expectedEpoch = record.snapshot.plan === null ? record.snapshot.epoch : record.snapshot.epoch + 1;
+    if (plan.epoch !== expectedEpoch) throw new BrokerStateError("stale-epoch", `Expected plan epoch ${expectedEpoch}`);
+    if (plan.goal !== record.snapshot.goal || !sameParticipants(plan.participants, record.snapshot.participants)) {
+      throw new BrokerStateError("invalid-transition", "Plan must preserve the accepted goal and participant roster");
+    }
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.epoch = plan.epoch;
+      snapshot.phase = "planning";
+      snapshot.plan = clone(plan);
+      snapshot.planHash = canonicalPlanHash(plan);
+      snapshot.planAcceptedParticipantIds = [];
+      snapshot.readyParticipantIds = [];
+      snapshot.completedParticipantIds = [];
+      snapshot.completionAssertions = [];
+      snapshot.integration = null;
+      return "PLAN";
+    });
+  }
+  acceptCoWorkPlan(actorId, token) {
+    const record = this.requireCoWork(token.coWorkId);
+    this.assertPlanToken(record.snapshot, token);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase === "prepared" && record.snapshot.planAcceptedParticipantIds.includes(actorId)) {
+      return this.transition(record.snapshot, actorId);
+    }
+    if (record.snapshot.phase !== "planning" || record.snapshot.plan === null) {
+      throw new BrokerStateError("invalid-transition", "Co-work plan is not awaiting acceptance");
+    }
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.planAcceptedParticipantIds = appendUnique(snapshot.planAcceptedParticipantIds, actorId);
+      if (includesAll(snapshot.planAcceptedParticipantIds, this.requiredIds(snapshot))) snapshot.phase = "prepared";
+    });
+  }
+  markCoWorkReady(actorId, token) {
+    const record = this.requireCoWork(token.coWorkId);
+    this.assertPlanToken(record.snapshot, token);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase === "running" && record.snapshot.readyParticipantIds.includes(actorId)) {
+      return this.transition(record.snapshot, actorId);
+    }
+    if (record.snapshot.phase !== "planning" && record.snapshot.phase !== "prepared") {
+      throw new BrokerStateError("invalid-transition", "Co-work is not accepting readiness");
+    }
+    if (!record.snapshot.planAcceptedParticipantIds.includes(actorId)) {
+      throw new BrokerStateError("invalid-transition", "Participant must accept the current plan before becoming ready");
+    }
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.readyParticipantIds = appendUnique(snapshot.readyParticipantIds, actorId);
+      if (includesAll(snapshot.planAcceptedParticipantIds, this.requiredIds(snapshot)) && includesAll(snapshot.readyParticipantIds, this.requiredIds(snapshot))) {
+        snapshot.phase = "running";
+        return "START";
+      }
+    });
+  }
+  completeCoWork(actorId, input) {
+    const record = this.requireCoWork(input.coWorkId);
+    this.assertPlanToken(record.snapshot, input);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase !== "running") throw new BrokerStateError("invalid-transition", "Co-work is not running");
+    if (!record.snapshot.acceptedParticipantIds.includes(actorId) || !record.snapshot.readyParticipantIds.includes(actorId)) {
+      throw new BrokerStateError("invalid-transition", "Participant must be accepted and ready before completing co-work");
+    }
+    if (record.snapshot.completionAssertions.some(({ participantId }) => participantId === actorId)) {
+      return this.transition(record.snapshot, actorId);
+    }
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.completionAssertions.push(input.detail === void 0 ? { participantId: actorId, passed: input.passed } : { participantId: actorId, passed: input.passed, detail: input.detail });
+      if (!input.passed) {
+        snapshot.phase = "failed";
+        return "FAIL";
+      }
+      snapshot.completedParticipantIds = appendUnique(snapshot.completedParticipantIds, actorId);
+      if (includesAll(snapshot.completedParticipantIds, this.requiredIds(snapshot))) snapshot.phase = "verifying";
+    });
+  }
+  integrateCoWork(actorId, input) {
+    const record = this.requireCoWork(input.coWorkId);
+    this.assertPlanToken(record.snapshot, input);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (actorId !== record.snapshot.integrationOwnerId) {
+      throw new BrokerStateError("invalid-transition", "Only the integration owner can finalize co-work integration");
+    }
+    if (record.snapshot.phase !== "verifying") throw new BrokerStateError("invalid-transition", "Co-work is not ready for integration verification");
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.integration = { passed: input.passed, evidence: input.evidence };
+      snapshot.phase = input.passed ? "completed" : "failed";
+      return input.passed ? "END" : "FAIL";
+    });
+  }
+  getCoWork(coWorkId) {
+    return clone(this.requireCoWork(coWorkId).snapshot);
+  }
+  cancelCoWork(actorId, coWorkId, _reason) {
+    const record = this.requireCoWork(coWorkId);
+    this.requireRequiredParticipant(record.snapshot, actorId);
+    if (record.snapshot.phase === "completed" || record.snapshot.phase === "failed" || record.snapshot.phase === "cancelled") {
+      throw new BrokerStateError("invalid-transition", "Co-work is already terminal");
+    }
+    return this.mutateCoWork(record, actorId, (snapshot) => {
+      snapshot.phase = "cancelled";
+      return "CANCEL";
+    });
+  }
+  sweepExpired() {
+    const cutoff = this.now() - this.heartbeatTimeoutMs;
+    for (const [id, record] of this.pals) {
+      if (record.lastSeenMs < cutoff) this.disconnect(id);
+    }
+  }
+  requirePal(palId) {
+    this.sweepExpired();
+    const record = this.pals.get(palId.toLowerCase());
+    if (record === void 0) throw new BrokerStateError("not-found", `Pal '${palId}' is not active`);
+    return record.presence;
+  }
+  duplicateReceipt(messageId) {
+    const recipientIds = this.delivered.get(messageId);
+    if (recipientIds === void 0) return void 0;
+    return DeliveryReceiptSchema.parse({
+      version: 1,
+      type: "delivery-receipt",
+      messageId,
+      status: "duplicate",
+      recipientIds
+    });
+  }
+  rememberDelivery(messageId, recipientIds) {
+    this.delivered.set(messageId, [...recipientIds]);
+    while (this.delivered.size > this.dedupLimit) {
+      const oldest = this.delivered.keys().next().value;
+      if (oldest === void 0) break;
+      this.delivered.delete(oldest);
+    }
+    return DeliveryReceiptSchema.parse({
+      version: 1,
+      type: "delivery-receipt",
+      messageId,
+      status: "delivered",
+      recipientIds
+    });
+  }
+  requireCoWork(coWorkId) {
+    const record = this.coWorks.get(coWorkId);
+    if (record === void 0) throw new BrokerStateError("not-found", `Co-work '${coWorkId}' does not exist`);
+    return record;
+  }
+  requireParticipant(snapshot, palId) {
+    if (!snapshot.participants.some((participant) => participant.palId === palId)) {
+      throw new BrokerStateError("invalid-transition", `Pal '${palId}' is not a co-work participant`);
+    }
+  }
+  requireRequiredParticipant(snapshot, palId) {
+    this.requireParticipant(snapshot, palId);
+    if (!snapshot.participants.some((participant) => participant.palId === palId && participant.required)) {
+      throw new BrokerStateError("invalid-transition", `Pal '${palId}' is an observer and cannot change co-work state`);
+    }
+  }
+  requiredIds(snapshot) {
+    return snapshot.participants.filter(({ required }) => required).map(({ palId }) => palId);
+  }
+  assertEpoch(snapshot, epoch) {
+    if (epoch !== snapshot.epoch) throw new BrokerStateError("stale-epoch", `Expected epoch ${snapshot.epoch}`);
+  }
+  assertPlanToken(snapshot, token) {
+    this.assertEpoch(snapshot, token.epoch);
+    if (snapshot.planHash === null || token.planHash !== snapshot.planHash) {
+      throw new BrokerStateError("invalid-transition", "Plan hash does not match the canonical active plan");
+    }
+  }
+  transition(snapshot, actorId, action) {
+    const result = CoWorkSnapshotSchema.parse(clone(snapshot));
+    if (action === void 0) return { snapshot: result, events: [] };
+    return {
+      snapshot: result,
+      events: [{
+        version: 1,
+        type: "cowork-event",
+        action,
+        actorId,
+        coWorkId: result.coWorkId,
+        epoch: result.epoch,
+        planHash: result.planHash,
+        snapshot: clone(result)
+      }]
+    };
+  }
+  mutateCoWork(record, actorId, mutate) {
+    const candidate = clone(record.snapshot);
+    const action = mutate(candidate);
+    const committed = CoWorkSnapshotSchema.parse(candidate);
+    record.snapshot = committed;
+    return this.transition(committed, actorId, action);
+  }
+  coWorkEvictionCandidate() {
+    if (this.coWorks.size < this.maxCoWorks) return void 0;
+    const terminal = [...this.coWorks.entries()].find(([, { snapshot }]) => snapshot.phase === "completed" || snapshot.phase === "failed" || snapshot.phase === "cancelled");
+    if (terminal === void 0) throw new BrokerStateError("capacity", "Active co-work capacity reached");
+    return terminal[0];
+  }
+};
+
+// src/pals/broker-cli.ts
+var startupAttempts = /* @__PURE__ */ new Map();
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function canConnect2(address) {
+  return new Promise((resolve) => {
+    const socket = new Socket2();
+    const finish = (connected) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(connected);
+    };
+    socket.once("connect", () => finish(true));
+    socket.once("error", () => finish(false));
+    socket.connect(address);
+  });
+}
+function startupLockPath(address) {
+  const digest = createHash2("sha256").update(address, "utf8").digest("hex").slice(0, 24);
+  return join2(tmpdir(), `flavor-code-pals-${digest}.startup.lock`);
+}
+async function spawnProductionBroker(address) {
+  const entry = process.argv[1];
+  if (entry === void 0) throw new Error("Cannot auto-start pals broker without a CLI entry point");
+  return spawnPalBrokerProcess({ address, executable: process.execPath, args: [entry, "--pals-broker", address] });
+}
+async function spawnPalBrokerProcess(options) {
+  if (options.executable.trim() === "" || options.args.length === 0) throw new Error("Pals broker process requires an executable and entry arguments");
+  const address = options.address;
+  const lockPath = startupLockPath(address);
+  const lock = await acquirePalFileLock({ path: lockPath, endpointLive: () => canConnect2(address) });
+  if (lock === void 0) return;
+  try {
+    const child = spawn(options.executable, [...options.args], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+      ...options.environment === void 0 ? {} : { env: options.environment }
+    });
+    child.unref();
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline && !await canConnect2(address)) await delay(25);
+    if (!await canConnect2(address)) throw new Error(`Pals broker process did not become ready at '${address}'`);
+  } finally {
+    await lock.release();
+  }
+}
+async function runPalBroker(options) {
+  const server = new PalBrokerServer(options);
+  await server.start();
+  const sweepIntervalMs = options.sweepIntervalMs ?? 5e3;
+  const idleShutdownMs = options.idleShutdownMs ?? 3e4;
+  let resolveClosed;
+  const closed = new Promise((resolve) => {
+    resolveClosed = resolve;
+  });
+  let closing;
+  const timer = setInterval(() => {
+    server.sweep();
+    if (server.connectionCount === 0 && Date.now() - server.lastActivityAt >= idleShutdownMs) void close();
+  }, sweepIntervalMs);
+  timer.unref?.();
+  const close = () => {
+    if (closing !== void 0) return closing;
+    closing = (async () => {
+      clearInterval(timer);
+      await server.close();
+      resolveClosed();
+    })();
+    return closing;
+  };
+  return { server, closed, close };
+}
+function ensurePalBrokerRunning(options) {
+  const existing = startupAttempts.get(options.address);
+  if (existing !== void 0) return existing;
+  const attempt = ensureOnce(options).finally(() => startupAttempts.delete(options.address));
+  startupAttempts.set(options.address, attempt);
+  return attempt;
+}
+async function ensureOnce(options) {
+  if (await canConnect2(options.address)) return;
+  await (options.startBroker ?? (() => spawnProductionBroker(options.address)))();
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const retryDelayMs = options.retryDelayMs ?? 25;
+  const deadline = Date.now() + timeoutMs;
+  do {
+    if (await canConnect2(options.address)) return;
+    await delay(retryDelayMs);
+  } while (Date.now() < deadline);
+  throw new Error(`Timed out waiting for pals broker at '${options.address}'`);
+}
+
+export {
+  loadOrCreatePalAuthToken,
+  validatePalAuthToken,
+  spawnPalBrokerProcess,
+  runPalBroker,
+  ensurePalBrokerRunning
+};