@cydm/pie 2.7.13 → 2.7.14

package/dist/builtin/extensions/pie-ipc/index.js

@@ -0,0 +1,1671 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  Type
+} from "../../../chunks/chunk-XXGYUYXI.js";
+import "../../../chunks/chunk-LZQXQOPJ.js";
+
+// builtin/extensions/pie-ipc/index.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// builtin/extensions/pie-ipc/pure.ts
+import { randomBytes } from "node:crypto";
+var IPC_PROTOCOL_VERSION = 1;
+var INSTANCE_ID_PATTERN = /^pie-[a-z0-9]{12}$/;
+var MAX_STATUS_FILE_BYTES = 128 * 1024;
+var MAX_DISPLAY_NAME_CHARS = 64;
+var MAX_STATUS_TEXT_FIELD_CHARS = 4096;
+var MAX_BODY_CHARS = 8e3;
+var MAX_STATUS_BODY_CHARS = 2e3;
+var STATUS_FILE_STALE_MS = 12e4;
+var HEARTBEAT_INTERVAL_MS = 2e4;
+var DEFAULT_SEND_WAIT_MS = 12e4;
+var MAX_SEEN_ENVELOPE_IDS = 1e3;
+var MAX_INBOX_MESSAGES = 100;
+var MAX_INFLIGHT_SENDS = 8;
+var INSTANCE_ID_ALPHABET = "abcdefghijklmnopqrstuvwxyz0123456789";
+function generateInstanceId(randomSource = defaultRandomBytes) {
+  const bytes = randomSource(12);
+  let id = "";
+  for (const byte of bytes) {
+    id += INSTANCE_ID_ALPHABET[byte % INSTANCE_ID_ALPHABET.length];
+  }
+  return `pie-${id}`;
+}
+function defaultRandomBytes(count) {
+  return randomBytes(count);
+}
+function isValidInstanceId(id) {
+  return INSTANCE_ID_PATTERN.test(id);
+}
+function peerLabel(instanceId, displayName) {
+  const name = displayName?.trim();
+  if (name) return name;
+  return instanceId.length > 12 ? instanceId.slice(0, 12) : instanceId;
+}
+var ENVELOPE_KINDS = /* @__PURE__ */ new Set([
+  "hello",
+  "bye",
+  "ping",
+  "message",
+  "ack",
+  "result",
+  "state.get",
+  "state"
+]);
+var LIFECYCLE_STATES = /* @__PURE__ */ new Set(["working", "idle", "blocked"]);
+function parseEnvelope(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (typeof record.v !== "number" || record.v !== IPC_PROTOCOL_VERSION) return null;
+  if (typeof record.id !== "string" || !/^[a-zA-Z0-9:-]{1,128}$/.test(record.id)) return null;
+  if (typeof record.from !== "string" || !isValidInstanceId(record.from)) return null;
+  if (typeof record.to !== "string" || !isValidInstanceId(record.to)) return null;
+  if (record.text !== void 0 && (typeof record.text !== "string" || record.text.length > MAX_BODY_CHARS + 100)) return null;
+  if (record.sessionId !== void 0 && (typeof record.sessionId !== "string" || record.sessionId.length > 256)) return null;
+  if (record.replyTo !== void 0 && (typeof record.replyTo !== "string" || !/^[a-zA-Z0-9:-]{1,128}$/.test(record.replyTo))) return null;
+  if (record.waitMs !== void 0 && (typeof record.waitMs !== "number" || !Number.isFinite(record.waitMs) || record.waitMs < 0 || record.waitMs > 6e5)) return null;
+  if (typeof record.kind !== "string" || !ENVELOPE_KINDS.has(record.kind)) return null;
+  if (typeof record.createdAt !== "number" || !Number.isSafeInteger(record.createdAt) || record.createdAt < 0) return null;
+  const envelope = {
+    v: record.v,
+    id: record.id,
+    from: record.from,
+    to: record.to,
+    kind: record.kind,
+    createdAt: record.createdAt
+  };
+  if (typeof record.auth === "string" && /^[a-f0-9]{64}$/.test(record.auth)) envelope.auth = record.auth;
+  if (typeof record.sessionId === "string") envelope.sessionId = record.sessionId;
+  if (typeof record.text === "string") envelope.text = record.text;
+  if (typeof record.replyTo === "string") envelope.replyTo = record.replyTo;
+  if (typeof record.waitMs === "number" && Number.isFinite(record.waitMs)) envelope.waitMs = record.waitMs;
+  return envelope;
+}
+var FrameTooLargeError = class extends Error {
+  constructor() {
+    super("pie-ipc frame exceeds byte cap");
+    this.name = "FrameTooLargeError";
+  }
+};
+var FrameDecoder = class {
+  buffer = "";
+  get partial() {
+    return this.buffer.length > 0;
+  }
+  push(chunk) {
+    this.buffer += chunk;
+    if (this.buffer.split("\n").some((line) => Buffer.byteLength(line, "utf8") > 64 * 1024)) {
+      this.buffer = "";
+      throw new FrameTooLargeError();
+    }
+    const envelopes = [];
+    let newline = this.buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line) {
+        const envelope = parseEnvelope(line);
+        if (envelope) envelopes.push(envelope);
+      }
+      newline = this.buffer.indexOf("\n");
+    }
+    return envelopes;
+  }
+};
+var WRAP_PREFIX = "[pie-ipc]";
+function wrapInboundText(fromLabel, text, at = Date.now(), messageId) {
+  const stamp = new Date(at).toISOString().slice(11, 19);
+  const marker = messageId ? ` #${clipMarker(messageId)} ` : " ";
+  return `${WRAP_PREFIX} ${stamp}${marker}peer "${clipLabel(fromLabel)}" says:
+${clipBody(text, MAX_BODY_CHARS)}`;
+}
+function isWrappedInboundText(text) {
+  return text.startsWith(`${WRAP_PREFIX} `);
+}
+function wrappedMessageMarker(text) {
+  if (!isWrappedInboundText(text)) return null;
+  const firstLine = text.split("\n", 1)[0];
+  const match = / #(\S+) peer "/.exec(firstLine);
+  return match ? match[1] : null;
+}
+function clipMarker(id) {
+  const clipped = id;
+  return clipped || "noid";
+}
+function clipLabel(label) {
+  const collapsed = label.replace(/\s+/g, " ").trim().slice(0, 60);
+  return collapsed || "unknown";
+}
+function clipBody(text, maxChars = MAX_BODY_CHARS) {
+  if (text.length <= maxChars) return text;
+  return `${text.slice(0, maxChars)}\u2026[truncated ${text.length - maxChars} chars]`;
+}
+var BoundedIdSet = class {
+  constructor(max = MAX_SEEN_ENVELOPE_IDS) {
+    this.max = max;
+  }
+  max;
+  seen = /* @__PURE__ */ new Map();
+  /** Returns true when the id is new (and records it). */
+  add(id, now = Date.now()) {
+    if (this.seen.has(id)) return false;
+    this.seen.set(id, now);
+    if (this.seen.size > this.max) {
+      const drop = Math.max(1, Math.floor(this.max / 4));
+      let dropped = 0;
+      for (const key of this.seen.keys()) {
+        if (dropped >= drop) break;
+        this.seen.delete(key);
+        dropped += 1;
+      }
+    }
+    return true;
+  }
+  has(id) {
+    return this.seen.has(id);
+  }
+  get size() {
+    return this.seen.size;
+  }
+};
+var signalAliveCheck = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+function peerHealth(file, now = Date.now(), aliveCheck = signalAliveCheck) {
+  if (Number.isInteger(file.pid) && file.pid > 0 && !aliveCheck(file.pid)) return "dead";
+  if (now - file.updatedAt > STATUS_FILE_STALE_MS) return "stale";
+  return "alive";
+}
+function parseStatusFile(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (record.schema !== 1) return null;
+  if (typeof record.instanceId !== "string" || !isValidInstanceId(record.instanceId)) return null;
+  if (typeof record.pid !== "number" || !Number.isInteger(record.pid) || record.pid <= 0 || record.pid > 99999999) return null;
+  if (typeof record.protocol !== "number" || record.protocol !== IPC_PROTOCOL_VERSION) return null;
+  if (typeof record.displayName !== "string" || !record.displayName || record.displayName.length > MAX_DISPLAY_NAME_CHARS) return null;
+  if (hasControlChars(record.displayName)) return null;
+  if (record.sessionId !== null && (typeof record.sessionId !== "string" || record.sessionId.length > 256 || hasControlChars(record.sessionId))) return null;
+  if (typeof record.cwd !== "string" || record.cwd.length > MAX_STATUS_TEXT_FIELD_CHARS || hasControlChars(record.cwd)) return null;
+  if (typeof record.startedAt !== "number" || !Number.isSafeInteger(record.startedAt) || record.startedAt < 0) return null;
+  if (typeof record.updatedAt !== "number" || !Number.isSafeInteger(record.updatedAt) || record.updatedAt < 0) return null;
+  if (typeof record.state !== "string" || !LIFECYCLE_STATES.has(record.state)) return null;
+  const file = {
+    schema: 1,
+    instanceId: record.instanceId,
+    pid: record.pid,
+    protocol: record.protocol,
+    displayName: record.displayName,
+    sessionId: record.sessionId,
+    cwd: record.cwd,
+    startedAt: record.startedAt,
+    updatedAt: record.updatedAt,
+    state: record.state
+  };
+  if (Array.isArray(record.allowPeers) && record.allowPeers.length <= 1e3 && record.allowPeers.every((id) => typeof id === "string" && (id === "*" || isValidInstanceId(id)))) file.allowPeers = record.allowPeers;
+  if (typeof record.secret === "string" && /^[a-f0-9]{64}$/.test(record.secret)) file.secret = record.secret;
+  if (typeof record.sessionName === "string" && !hasControlChars(record.sessionName) && record.sessionName.length <= MAX_DISPLAY_NAME_CHARS) file.sessionName = record.sessionName;
+  if (typeof record.currentTool === "string" && !hasControlChars(record.currentTool) && record.currentTool.length <= 200) file.currentTool = record.currentTool;
+  if (typeof record.blockedSince === "number" && Number.isSafeInteger(record.blockedSince) && record.blockedSince >= 0) file.blockedSince = record.blockedSince;
+  if (typeof record.turnStartedAt === "number" && Number.isSafeInteger(record.turnStartedAt) && record.turnStartedAt >= 0) file.turnStartedAt = record.turnStartedAt;
+  if (typeof record.undeliveredInjections === "number" && Number.isFinite(record.undeliveredInjections)) file.undeliveredInjections = Math.min(100, Math.max(0, Math.floor(record.undeliveredInjections)));
+  if (typeof record.lastBodyText === "string" && record.lastBodyText.length <= MAX_STATUS_TEXT_FIELD_CHARS && !/[\u0000-\u0008\u000b-\u001f\u007f]/.test(record.lastBodyText)) file.lastBodyText = record.lastBodyText;
+  if (typeof record.lastBodyAt === "number" && Number.isSafeInteger(record.lastBodyAt) && record.lastBodyAt >= 0) file.lastBodyAt = record.lastBodyAt;
+  if (typeof record.port === "number" && Number.isInteger(record.port) && record.port > 0 && record.port <= 65535) file.port = record.port;
+  return file;
+}
+function hasControlChars(text) {
+  return /[\u0000-\u001f\u007f]/.test(text);
+}
+var BLOCKING_TOOL_NAMES = /* @__PURE__ */ new Set(["ask_user_multi"]);
+function isBlockingTool(toolName) {
+  return BLOCKING_TOOL_NAMES.has(toolName);
+}
+function foldLifecycleEvent(current, event, now = Date.now()) {
+  switch (event.type) {
+    case "turn:start":
+    case "agent:start": {
+      const next = { state: "working", turnStartedAt: now };
+      if (current.blockedSince !== void 0) next.blockedSince = current.blockedSince;
+      return next;
+    }
+    case "tool:execution:start": {
+      if (current.state === "idle") return { ...current, state: "working", turnStartedAt: current.turnStartedAt ?? now };
+      if (event.toolName && isBlockingTool(event.toolName) && current.state !== "blocked") {
+        return { ...current, state: "blocked", blockedSince: now, currentTool: event.toolName };
+      }
+      return { ...current, currentTool: event.toolName };
+    }
+    case "tool:execution:end": {
+      if (current.state === "blocked" && (!event.toolName || isBlockingTool(event.toolName))) {
+        return { ...current, state: "working", blockedSince: void 0, currentTool: void 0 };
+      }
+      return current;
+    }
+    case "turn:completed":
+    case "turn:failed":
+    case "turn:cancelled":
+    case "agent:end": {
+      if (current.state === "idle") return current;
+      return { state: "idle" };
+    }
+    default:
+      return current;
+  }
+}
+function resolveIpcConfig(configLayers) {
+  const problems = [];
+  const merged = {};
+  for (const layer of configLayers) {
+    if (layer.content === void 0) continue;
+    try {
+      const parsed = JSON.parse(layer.content);
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        problems.push(`${layer.file}: root is not an object`);
+        continue;
+      }
+      Object.assign(merged, parsed);
+    } catch (error) {
+      problems.push(`${layer.file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (merged.enabled !== true) return { config: null, problems };
+  const config = { enabled: true };
+  if (typeof merged.displayName === "string" && merged.displayName.trim()) {
+    config.displayName = merged.displayName.replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 60);
+  }
+  if (Array.isArray(merged.allowPeers)) {
+    const ids = merged.allowPeers.filter((id) => typeof id === "string" && (id === "*" || isValidInstanceId(id))).slice(0, 1e3);
+    if (ids.length) config.allowPeers = ids;
+  }
+  if (merged.autoInject !== void 0) config.autoInject = merged.autoInject === true;
+  if (typeof merged.maxBodyChars === "number" && Number.isFinite(merged.maxBodyChars)) {
+    const bounded = Math.min(Math.max(Math.floor(merged.maxBodyChars), 100), MAX_BODY_CHARS);
+    if (bounded !== merged.maxBodyChars) {
+      problems.push(`pie-ipc: maxBodyChars clamped to ${bounded}`);
+    }
+    config.maxBodyChars = bounded;
+  }
+  return { config, problems };
+}
+function assistantBodyText(message) {
+  if (message?.role !== "assistant" || !Array.isArray(message.content)) return "";
+  let text = "";
+  let hasToolCalls = false;
+  for (const block of message.content) {
+    if (typeof block !== "object" || block === null) continue;
+    const record = block;
+    if (record.type === "text" && typeof record.text === "string") text += record.text;
+    else if (record.type === "toolCall") hasToolCalls = true;
+  }
+  if (hasToolCalls) return "";
+  return text.trim();
+}
+
+// builtin/extensions/pie-ipc/discovery.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function ipcDiscoveryDir(configDir) {
+  return path.join(configDir, "run", "ipc");
+}
+function statusFilePath(discoveryDir, instanceId) {
+  if (!isValidInstanceId(instanceId)) throw new Error("Invalid instance id");
+  return path.join(discoveryDir, `${instanceId}.json`);
+}
+function ensurePrivateDir(discoveryDir) {
+  if (process.platform === "win32") throw new Error("pie-ipc requires POSIX private-file permissions; Windows is not supported yet");
+  fs.mkdirSync(discoveryDir, { recursive: true, mode: 448 });
+  const stat = fs.lstatSync(discoveryDir);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()) throw new Error("Unsafe IPC directory");
+  fs.chmodSync(discoveryDir, 448);
+}
+function writeStatusFile(discoveryDir, file, log) {
+  let temp;
+  try {
+    ensurePrivateDir(discoveryDir);
+    const target = statusFilePath(discoveryDir, file.instanceId);
+    const raw = JSON.stringify(file);
+    if (Buffer.byteLength(raw) > MAX_STATUS_FILE_BYTES || !parseStatusFile(raw)) throw new Error("Invalid status payload");
+    temp = path.join(discoveryDir, `.${randomBytes2(16).toString("hex")}.tmp`);
+    const handle = fs.openSync(temp, "wx", 384);
+    try {
+      fs.writeFileSync(handle, raw);
+    } finally {
+      fs.closeSync(handle);
+    }
+    fs.renameSync(temp, target);
+    return true;
+  } catch (error) {
+    try {
+      log?.(`pie-ipc: status write failed: ${error instanceof Error ? error.message : String(error)}`);
+    } catch {
+    }
+    return false;
+  } finally {
+    if (temp) {
+      try {
+        fs.unlinkSync(temp);
+      } catch {
+      }
+    }
+  }
+}
+function readStatusFile(discoveryDir, instanceId) {
+  if (!isValidInstanceId(instanceId)) return null;
+  const target = statusFilePath(discoveryDir, instanceId);
+  let fd;
+  try {
+    if (process.platform === "win32") return null;
+    const dir = fs.lstatSync(discoveryDir);
+    if (!dir.isDirectory() || dir.isSymbolicLink() || process.getuid && (dir.uid !== process.getuid() || (dir.mode & 63) !== 0)) return null;
+    fd = fs.openSync(target, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0) | (fs.constants.O_NONBLOCK ?? 0));
+    const stats = fs.fstatSync(fd);
+    if (!stats.isFile() || stats.size > MAX_STATUS_FILE_BYTES || process.getuid && (stats.uid !== process.getuid() || (stats.mode & 63) !== 0)) return null;
+    const bytes = Buffer.alloc(MAX_STATUS_FILE_BYTES + 1);
+    const count = fs.readSync(fd, bytes, 0, bytes.length, 0);
+    if (count > MAX_STATUS_FILE_BYTES) return null;
+    const file = parseStatusFile(bytes.subarray(0, count).toString("utf8"));
+    return file?.instanceId === instanceId ? file : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== void 0) fs.closeSync(fd);
+  }
+}
+function removeStatusFile(discoveryDir, instanceId) {
+  try {
+    fs.rmSync(statusFilePath(discoveryDir, instanceId), { force: true });
+  } catch {
+  }
+}
+function listPeers(discoveryDir, options = {}) {
+  const now = options.now ?? Date.now();
+  const aliveCheck = options.aliveCheck ?? ((pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  });
+  const entries = [];
+  let directory;
+  try {
+    directory = fs.opendirSync(discoveryDir);
+    for (let n = 0; n < 1024; n++) {
+      const entry = directory.readSync();
+      if (!entry) break;
+      entries.push(entry);
+    }
+  } catch {
+    return [];
+  } finally {
+    try {
+      directory?.closeSync();
+    } catch {
+    }
+  }
+  const listings = [];
+  for (const entry of entries.slice(0, 1024)) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const instanceId = entry.name.slice(0, -".json".length);
+    if (instanceId === options.selfId) continue;
+    if (!isValidInstanceId(instanceId)) continue;
+    const file = readStatusFile(discoveryDir, instanceId);
+    if (!file || file.instanceId !== instanceId) continue;
+    const health = peerHealth(file, now, aliveCheck);
+    if (health === "dead" && options.pruneDead !== false) {
+      try {
+        fs.rmSync(path.join(discoveryDir, entry.name), { force: true });
+      } catch {
+      }
+      continue;
+    }
+    listings.push({ file, health });
+  }
+  listings.sort((a, b) => b.file.updatedAt - a.file.updatedAt);
+  return listings;
+}
+function startHeartbeat(discoveryDir, file, intervalMs, write = (next) => writeStatusFile(discoveryDir, next), log) {
+  let failures = 0;
+  const timer = setInterval(() => {
+    try {
+      if (!write({ ...file(), updatedAt: Date.now() })) {
+        failures += 1;
+        if (failures === 3) log?.("pie-ipc: heartbeat writes keep failing; discovery may be degraded");
+      } else {
+        failures = 0;
+      }
+    } catch (error) {
+      try {
+        log?.(`pie-ipc: heartbeat error: ${error instanceof Error ? error.message : String(error)}`);
+      } catch {
+      }
+    }
+  }, intervalMs);
+  timer.unref?.();
+  return () => clearInterval(timer);
+}
+function watchDiscoveryDir(discoveryDir, onChange) {
+  let watcher = null;
+  let closed = false;
+  let lastEventAt = 0;
+  const attach = () => {
+    if (closed) return;
+    try {
+      watcher = fs.watch(discoveryDir, (_event, filename) => {
+        const name = String(filename ?? "");
+        if (!name.endsWith(".json")) return;
+        const now = Date.now();
+        if (now - lastEventAt < 50) return;
+        lastEventAt = now;
+        try {
+          onChange(name.slice(0, -".json".length));
+        } catch {
+        }
+      });
+    } catch {
+      watcher = null;
+    }
+    watcher?.on("error", () => {
+      watcher?.close();
+      watcher = null;
+    });
+    watcher?.unref?.();
+  };
+  attach();
+  const retry = setInterval(() => {
+    if (closed || watcher) return;
+    attach();
+  }, 5e3);
+  retry.unref?.();
+  return () => {
+    closed = true;
+    clearInterval(retry);
+    watcher?.close();
+    watcher = null;
+  };
+}
+function buildStatusFile(input) {
+  return {
+    schema: 1,
+    instanceId: input.instanceId,
+    pid: process.pid,
+    protocol: IPC_PROTOCOL_VERSION,
+    displayName: input.displayName,
+    sessionId: input.sessionId,
+    sessionName: input.sessionName,
+    cwd: input.cwd,
+    startedAt: Date.now(),
+    updatedAt: Date.now(),
+    state: "idle",
+    undeliveredInjections: 0,
+    port: input.port
+  };
+}
+
+// builtin/extensions/pie-ipc/transport.ts
+import * as net from "node:net";
+import { createHmac, randomBytes as randomBytes3, randomUUID, timingSafeEqual } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+function signEnvelope(e, secret) {
+  const payload = [e.v, e.id, e.from, e.to, e.kind, e.createdAt, e.sessionId ?? null, e.text ?? null, e.replyTo ?? null, e.waitMs ?? null];
+  return { ...e, auth: createHmac("sha256", secret).update(JSON.stringify(payload)).digest("hex") };
+}
+function verified(e, secret) {
+  if (!e.auth || !/^[a-f0-9]{64}$/.test(e.auth)) return false;
+  return timingSafeEqual(Buffer.from(e.auth, "hex"), Buffer.from(signEnvelope(e, secret).auth, "hex"));
+}
+var IpcTransport = class {
+  constructor(host) {
+    this.host = host;
+    this.instanceId = host.instanceId;
+    this.secret = host.secret ?? randomBytes3(32).toString("hex");
+    this.server = net.createServer((socket) => this.accept(socket));
+    this.server.on("error", () => {
+    });
+    this.server.unref();
+  }
+  host;
+  instanceId;
+  secret;
+  server;
+  sockets = /* @__PURE__ */ new Set();
+  cancels = /* @__PURE__ */ new Set();
+  seen = new BoundedIdSet();
+  closed = false;
+  inflight = 0;
+  inbound = 0;
+  rateWindow = Date.now();
+  rateCount = 0;
+  port = null;
+  get listenPort() {
+    return this.port;
+  }
+  listen() {
+    if (this.closed) return Promise.reject(new Error("closed"));
+    return new Promise((resolve, reject) => {
+      const cancel = () => {
+        this.cancels.delete(cancel);
+        reject(new Error("closed"));
+      };
+      this.cancels.add(cancel);
+      const error = (e) => {
+        this.cancels.delete(cancel);
+        reject(e);
+      };
+      this.server.once("error", error);
+      this.server.listen(0, "127.0.0.1", () => {
+        this.server.off("error", error);
+        this.cancels.delete(cancel);
+        if (this.closed) {
+          this.server.close();
+          reject(new Error("closed"));
+          return;
+        }
+        const address = this.server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("closed"));
+          return;
+        }
+        this.port = address.port;
+        resolve(address.port);
+      });
+    });
+  }
+  write(socket, envelope, secret) {
+    if (socket.destroyed) return false;
+    const data = JSON.stringify(signEnvelope(envelope, secret)) + "\n";
+    if (socket.writableLength + Buffer.byteLength(data) > 512 * 1024) {
+      socket.destroy();
+      return false;
+    }
+    try {
+      socket.write(data);
+      return true;
+    } catch {
+      socket.destroy();
+      return false;
+    }
+  }
+  read(socket, receive, idleMs) {
+    const decoder = new FrameDecoder();
+    const utf8 = new StringDecoder("utf8");
+    let frameTimer;
+    let frames = 0;
+    socket.setTimeout(idleMs, () => socket.destroy());
+    socket.on("error", () => socket.destroy());
+    socket.on("close", () => {
+      if (frameTimer) clearTimeout(frameTimer);
+      this.sockets.delete(socket);
+    });
+    socket.on("data", (chunk) => {
+      try {
+        frames += chunk.reduce((n, b) => n + (b === 10 ? 1 : 0), 0);
+        if (frames > 128) {
+          socket.destroy();
+          return;
+        }
+        const envelopes = decoder.push(utf8.write(chunk));
+        const partial = decoder.partial || chunk.at(-1) !== 10;
+        if (frameTimer && (!partial || chunk.includes(10))) {
+          clearTimeout(frameTimer);
+          frameTimer = void 0;
+        }
+        if (partial && !frameTimer) {
+          frameTimer = setTimeout(() => socket.destroy(), 15e3);
+          frameTimer.unref();
+        }
+        for (const e of envelopes) {
+          if (socket.destroyed) break;
+          receive(e);
+        }
+      } catch {
+        socket.destroy();
+      }
+    });
+  }
+  accept(socket) {
+    if (this.closed || this.inbound >= 16) {
+      socket.destroy();
+      return;
+    }
+    this.inbound++;
+    this.sockets.add(socket);
+    socket.setNoDelay(true);
+    socket.once("close", () => {
+      this.inbound--;
+    });
+    const lifecycle = new AbortController();
+    socket.once("close", () => lifecycle.abort());
+    let sender;
+    this.read(socket, (e) => {
+      if (e.to !== this.instanceId || !verified(e, this.secret) || sender && sender !== e.from) {
+        socket.destroy();
+        return;
+      }
+      sender = e.from;
+      if (Date.now() - this.rateWindow >= 1e3) {
+        this.rateWindow = Date.now();
+        this.rateCount = 0;
+      }
+      if (++this.rateCount > 128) {
+        socket.destroy();
+        return;
+      }
+      if (e.waitMs) socket.setTimeout(Math.max(6e4, e.waitMs + 1e3));
+      if (!this.seen.add(`${e.from}:${e.id}`)) return;
+      try {
+        this.host.onEnvelope(e, (reply) => {
+          if (reply.from === this.instanceId && reply.to === e.from && reply.replyTo === e.id) this.write(socket, reply, this.secret);
+        }, lifecycle.signal);
+      } catch {
+        socket.destroy();
+      }
+    }, 6e4);
+  }
+  async send(peerInstanceId, port, kind, options = {}) {
+    if (this.closed || options.signal?.aborted || this.inflight >= MAX_INFLIGHT_SENDS) return null;
+    let secret;
+    try {
+      secret = this.host.resolveSecret?.(peerInstanceId);
+    } catch {
+      return null;
+    }
+    if (!secret || !/^[a-f0-9]{64}$/.test(secret) || !Number.isInteger(port) || port < 1 || port > 65535) return null;
+    const waitMs = options.waitMs ?? DEFAULT_SEND_WAIT_MS;
+    if (!Number.isFinite(waitMs) || waitMs < 0 || waitMs > 6e5) return null;
+    this.inflight++;
+    return new Promise((resolve) => {
+      const socket = new net.Socket();
+      this.sockets.add(socket);
+      const envelope = { v: IPC_PROTOCOL_VERSION, id: randomUUID(), from: this.instanceId, to: peerInstanceId, kind, createdAt: Date.now(), ...options.text !== void 0 ? { text: clipBody(options.text) } : {}, ...options.sessionId !== void 0 ? { sessionId: options.sessionId } : {}, ...options.replyTo ? { replyTo: options.replyTo } : {}, waitMs: options.expectReply ? waitMs : 0 };
+      let done = false;
+      const finish = (value) => {
+        if (done) return;
+        done = true;
+        clearTimeout(timer);
+        clearTimeout(dialTimer);
+        options.signal?.removeEventListener("abort", abort);
+        this.cancels.delete(abort);
+        this.inflight--;
+        socket.destroy();
+        resolve(value);
+      };
+      const abort = () => finish(null);
+      const timer = setTimeout(abort, options.expectReply ? waitMs : 3e3);
+      const dialTimer = setTimeout(abort, 3e3);
+      this.cancels.add(abort);
+      options.signal?.addEventListener("abort", abort, { once: true });
+      socket.once("close", abort);
+      this.read(socket, (e) => {
+        if (e.to !== this.instanceId || e.from !== peerInstanceId || e.replyTo !== envelope.id || !verified(e, secret)) {
+          finish(null);
+          return;
+        }
+        if ((options.replyKinds ?? /* @__PURE__ */ new Set(["result", "ack", "state"])).has(e.kind)) finish(e);
+      }, Math.max(waitMs, 3e3));
+      socket.once("connect", () => {
+        clearTimeout(dialTimer);
+        if (done || options.signal?.aborted || this.closed) {
+          finish(null);
+          return;
+        }
+        if (!this.write(socket, envelope, secret)) {
+          finish(null);
+          return;
+        }
+        if (!options.expectReply) {
+          socket.end(() => finish(envelope));
+        }
+      });
+      try {
+        socket.connect(port, "127.0.0.1");
+      } catch {
+        finish(null);
+      }
+    });
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const cancel of [...this.cancels]) cancel();
+    for (const socket of this.sockets) socket.destroy();
+    this.sockets.clear();
+    this.server.close();
+    this.port = null;
+  }
+};
+
+// builtin/extensions/pie-ipc/delivery.ts
+var AllowPolicy = class {
+  /**
+   * Empty list denies messages/body. '*' explicitly trusts authenticated local clients.
+   */
+  constructor(ids) {
+    this.ids = ids;
+  }
+  ids;
+  get allowAll() {
+    return this.ids.includes("*");
+  }
+  allows(instanceId) {
+    return this.allowAll || this.ids.includes(instanceId);
+  }
+  allow(instanceId) {
+    if (!this.ids.includes(instanceId)) this.ids.push(instanceId);
+  }
+  snapshot() {
+    return [...this.ids];
+  }
+};
+function deliveredUserText(message) {
+  if (message?.role !== "user") return "";
+  if (typeof message.content === "string") return message.content;
+  if (!Array.isArray(message.content)) return "";
+  let text = "";
+  for (const block of message.content) {
+    if (typeof block === "object" && block !== null && block.type === "text") {
+      const value = block.text;
+      if (typeof value === "string") text += value;
+    }
+  }
+  return text;
+}
+var InboundDelivery = class {
+  constructor(host, options) {
+    this.host = host;
+    this.options = options;
+    this.autoInject = options.autoInject;
+    this.degradeAfterMisses = options.degradeAfterMisses ?? 3;
+    this.verifyDeadlineMs = options.verifyDeadlineMs ?? 3e4;
+  }
+  host;
+  options;
+  inbox = [];
+  pending = /* @__PURE__ */ new Map();
+  droppedCount = { value: 0 };
+  autoInject;
+  consecutiveMisses = 0;
+  degradeAfterMisses;
+  verifyDeadlineMs;
+  /** Degraded = autoInject force-disabled after repeated delivery misses. */
+  degraded = false;
+  /** Counters surfaced by /ipc status. */
+  counters = { injected: 0, queued: 0, dropped: 0, denied: 0, degradedAt: 0, recovered: 0 };
+  get effectiveAutoInject() {
+    return this.autoInject && !this.degraded;
+  }
+  setAutoInject(enabled) {
+    this.autoInject = enabled;
+    if (enabled) {
+      this.degraded = false;
+      this.consecutiveMisses = 0;
+    }
+  }
+  /** Route one inbound message envelope. Returns the routing decision. */
+  routeMessage(envelope, displayName) {
+    try {
+      return this.routeMessageInner(envelope, displayName);
+    } catch (error) {
+      this.host.log(`pie-ipc: delivery error: ${error instanceof Error ? error.message : String(error)}`);
+      return "denied";
+    }
+  }
+  routeMessageInner(envelope, displayName) {
+    if (envelope.kind !== "message" || typeof envelope.text !== "string" || !envelope.text.trim()) {
+      return "denied";
+    }
+    if (!this.options.allowPolicy.allows(envelope.from)) {
+      this.counters.denied += 1;
+      this.host.notify?.(`pie-ipc: message from unapproved peer ${peerLabel(envelope.from, displayName)} \u2014 run /ipc allow`, "warning");
+      return "denied";
+    }
+    const label = peerLabel(envelope.from, displayName);
+    const message = {
+      id: envelope.id,
+      from: envelope.from,
+      fromLabel: label,
+      sessionId: envelope.sessionId,
+      text: clipBody(envelope.text),
+      receivedAt: Date.now()
+    };
+    try {
+      this.host.appendEntry("pie.ipc.message", {
+        id: message.id,
+        from: message.from,
+        fromLabel: message.fromLabel,
+        text: message.text.slice(0, 400)
+      });
+    } catch (error) {
+      this.host.log(`pie-ipc: audit entry failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (this.host.hasUI && this.effectiveAutoInject && this.pending.size < MAX_INBOX_MESSAGES) {
+      this.inject(message);
+      return "injected";
+    }
+    this.enqueueInbox(message);
+    return this.host.hasUI ? "queued" : "headless-queued";
+  }
+  inject(message) {
+    const wrapped = wrapInboundText(message.fromLabel, message.text, message.receivedAt, message.id);
+    const marker = wrappedMessageMarker(wrapped) ?? message.id;
+    const entry = {
+      marker,
+      message,
+      injectedAt: Date.now(),
+      timer: setTimeout(() => {
+        try {
+          this.noteMiss(message);
+        } catch {
+        }
+      }, this.verifyDeadlineMs)
+    };
+    entry.timer.unref?.();
+    this.pending.set(marker, entry);
+    this.counters.injected += 1;
+    try {
+      this.host.sendUserMessage(wrapped);
+    } catch {
+      clearTimeout(entry.timer);
+      if (this.pending.has(marker)) this.enqueueInbox(message);
+    }
+    this.updateStatus();
+  }
+  enqueueInbox(message) {
+    this.inbox.push(message);
+    this.counters.queued += 1;
+    if (this.inbox.length > MAX_INBOX_MESSAGES) {
+      this.inbox.shift();
+      this.droppedCount.value += 1;
+      this.counters.dropped += 1;
+      this.host.notify?.("pie-ipc: inbox full; oldest message dropped", "warning");
+    }
+    this.updateStatus();
+  }
+  /**
+   * Called on user message:end — verify pending injections against the
+   * settled user text. Timeout alone never moves a queued input to the inbox.
+   */
+  onUserMessageEnd(message) {
+    const text = deliveredUserText(message);
+    if (!isWrappedInboundText(text)) return;
+    const marker = wrappedMessageMarker(text);
+    if (!marker) return;
+    const entry = this.pending.get(marker);
+    if (!entry) return;
+    const recovered = this.inbox.findIndex((item) => item.id === entry.message.id);
+    if (recovered >= 0) this.inbox.splice(recovered, 1);
+    this.options.onConsumed?.(entry.message.id);
+    clearTimeout(entry.timer);
+    this.pending.delete(marker);
+    this.consecutiveMisses = 0;
+    this.host.log("pie-ipc: injection delivery verified");
+    this.updateStatus();
+  }
+  noteMiss(message) {
+    this.consecutiveMisses += 1;
+    this.host.log(`pie-ipc: injection ${message.id} not observed (miss ${this.consecutiveMisses})`);
+    if (this.consecutiveMisses >= this.degradeAfterMisses) {
+      this.degraded = true;
+      this.counters.degradedAt = Date.now();
+      this.host.notify?.(
+        `pie-ipc: injected messages stopped landing ${this.consecutiveMisses}x \u2014 auto-inject disabled, messages now wait in the inbox (/ipc poll)`,
+        "warning"
+      );
+    }
+    this.updateStatus();
+  }
+  /** Drain the inbox (ipc_poll). Messages leave the inbox permanently. */
+  drainInbox(limit = 20) {
+    if (this.inbox.length === 0) return [];
+    const drained = this.inbox.splice(0, Math.max(0, Math.min(100, Math.floor(limit))));
+    this.updateStatus();
+    return drained;
+  }
+  get inboxSize() {
+    return this.inbox.length;
+  }
+  get pendingInjections() {
+    return this.pending.size;
+  }
+  /** Undelivered injections advertised in the status file. */
+  get undeliveredInjections() {
+    return this.pending.size;
+  }
+  get overflowDropped() {
+    return this.droppedCount.value;
+  }
+  /** Clear inbox + verification state on session switch. */
+  resetSessionState() {
+    this.inbox.length = 0;
+    for (const entry of this.pending.values()) {
+      clearTimeout(entry.timer);
+    }
+    this.pending.clear();
+    this.degraded = false;
+    this.consecutiveMisses = 0;
+    this.updateStatus();
+  }
+  updateStatus() {
+    try {
+      if (!this.host.setStatus) return;
+      if (this.inbox.length > 0) {
+        const suffix = this.degraded ? " (degraded)" : "";
+        this.host.setStatus("pie-ipc", `ipc inbox ${this.inbox.length}${suffix}`);
+      } else if (this.degraded) {
+        this.host.setStatus("pie-ipc", "ipc auto-inject degraded; /ipc poll");
+      } else {
+        this.host.setStatus("pie-ipc", void 0);
+      }
+    } catch (error) {
+      this.host.log(`pie-ipc: status update failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+};
+
+// builtin/extensions/pie-ipc/status.ts
+var StatusProjection = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  shape = { state: "idle" };
+  lastBodyText = "";
+  lastBodyAt = 0;
+  undelivered = 0;
+  tools = /* @__PURE__ */ new Map();
+  bodyStart = 0;
+  get state() {
+    return this.shape.state;
+  }
+  get currentTool() {
+    return this.shape.currentTool;
+  }
+  /** Fold one lifecycle event; returns true when the state changed. */
+  updateFromEvent(event, now = Date.now()) {
+    if (event.type === "turn:completed") return false;
+    if (event.type === "tool:execution:start" && event.toolName) this.tools.set(event.toolName, (this.tools.get(event.toolName) ?? 0) + 1);
+    if (event.type === "tool:execution:end" && event.toolName) {
+      const count = (this.tools.get(event.toolName) ?? 1) - 1;
+      if (count > 0) this.tools.set(event.toolName, count);
+      else this.tools.delete(event.toolName);
+    }
+    if (["agent:end", "turn:failed", "turn:cancelled"].includes(event.type)) this.tools.clear();
+    const before = this.shape.state + (this.shape.blockedSince ?? "") + (this.shape.currentTool ?? "");
+    this.shape = foldLifecycleEvent(this.shape, event, now);
+    if (event.type.startsWith("tool:")) {
+      const blocking = this.tools.has("ask_user_multi");
+      this.shape = { ...this.shape, state: blocking ? "blocked" : "working", currentTool: blocking ? "ask_user_multi" : [...this.tools.keys()].at(-1), blockedSince: blocking ? this.shape.blockedSince ?? now : void 0 };
+    }
+    const after = this.shape.state + (this.shape.blockedSince ?? "") + (this.shape.currentTool ?? "");
+    return before !== after;
+  }
+  /** A turn settled: harvest the final body text from the tail. */
+  onTurnSettled() {
+    const messages = this.host.getMessages();
+    for (let index = messages.length - 1; index >= this.bodyStart; index -= 1) {
+      const text = assistantBodyText(messages[index]);
+      if (text) {
+        this.lastBodyText = clipBody(text, MAX_STATUS_BODY_CHARS);
+        this.lastBodyAt = Date.now();
+        return;
+      }
+    }
+  }
+  /** Called when an injection may not have been consumed yet. */
+  noteInjectionDelivered() {
+    this.undelivered += 1;
+  }
+  /** Called at turn:start — queued injections are being consumed now. */
+  onTurnStarted() {
+    this.undelivered = 0;
+    this.bodyStart = this.host.getMessages().length;
+    this.shape = { ...this.shape, currentTool: void 0 };
+  }
+  /** Session switch: lifecycle and answer state do not carry over. */
+  resetSessionState() {
+    this.shape = { state: "idle" };
+    this.tools.clear();
+    this.bodyStart = this.host.getMessages().length;
+    this.lastBodyText = "";
+    this.lastBodyAt = 0;
+    this.undelivered = 0;
+  }
+  /** Body text used to answer waiting ipc_send peers. */
+  lastBodyForReply() {
+    return this.lastBodyText;
+  }
+  snapshot(base) {
+    return {
+      ...base,
+      state: this.shape.state,
+      currentTool: this.shape.currentTool,
+      blockedSince: this.shape.blockedSince,
+      turnStartedAt: this.shape.turnStartedAt,
+      undeliveredInjections: this.undelivered,
+      lastBodyText: this.lastBodyText || void 0,
+      lastBodyAt: this.lastBodyAt || void 0
+    };
+  }
+};
+
+// builtin/extensions/pie-ipc/index.ts
+var Runtime = class {
+  constructor(ctx, config, discoveryDir) {
+    this.ctx = ctx;
+    this.config = config;
+    this.discoveryDir = discoveryDir;
+    this.displayName = config.displayName ?? peerLabel(this.instanceId);
+    this.allowPolicy = new AllowPolicy(config.allowPeers ? [...config.allowPeers] : []);
+    this.projection = new StatusProjection({ getMessages: () => ctx.getMessages() });
+  }
+  ctx;
+  config;
+  discoveryDir;
+  instanceId = generateInstanceId();
+  transport = null;
+  delivery = null;
+  projection;
+  /** Shared allow policy: /ipc allow affects delivery AND state.get gates. */
+  allowPolicy;
+  /** Inbound messages we accepted for a turn; answered on turn settle. */
+  awaitingReply = /* @__PURE__ */ new Map();
+  executionFailure;
+  active = false;
+  polledInputs = /* @__PURE__ */ new Map();
+  /** Server readiness gate: no status writes before the listener is up. */
+  serverReady = false;
+  disposed = false;
+  displayName;
+  sessionId = null;
+  sessionName;
+  statusBase;
+  stopHeartbeat = null;
+  stopWatch = null;
+  /** Server role: listen, advertise, watch peers. Publishes only after the
+   *  listener is up (headless instances never publish). */
+  async startServer() {
+    ensurePrivateDir(this.discoveryDir);
+    this.transport = new IpcTransport({
+      instanceId: this.instanceId,
+      resolveSecret: (id) => readStatusFile(this.discoveryDir, id)?.secret,
+      onEnvelope: (envelope, respond, signal) => this.handleEnvelope(envelope, respond, signal),
+      log: (message) => this.ctx.log(message)
+    });
+    const port = await this.transport.listen();
+    if (this.disposed) {
+      this.transport.close();
+      return;
+    }
+    this.statusBase = buildStatusFile({
+      instanceId: this.instanceId,
+      displayName: this.displayName,
+      sessionId: this.sessionId,
+      sessionName: this.sessionName,
+      cwd: this.ctx.cwd,
+      port
+    });
+    this.statusBase.secret = this.transport.secret;
+    this.serverReady = true;
+    this.writeStatus();
+    this.stopHeartbeat = startHeartbeat(this.discoveryDir, () => {
+      listPeers(this.discoveryDir, { selfId: this.instanceId, pruneDead: true });
+      return this.currentStatus();
+    }, HEARTBEAT_INTERVAL_MS, void 0, (message) => this.ctx.log(message));
+    this.stopWatch = watchDiscoveryDir(this.discoveryDir, () => {
+      this.ctx.ui.setStatus?.("pie-ipc-peers", void 0);
+    });
+  }
+  currentStatus() {
+    const snapshot = this.projection.snapshot({
+      ...this.statusBase,
+      displayName: this.displayName,
+      sessionId: this.sessionId,
+      sessionName: this.sessionName
+    });
+    return { ...snapshot, allowPeers: [...this.allowPolicy.snapshot()], undeliveredInjections: this.delivery?.undeliveredInjections ?? snapshot.undeliveredInjections ?? 0 };
+  }
+  writeStatus() {
+    if (!this.serverReady) return;
+    writeStatusFile(this.discoveryDir, this.currentStatus(), (message) => this.ctx.log(message));
+  }
+  handleEnvelope(envelope, respond, signal) {
+    const reply = (kind, text) => {
+      respond({
+        v: IPC_PROTOCOL_VERSION,
+        id: `${envelope.id}:r`,
+        from: this.instanceId,
+        to: envelope.from,
+        kind,
+        createdAt: Date.now(),
+        replyTo: envelope.id,
+        ...text !== void 0 ? { text } : {}
+      });
+    };
+    switch (envelope.kind) {
+      case "ping":
+        reply("ack", "pong");
+        return;
+      case "state.get": {
+        if (envelope.from !== this.instanceId && !this.allowPolicy.allows(envelope.from)) {
+          reply("state", JSON.stringify({ state: this.projection.state, restricted: true }));
+          return;
+        }
+        const status = this.currentStatus();
+        reply("state", JSON.stringify({
+          state: status.state,
+          currentTool: status.currentTool,
+          blockedSince: status.blockedSince,
+          turnStartedAt: status.turnStartedAt,
+          undeliveredInjections: status.undeliveredInjections,
+          lastBodyText: status.lastBodyText,
+          lastBodyAt: status.lastBodyAt,
+          sessionId: status.sessionId,
+          displayName: status.displayName
+        }));
+        return;
+      }
+      case "message": {
+        if (envelope.sessionId !== (this.sessionId ?? "")) {
+          reply("result", "rejected: target session changed");
+          return;
+        }
+        if (envelope.waitMs && this.awaitingReply.size >= 100) {
+          reply("result", "rejected: reply capacity reached");
+          return;
+        }
+        const deliveryId = `${envelope.from}:${envelope.id}`;
+        if (envelope.waitMs && envelope.waitMs > 0) {
+          const timer = setTimeout(() => this.finishReply(deliveryId, "expired: input not answered within waitMs"), envelope.waitMs);
+          timer.unref();
+          const disconnected = () => this.finishReply(deliveryId, "cancelled: requester disconnected");
+          this.awaitingReply.set(deliveryId, { reply: (text) => reply("result", text), timer, consumed: false, body: "", detach: () => signal?.removeEventListener("abort", disconnected) });
+          if (signal?.aborted) {
+            this.finishReply(deliveryId, "cancelled: requester disconnected");
+            return;
+          }
+          signal?.addEventListener("abort", disconnected, { once: true });
+        }
+        const decision = this.delivery?.routeMessage({ ...envelope, id: deliveryId }, this.displayNameOf(envelope.from));
+        if (decision === "denied") {
+          this.finishReply(deliveryId, "denied: not on this peer's allow list (/ipc allow)");
+          if (!envelope.waitMs) reply("result", "denied: not allowed");
+          return;
+        }
+        reply("ack", decision);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  displayNameOf(peerInstanceId) {
+    return readStatusFile(this.discoveryDir, peerInstanceId)?.displayName;
+  }
+  // ---- lifecycle events ----
+  onEvent(event) {
+    switch (event.type) {
+      case "turn:start": {
+        if (!this.active) this.executionFailure = void 0;
+        this.active = true;
+        this.projection.onTurnStarted();
+        if (this.projection.updateFromEvent(event)) this.writeStatus();
+        return;
+      }
+      case "tool:execution:start":
+      case "tool:execution:end": {
+        if (this.projection.updateFromEvent(event)) this.writeStatus();
+        return;
+      }
+      case "turn:completed":
+        return;
+      // inner model/tool round, not real idle
+      case "agent:end":
+      case "turn:failed":
+      case "turn:cancelled": {
+        this.projection.onTurnSettled();
+        if (this.projection.updateFromEvent(event)) this.writeStatus();
+        this.answerAwaitingPeers(event.type !== "agent:end" || Boolean(this.executionFailure));
+        this.active = false;
+        return;
+      }
+      case "session:changed": {
+        this.sessionId = event.sessionId ?? null;
+        this.sessionName = this.ctx.getSessionName?.();
+        this.delivery?.resetSessionState();
+        this.polledInputs.clear();
+        this.projection.resetSessionState();
+        this.executionFailure = void 0;
+        for (const id of [...this.awaitingReply.keys()]) this.finishReply(id, "cancelled: target session changed");
+        this.active = false;
+        this.writeStatus();
+        return;
+      }
+      case "message:end": {
+        const message = event.message;
+        if (message?.role === "user") {
+          this.delivery?.onUserMessageEnd(message);
+          const text = Array.isArray(message.content) ? message.content.map((block) => block?.type === "text" ? block.text : "").join("") : message.content;
+          if (typeof text === "string") {
+            const ids = this.polledInputs.get(text);
+            if (ids) {
+              this.polledInputs.delete(text);
+              for (const id of ids) this.markConsumed(id);
+            }
+          }
+        } else {
+          if (message?.role === "assistant") {
+            const outcome = message;
+            if (outcome.stopReason === "error" || outcome.stopReason === "aborted") this.executionFailure = outcome.stopReason;
+          }
+          const body = message && !this.executionFailure ? assistantBodyText(message) : "";
+          if (body) {
+            for (const waiter of this.awaitingReply.values()) if (waiter.consumed) waiter.body = body;
+          }
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /**
+   * When a turn settles, every peer message that opened (or queued into)
+   * this turn gets the assistant body as its awaited result. Failed/cancelled
+   * turns answer with an explanatory text instead.
+   */
+  markConsumed(id) {
+    const waiter = this.awaitingReply.get(id);
+    if (waiter && this.active) waiter.consumed = true;
+  }
+  finishReply(id, text) {
+    const waiter = this.awaitingReply.get(id);
+    if (!waiter) return;
+    this.awaitingReply.delete(id);
+    clearTimeout(waiter.timer);
+    waiter.detach();
+    try {
+      waiter.reply(clipBody(text));
+    } catch {
+    }
+  }
+  answerAwaitingPeers(failed) {
+    for (const [id, waiter] of [...this.awaitingReply]) {
+      if (waiter.consumed) this.finishReply(id, failed ? "(peer turn failed or was cancelled)" : waiter.body || "(empty reply)");
+    }
+  }
+  // ---- mutations from commands ----
+  mutations() {
+    return {
+      mute: (enabled) => {
+        this.delivery?.setAutoInject(!enabled);
+        this.ctx.log(`pie-ipc: auto-inject ${enabled ? "muted" : "enabled"}`);
+      },
+      allow: (instanceId) => {
+        this.allowPolicy.allow(instanceId);
+        this.writeStatus();
+        this.ctx.log(`pie-ipc: allowed peer ${instanceId}`);
+      },
+      setDisplayName: (name) => {
+        this.displayName = name.replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 60) || peerLabel(this.instanceId);
+        this.writeStatus();
+        this.ctx.log(`pie-ipc: display name set to ${this.displayName}`);
+      }
+    };
+  }
+  // ---- model tool implementations ----
+  async listPeers() {
+    const listings = listPeers(this.discoveryDir, { selfId: this.instanceId, pruneDead: false });
+    if (listings.length === 0) return "No pie-ipc peers discovered.";
+    const lines = listings.map(({ file, health }) => {
+      const label = peerLabel(file.instanceId, file.displayName);
+      const bits = [`${label} [${health}] ${file.state}`];
+      if (this.allowPolicy.allows(file.instanceId) && file.currentTool) bits.push(`tool=${file.currentTool}`);
+      if (this.allowPolicy.allows(file.instanceId) && file.blockedSince !== void 0) bits.push(`blocked ${Math.max(0, Math.round((Date.now() - file.blockedSince) / 1e3))}s`);
+      if (this.allowPolicy.allows(file.instanceId) && file.sessionId) bits.push(`session=${file.sessionId.slice(0, 8)}`);
+      if (file.port) bits.push(`port=${file.port}`);
+      bits.push(`id=${file.instanceId}`);
+      return bits.join(" ");
+    });
+    return lines.join("\n");
+  }
+  async statusOf(peerRef) {
+    const target = this.resolvePeer(peerRef);
+    if (!target) return `Peer not found: ${peerRef}`;
+    const staticView = `${peerLabel(target.instanceId, target.displayName)} [${listPeers(this.discoveryDir, { selfId: this.instanceId, pruneDead: false }).find((entry) => entry.file.instanceId === target.instanceId)?.health ?? "unknown"}] ${target.state}`;
+    if (!this.allowPolicy.allows(target.instanceId) || !(target.allowPeers?.includes("*") || target.allowPeers?.includes(this.instanceId))) return `${staticView}
+(content restricted by local allow policy)`;
+    if (target.lastBodyText) return `${staticView}
+last body (snapshot; may be stale): ${clipBody(target.lastBodyText, 400)}`;
+    if (!target.port || !this.transport) return `${staticView}
+(no live listener; file view only)`;
+    const reply = await this.transport.send(target.instanceId, target.port, "state.get", { expectReply: true, waitMs: 3e3 });
+    if (!reply || reply.kind !== "state") return `${staticView}
+(live query failed or timed out)`;
+    try {
+      const parsed = JSON.parse(reply.text ?? "{}");
+      const lines = [staticView];
+      if (parsed.currentTool) lines.push(`current tool: ${String(parsed.currentTool)}`);
+      if (typeof parsed.blockedSince === "number") lines.push(`blocked for ${Math.max(0, Math.round((Date.now() - parsed.blockedSince) / 1e3))}s`);
+      if (typeof parsed.undeliveredInjections === "number" && parsed.undeliveredInjections > 0) lines.push(`undelivered injections: ${parsed.undeliveredInjections}`);
+      if (parsed.restricted) lines.push("(peer restricts details for unapproved askers)");
+      if (typeof parsed.lastBodyText === "string" && parsed.lastBodyText) lines.push(`last body: ${clipBody(parsed.lastBodyText, 400)}`);
+      return lines.join("\n");
+    } catch {
+      return `${staticView}
+(live query returned unparsable payload)`;
+    }
+  }
+  /** Resolve a peer by display name, name prefix, or instance id. */
+  resolvePeer(peerRef) {
+    const listings = listPeers(this.discoveryDir, { selfId: this.instanceId, pruneDead: false });
+    const ref = peerRef.trim().toLowerCase();
+    if (!ref) return null;
+    const exact = listings.find(({ file }) => file.instanceId.toLowerCase() === ref);
+    if (exact) return exact.file;
+    const names = listings.filter(({ file }) => file.displayName.toLowerCase() === ref);
+    if (names.length) return names.length === 1 ? names[0].file : null;
+    const matches = listings.filter(({ file }) => file.instanceId.toLowerCase().startsWith(ref) || file.displayName.toLowerCase().startsWith(ref));
+    return matches.length === 1 ? matches[0].file : null;
+  }
+  async sendToPeer(peerRef, text, wait, waitMs, context) {
+    const target = this.resolvePeer(peerRef);
+    if (!target) {
+      return { content: [{ type: "text", text: `Peer not found: ${peerRef}. Call ipc_list_peers first.` }], isError: true };
+    }
+    if (!target.port) {
+      return { content: [{ type: "text", text: `${peerLabel(target.instanceId, target.displayName)} is not listening (client-only or headless host).` }], isError: true };
+    }
+    if (!this.transport) {
+      return { content: [{ type: "text", text: "IPC transport is unavailable (server startup failed or instance disposed)." }], isError: true };
+    }
+    const body = clipBody(text, this.config.maxBodyChars);
+    const reply = await this.transport.send(target.instanceId, target.port, "message", {
+      text: body,
+      sessionId: target.sessionId ?? "",
+      expectReply: wait,
+      waitMs,
+      signal: context.signal,
+      // Waiting sends resolve only on the peer's turn-settling result (or
+      // its terminal denied answer); the receipt ack stays informational.
+      replyKinds: /* @__PURE__ */ new Set(["result"])
+    });
+    if (!wait) {
+      if (!reply) return { content: [{ type: "text", text: `Send failed: ${peerLabel(target.instanceId, target.displayName)} unreachable.` }], isError: true };
+      return { content: [{ type: "text", text: `Sent to ${peerLabel(target.instanceId, target.displayName)} (no wait; receipt/consumption not confirmed).` }] };
+    }
+    if (!reply) {
+      if (context.signal?.aborted) return { content: [{ type: "text", text: "Wait cancelled; already accepted peer input is not cancelled." }] };
+      const snapshot = await this.statusOf(peerRef);
+      return {
+        content: [{ type: "text", text: `No reply from ${peerLabel(target.instanceId, target.displayName)} within ${waitMs}ms (or aborted).
+Peer status:
+${snapshot}` }],
+        isError: false
+      };
+    }
+    return { content: [{ type: "text", text: reply.text ?? "(empty reply)" }] };
+  }
+  drainInbox(limit, modelTool = true) {
+    const messages = this.delivery?.drainInbox(limit) ?? [];
+    if (messages.length === 0) return "Inbox empty.";
+    const text = messages.map((message) => `[pie-ipc id=${message.id}] ${message.fromLabel} (${new Date(message.receivedAt).toISOString()}):
+${message.text}`).join("\n---\n");
+    if (modelTool && this.active) for (const message of messages) this.markConsumed(message.id);
+    else {
+      if (this.polledInputs.size >= 100) this.polledInputs.delete(this.polledInputs.keys().next().value);
+      this.polledInputs.set(text, messages.map((message) => message.id));
+    }
+    return text;
+  }
+  /** /ipc send: deliver text, then surface the result without waiting. */
+  async drainReplyAfterSend(peerRef, text) {
+    const result = await this.sendToPeer(peerRef, text, false, 0, { toolCallId: "ipc-command", cwd: this.ctx.cwd, log: () => {
+    }, reportProgress: () => {
+    } });
+    return result.content[0]?.text ?? "(no result)";
+  }
+  dispose() {
+    this.disposed = true;
+    this.stopHeartbeat?.();
+    this.stopWatch?.();
+    for (const id of [...this.awaitingReply.keys()]) this.finishReply(id, "cancelled: peer disposed");
+    this.delivery?.resetSessionState();
+    this.polledInputs.clear();
+    try {
+      this.ctx.ui.setStatus?.("pie-ipc-peers", void 0);
+    } catch {
+    }
+    this.transport?.close();
+    removeStatusFile(this.discoveryDir, this.instanceId);
+  }
+};
+function loadConfig(ctx, configDir) {
+  const layers = [
+    { file: path2.join(configDir, "ipc.json"), content: safeRead(path2.join(configDir, "ipc.json")) },
+    { file: path2.join(ctx.cwd, ".pie", "ipc.json"), content: safeRead(path2.join(ctx.cwd, ".pie", "ipc.json")) }
+  ];
+  return resolveIpcConfig(layers);
+}
+function safeRead(file) {
+  try {
+    return fs2.readFileSync(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function pieIpcExtension(ctx) {
+  const configDir = process.env.PIE_IPC_CONFIG_DIR ?? getConfigDirSafe(ctx);
+  const discoveryDir = ipcDiscoveryDir(configDir);
+  const { config, problems } = loadConfig(ctx, configDir);
+  for (const problem of problems) ctx.log(`pie-ipc: ${problem}`);
+  if (!config) {
+    return;
+  }
+  if (process.platform === "win32") {
+    ctx.log("pie-ipc: disabled: Windows ACL isolation is not implemented");
+    return;
+  }
+  const runtime = new Runtime(ctx, config, discoveryDir);
+  ctx.log(`pie-ipc: enabled as ${runtime.instanceId} (${ctx.hasUI ? "server+client" : "client-only"})`);
+  if (ctx.hasUI) {
+    runtime.delivery = new InboundDelivery(
+      {
+        hasUI: ctx.hasUI,
+        sendUserMessage: (text) => ctx.sendUserMessage(text),
+        appendEntry: (type, data) => ctx.appendEntry?.(type, data) ?? "",
+        setStatus: (key, text) => ctx.ui.setStatus?.(key, text),
+        notify: (message, type) => ctx.ui.notify(message, type),
+        getMessages: () => ctx.getMessages(),
+        log: (message) => ctx.log(message)
+      },
+      { autoInject: config.autoInject ?? false, allowPolicy: runtime.allowPolicy, onConsumed: (id) => runtime.markConsumed(id) }
+    );
+    void runtime.startServer().catch((error) => {
+      ctx.log(`pie-ipc: server start failed: ${error instanceof Error ? error.message : String(error)}`);
+    });
+  } else {
+    runtime.transport = new IpcTransport({
+      instanceId: runtime.instanceId,
+      resolveSecret: (id) => readStatusFile(discoveryDir, id)?.secret,
+      onEnvelope: () => {
+      },
+      log: (message) => ctx.log(message)
+    });
+  }
+  const events = [
+    "turn:start",
+    "agent:end",
+    "turn:completed",
+    "turn:failed",
+    "turn:cancelled",
+    "tool:execution:start",
+    "tool:execution:end",
+    "session:changed",
+    "message:end"
+  ];
+  for (const event of events) {
+    ctx.on(event, ((payload) => {
+      runtime.onEvent(payload);
+    }));
+  }
+  const risk = {
+    riskClass: "external_side_effect",
+    permissionScope: "host",
+    requiresPermission: true,
+    externalSideEffect: true,
+    readsNetwork: true,
+    writesNetwork: true,
+    allowedForSubagentByDefault: false,
+    concurrencySafe: false
+  };
+  ctx.registerTool({
+    name: "ipc_list_peers",
+    label: "List Pie IPC peers",
+    description: "List other Pie processes on this machine that advertise pie-ipc. Each line: name [health] state (working/idle/blocked), current tool, blocked duration, session, port, instance id. Local read only; use ipc_status for a live query.",
+    parameters: Type.Object({}),
+    risk: { ...risk, riskClass: "read_only", externalSideEffect: false, requiresPermission: false, readsNetwork: false, writesNetwork: false, concurrencySafe: true },
+    renderHint: {
+      summary: () => "list peers"
+    },
+    execute: async () => ({ content: [{ type: "text", text: await runtime.listPeers() }] })
+  });
+  ctx.registerTool({
+    name: "ipc_send",
+    label: "Send a message to a Pie peer",
+    description: `Send text to another Pie process (interactive peer) addressed by display name or instance id prefix. wait=false (default): fire-and-forget \u2014 the peer receives it as user input. wait=true: hold until the peer's reply arrives (bounded by waitMs, default ${DEFAULT_SEND_WAIT_MS}ms); on timeout the peer's last known status is attached. Inbound messages from peers arrive as user input or in ipc_poll.`,
+    parameters: Type.Object({
+      to: Type.String({ description: "Peer display name or instance id (see ipc_list_peers)" }),
+      text: Type.String({ description: "Message body for the peer" }),
+      wait: Type.Optional(Type.Boolean({ description: "Wait for the peer's reply text (default false)" })),
+      waitMs: Type.Optional(Type.Number({ description: "Reply wait budget in ms (default 120000, max 600000)", minimum: 100, maximum: 6e5 }))
+    }),
+    risk,
+    renderHint: {
+      summary: (args) => {
+        const record = args ?? {};
+        return `\u2192 ${record.to ?? "?"}: ${(record.text ?? "").slice(0, 60)}`;
+      }
+    },
+    execute: async (args, context) => runtime.sendToPeer(args.to, args.text, args.wait ?? false, Math.min(args.waitMs ?? DEFAULT_SEND_WAIT_MS, 6e5), context)
+  });
+  ctx.registerTool({
+    name: "ipc_status",
+    label: "Query a peer's live status",
+    description: "Live-query a Pie peer's status over its socket: lifecycle state, current tool, blocked duration, undelivered injections, truncated last body text. Falls back to the status-file view when the peer is unreachable. unapproved askers get a restricted summary.",
+    parameters: Type.Object({
+      peer: Type.String({ description: "Peer display name or instance id prefix" })
+    }),
+    risk: { ...risk, riskClass: "network", requiresPermission: false, externalSideEffect: false, writesNetwork: false },
+    renderHint: {
+      summary: (args) => {
+        const record = args ?? {};
+        return `status ${record.peer ?? "?"}`;
+      }
+    },
+    execute: async (args) => ({ content: [{ type: "text", text: await runtime.statusOf(args.peer) }] })
+  });
+  ctx.registerTool({
+    name: "ipc_poll",
+    label: "Poll inbound IPC inbox",
+    description: "Drain undelivered inbound peer messages from the local inbox (mute mode, or while auto-inject is degraded). Messages leave the inbox permanently. Returns 'Inbox empty.' when there is nothing pending.",
+    parameters: Type.Object({
+      limit: Type.Optional(Type.Number({ description: "Max messages to drain (default 20)", minimum: 1, maximum: 100 }))
+    }),
+    risk: { ...risk, riskClass: "session_mutation", externalSideEffect: false, requiresPermission: false, readsNetwork: false, writesNetwork: false, concurrencySafe: false },
+    renderHint: {
+      summary: (args) => {
+        const record = args ?? {};
+        return `poll inbox${record.limit ? ` (limit ${record.limit})` : ""}`;
+      }
+    },
+    execute: async (args) => ({ content: [{ type: "text", text: runtime.drainInbox(args.limit ?? 20) }] })
+  });
+  ctx.registerCommand({
+    path: ["ipc"],
+    description: "Pie IPC peers: /ipc peers|send|poll|status|name|mute|allow",
+    handler: async (_extensionCtx, args) => {
+      const [sub, ...rest] = (args ?? "").trim().split(/\s+/);
+      const mutations = runtime.mutations();
+      const run = async () => {
+        switch (sub) {
+          case void 0:
+          case "":
+          case "peers":
+            return await runtime.listPeers();
+          case "send": {
+            const [peerRef, ...words] = rest;
+            if (!peerRef || words.length === 0) return "Usage: /ipc send <peer> <text>";
+            return runtime.drainReplyAfterSend(peerRef, words.join(" "));
+          }
+          case "poll":
+            return runtime.drainInbox(20, false);
+          case "status": {
+            const peerRef = rest[0];
+            if (!peerRef) return "Usage: /ipc status <peer>";
+            return await runtime.statusOf(peerRef);
+          }
+          case "name":
+            if (!rest[0]) return `Current name: ${runtime.displayName}
+Usage: /ipc name <new-name>`;
+            mutations.setDisplayName(rest[0]);
+            return `Display name set to: ${rest[0]}`;
+          case "mute":
+            mutations.mute(rest[0] !== "off");
+            return rest[0] === "off" ? "Auto-inject re-enabled (inbox still available via ipc_poll)." : "Muted: inbound messages wait in the inbox (ipc_poll).";
+          case "allow": {
+            if (!rest[0]) return "Usage: /ipc allow <instance-id>";
+            const target = runtime.resolvePeer(rest[0]);
+            const id = target?.instanceId ?? rest[0];
+            if (id !== "*" && !/^pie-[a-z0-9]{12}$/.test(id)) return "Invalid instance id.";
+            mutations.allow(id);
+            return `Allowed peer: ${id}`;
+          }
+          default:
+            return "Usage: /ipc peers|send <peer> <text>|poll|status <peer>|name <name>|mute [off]|allow <id>";
+        }
+      };
+      const output = await run();
+      if (sub === "poll") return output;
+      ctx.ui.notify(output, "info");
+    }
+  });
+  ctx.registerCleanup?.(() => {
+    runtime.dispose();
+  });
+}
+function getConfigDirSafe(_ctx) {
+  const envDir = process.env.PIE_CODING_AGENT_DIR;
+  if (envDir) {
+    if (envDir === "~") return homeDir();
+    if (envDir.startsWith("~/")) return path2.join(homeDir(), envDir.slice(2));
+    return envDir;
+  }
+  return path2.join(homeDir(), ".pie");
+}
+function homeDir() {
+  return process.env.HOME ?? process.env.USERPROFILE ?? "/tmp";
+}
+export {
+  pieIpcExtension as default
+};