@ctliz/agent-intercom-codex 0.11.0-connect.2

package/durable-json.ts

@@ -0,0 +1,25 @@
+import { randomUUID } from "crypto";
+import { closeSync, fsyncSync, openSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { INTERCOM_RUNTIME_FILE_MODE, restrictIntercomRuntimeFile } from "./broker/paths.ts";
+
+export function writeDurableJson(filePath: string, value: unknown): void {
+  const temporaryPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(temporaryPath, JSON.stringify(value), { encoding: "utf-8", mode: INTERCOM_RUNTIME_FILE_MODE });
+  const fileDescriptor = openSync(temporaryPath, "r");
+  try {
+    fsyncSync(fileDescriptor);
+  } finally {
+    closeSync(fileDescriptor);
+  }
+  renameSync(temporaryPath, filePath);
+  restrictIntercomRuntimeFile(filePath);
+  if (process.platform !== "win32") {
+    const directoryDescriptor = openSync(dirname(filePath), "r");
+    try {
+      fsyncSync(directoryDescriptor);
+    } finally {
+      closeSync(directoryDescriptor);
+    }
+  }
+}

package/licenses/MIT-pi-intercom.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nico Bailon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/outbound-outbox.ts

@@ -0,0 +1,116 @@
+import { createHash } from "crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync } from "fs";
+import { join } from "path";
+import { ensureIntercomRuntimeDir, getIntercomDirPath, INTERCOM_DIR_MODE, restrictIntercomRuntimeFile } from "./broker/paths.ts";
+import { writeDurableJson } from "./durable-json.ts";
+import type { Message } from "./types.ts";
+
+const OUTBOX_STATE_VERSION = 1;
+const MAX_OUTBOX_MESSAGES = 256;
+
+export interface StoredOutboundMessage {
+  to: string;
+  message: Message;
+  queuedAt: number;
+}
+
+interface OutboxState {
+  version: typeof OUTBOX_STATE_VERSION;
+  entries: StoredOutboundMessage[];
+}
+
+function fingerprint(entry: Pick<StoredOutboundMessage, "to" | "message">): string {
+  return JSON.stringify({
+    to: entry.to,
+    replyTo: entry.message.replyTo,
+    expectsReply: entry.message.expectsReply,
+    content: entry.message.content,
+  });
+}
+
+function isStoredOutboundMessage(value: unknown): value is StoredOutboundMessage {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const entry = value as Record<string, unknown>;
+  if (typeof entry.to !== "string" || typeof entry.queuedAt !== "number") return false;
+  if (typeof entry.message !== "object" || entry.message === null || Array.isArray(entry.message)) return false;
+  const message = entry.message as Record<string, unknown>;
+  return typeof message.id === "string"
+    && typeof message.timestamp === "number"
+    && typeof message.content === "object"
+    && message.content !== null
+    && typeof (message.content as Record<string, unknown>).text === "string";
+}
+
+function fileName(sessionId: string): string {
+  return `${createHash("sha256").update(sessionId).digest("hex")}.json`;
+}
+
+export class PersistentOutboundOutbox {
+  private readonly directory: string;
+  private readonly filePath: string;
+  private state: OutboxState;
+
+  constructor(sessionId: string, intercomDir: string = getIntercomDirPath()) {
+    ensureIntercomRuntimeDir(intercomDir);
+    this.directory = join(intercomDir, "outbox");
+    mkdirSync(this.directory, { recursive: true, mode: INTERCOM_DIR_MODE });
+    if (process.platform !== "win32") chmodSync(this.directory, INTERCOM_DIR_MODE);
+    this.filePath = join(this.directory, fileName(sessionId));
+    this.state = this.load();
+  }
+
+  list(): StoredOutboundMessage[] {
+    return this.state.entries.map((entry) => ({ ...entry, message: { ...entry.message, content: { ...entry.message.content } } }));
+  }
+
+  enqueue(to: string, message: Message): "added" | "existing" {
+    const existing = this.state.entries.find((entry) => entry.message.id === message.id);
+    if (existing) {
+      if (fingerprint(existing) !== fingerprint({ to, message })) {
+        throw new Error(`Message ID ${message.id} is already queued with a different payload`);
+      }
+      return "existing";
+    }
+    if (this.state.entries.length >= MAX_OUTBOX_MESSAGES) {
+      throw new Error(`Durable outbox is full (${MAX_OUTBOX_MESSAGES} messages)`);
+    }
+    this.state.entries.push({ to, message, queuedAt: Date.now() });
+    this.persist();
+    return "added";
+  }
+
+  remove(messageId: string): void {
+    const remaining = this.state.entries.filter((entry) => entry.message.id !== messageId);
+    if (remaining.length === this.state.entries.length) return;
+    this.state.entries = remaining;
+    this.persist();
+  }
+
+  clear(): void {
+    if (this.state.entries.length === 0) return;
+    this.state.entries = [];
+    this.persist();
+  }
+
+  private load(): OutboxState {
+    if (!existsSync(this.filePath)) return { version: OUTBOX_STATE_VERSION, entries: [] };
+    try {
+      const parsed: unknown = JSON.parse(readFileSync(this.filePath, "utf-8"));
+      if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("expected object");
+      const state = parsed as Record<string, unknown>;
+      if (state.version !== OUTBOX_STATE_VERSION || !Array.isArray(state.entries) || !state.entries.every(isStoredOutboundMessage)) {
+        throw new Error("invalid outbox state");
+      }
+      return { version: OUTBOX_STATE_VERSION, entries: state.entries };
+    } catch {
+      const corruptPath = `${this.filePath}.corrupt-${Date.now()}`;
+      renameSync(this.filePath, corruptPath);
+      restrictIntercomRuntimeFile(corruptPath);
+      return { version: OUTBOX_STATE_VERSION, entries: [] };
+    }
+  }
+
+  private persist(): void {
+    writeDurableJson(this.filePath, this.state);
+  }
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@ctliz/agent-intercom-codex",
+  "version": "0.11.0-connect.2",
+  "description": "Codex MCP plugin for direct local messaging with Pi and Codex coding-agent sessions.",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "main": "dist/codex-server.mjs",
+  "bin": {
+    "codex-intercom-mcp": "dist/codex-server.mjs",
+    "codex-intercom-bridge": "dist/bridge-daemon.mjs",
+    "coi": "dist/coi.mjs"
+  },
+  "files": [
+    "assets/**/*",
+    "dist/**/*",
+    "codex/**/*.ts",
+    "!codex/**/*.test.ts",
+    "broker/**/*.ts",
+    "!broker/**/*.test.ts",
+    "protocol-v4/**/*.ts",
+    "!protocol-v4/**/*.test.ts",
+    "provider/protected-service.ts",
+    "provider/provider.mjs",
+    "!provider/entry.ts",
+    "scripts/**/*",
+    "!scripts/**/*.test.mjs",
+    "!scripts/build-protected-provider.mjs",
+    "skills/**/*",
+    "types.ts",
+    "config.ts",
+    "tsconfig.json",
+    "durable-json.ts",
+    "boss-control-outbox.ts",
+    "outbound-outbox.ts",
+    ".codex-plugin/**/*",
+    ".mcp.json",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "licenses/**/*",
+    "COPYRIGHT",
+    "LICENSE_TRANSITION.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "build:protected-provider": "node scripts/build-protected-provider.mjs",
+    "prepack": "npm run build:protected-provider",
+    "prepare": "npm run build",
+    "codex:mcp": "tsx codex/server.ts",
+    "codex:bridge": "tsx codex/bridge-daemon.ts",
+    "coi": "tsx codex/coi.ts",
+    "test": "node --import tsx --test broker/*.test.ts boss-control-outbox.test.ts outbound-outbox.test.ts codex/*.test.ts protocol-v4/*.test.ts provider/*.test.ts scripts/*.test.mjs",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "codex",
+    "mcp",
+    "intercom",
+    "multi-agent",
+    "pi"
+  ],
+  "peerDependencies": {
+    "@ctliz/agent-intercom-core": "0.1.0"
+  },
+  "optionalDependencies": {
+    "node-pty": "^1.1.0"
+  },
+  "devDependencies": {
+    "@ctliz/agent-intercom-core": "git+https://github.com/ctliz/agent-intercom-core.git#37e074970e2a9de32a16fc325607c3b476b0bd45",
+    "@types/node": "^24.0.0",
+    "esbuild": "^0.28.1",
+    "tsx": "^4.20.0",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ctliz/agent-intercom-codex.git"
+  },
+  "homepage": "https://github.com/ctliz/agent-intercom-codex#readme",
+  "bugs": {
+    "url": "https://github.com/ctliz/agent-intercom-codex/issues"
+  }
+}

package/protocol-v4/contract.ts

@@ -0,0 +1,27 @@
+import {
+  INTERCOM_PROTOCOL_NAME,
+  INTERCOM_PROTOCOL_V4_SEMANTICS_HASH,
+  INTERCOM_PROTOCOL_V4_VECTOR_SCHEMA_VERSION,
+  INTERCOM_PROTOCOL_V4_VECTORS,
+  INTERCOM_PROTOCOL_VERSION,
+  INTERCOM_SCOPE_ENV,
+  INTERCOM_SCOPE_ID_PATTERN,
+  INTERCOM_SCOPE_ID_PATTERN_SOURCE,
+  intercomScopeIdFromEnv,
+  parseIntercomScopeId,
+  sameIntercomScope,
+} from "@ctliz/agent-intercom-core/protocol-v4";
+
+export {
+  INTERCOM_PROTOCOL_NAME,
+  INTERCOM_PROTOCOL_V4_SEMANTICS_HASH,
+  INTERCOM_PROTOCOL_V4_VECTOR_SCHEMA_VERSION,
+  INTERCOM_PROTOCOL_V4_VECTORS,
+  INTERCOM_PROTOCOL_VERSION,
+  INTERCOM_SCOPE_ENV,
+  INTERCOM_SCOPE_ID_PATTERN,
+  INTERCOM_SCOPE_ID_PATTERN_SOURCE,
+  intercomScopeIdFromEnv,
+  parseIntercomScopeId,
+  sameIntercomScope,
+};

package/provider/protected-service.ts

@@ -0,0 +1,162 @@
+import { types as nodeUtilTypes } from "node:util";
+import { BROKER_PROTECTED_PROVIDER_ROOT } from "@ctliz/agent-intercom-core/boss";
+
+export const CODEX_BOSS_PROTECTED_PROVIDER_ID = "codex" as const;
+export const CODEX_BOSS_PROTECTED_PROVIDER_PACKAGE = "@ctliz/agent-intercom-codex" as const;
+export const CODEX_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH =
+  `${BROKER_PROTECTED_PROVIDER_ROOT}${CODEX_BOSS_PROTECTED_PROVIDER_ID}/provider.mjs` as const;
+export const BOSS_PROTECTED_SERVICE_UNAVAILABLE = "BOSS_PROTECTED_SERVICE_UNAVAILABLE" as const;
+
+const CODEX_BOSS_PROTECTED_PROVIDER_MODE = "0555" as const;
+const CANONICAL_SEMANTIC_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-(?:(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+const CANDIDATE_KEYS = [
+  "adapterId",
+  "providerPackage",
+  "providerVersion",
+  "providerDigest",
+  "artifactPath",
+  "artifactOwnerUid",
+  "artifactOwnerGid",
+  "artifactMode",
+] as const;
+
+export interface CodexBossProtectedProviderArtifactCandidate {
+  adapterId: typeof CODEX_BOSS_PROTECTED_PROVIDER_ID;
+  providerPackage: typeof CODEX_BOSS_PROTECTED_PROVIDER_PACKAGE;
+  providerVersion: string;
+  providerDigest: string;
+  artifactPath: typeof CODEX_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH;
+  artifactOwnerUid: 0;
+  artifactOwnerGid: 0;
+  artifactMode: typeof CODEX_BOSS_PROTECTED_PROVIDER_MODE;
+}
+
+export type CodexBossProtectedServiceErrorCode =
+  | "INVALID_CODEX_PROTECTED_PROVIDER_CANDIDATE"
+  | typeof BOSS_PROTECTED_SERVICE_UNAVAILABLE;
+
+export class CodexBossProtectedServiceError extends Error {
+  readonly code: CodexBossProtectedServiceErrorCode;
+  readonly path: string;
+
+  constructor(code: CodexBossProtectedServiceErrorCode, path: string, message: string) {
+    super(`${path}: ${message}`);
+    this.name = "CodexBossProtectedServiceError";
+    this.code = code;
+    this.path = path;
+  }
+}
+
+function invalid(path: string, message: string): never {
+  throw new CodexBossProtectedServiceError(
+    "INVALID_CODEX_PROTECTED_PROVIDER_CANDIDATE",
+    path,
+    message,
+  );
+}
+
+function assertExactOwnDataCandidate(value: unknown): asserts value is Record<string, unknown> {
+  const path = "$candidate";
+  if (
+    typeof value !== "object"
+    || value === null
+    || nodeUtilTypes.isProxy(value)
+    || Array.isArray(value)
+    || Object.getPrototypeOf(value) !== Object.prototype
+  ) {
+    invalid(path, "must be a non-proxy plain data object");
+  }
+
+  const keys = Reflect.ownKeys(value);
+  if (
+    keys.length !== CANDIDATE_KEYS.length
+    || keys.some((key) => typeof key !== "string" || !CANDIDATE_KEYS.includes(key as typeof CANDIDATE_KEYS[number]))
+  ) {
+    invalid(path, "must contain exactly the canonical unsigned Codex provider candidate fields");
+  }
+
+  for (const key of CANDIDATE_KEYS) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      descriptor === undefined
+      || !descriptor.enumerable
+      || !Object.hasOwn(descriptor, "value")
+    ) {
+      invalid(`${path}.${key}`, "must be an own enumerable data property");
+    }
+  }
+}
+
+function ownValue(value: Record<string, unknown>, key: typeof CANDIDATE_KEYS[number]): unknown {
+  return Object.getOwnPropertyDescriptor(value, key)!.value;
+}
+
+function readProviderVersion(value: unknown): string {
+  if (
+    typeof value !== "string"
+    || value.length > 128
+    || /[\r\n\u2028\u2029]/.test(value)
+    || !CANONICAL_SEMANTIC_VERSION.test(value)
+  ) {
+    invalid("$candidate.providerVersion", "must be a canonical semantic version");
+  }
+  return value;
+}
+
+function readProviderDigest(value: unknown): string {
+  if (typeof value !== "string" || value.length !== 64 || !/^[a-f0-9]{64}$/.test(value)) {
+    invalid("$candidate.providerDigest", "must be a lowercase SHA-256 digest");
+  }
+  return value;
+}
+
+/**
+ * Normalize an unsigned release candidate for the packaged Codex provider.
+ * This parser cannot verify installation, signatures, service identities, or
+ * authority. Its frozen result remains explicitly non-authoritative.
+ */
+export function parseCodexBossProtectedProviderArtifactCandidate(
+  value: unknown,
+): Readonly<CodexBossProtectedProviderArtifactCandidate> {
+  assertExactOwnDataCandidate(value);
+
+  if (ownValue(value, "adapterId") !== CODEX_BOSS_PROTECTED_PROVIDER_ID) {
+    invalid("$candidate.adapterId", "must identify the Codex provider");
+  }
+  if (ownValue(value, "providerPackage") !== CODEX_BOSS_PROTECTED_PROVIDER_PACKAGE) {
+    invalid("$candidate.providerPackage", "must identify the canonical Codex package");
+  }
+  if (ownValue(value, "artifactPath") !== CODEX_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH) {
+    invalid("$candidate.artifactPath", "must equal the canonical protected Codex provider path");
+  }
+  if (ownValue(value, "artifactOwnerUid") !== 0 || ownValue(value, "artifactOwnerGid") !== 0) {
+    invalid("$candidate.artifactOwnerUid", "must describe a root:root artifact");
+  }
+  if (ownValue(value, "artifactMode") !== CODEX_BOSS_PROTECTED_PROVIDER_MODE) {
+    invalid("$candidate.artifactMode", "must be read/execute-only mode 0555");
+  }
+
+  return Object.freeze({
+    adapterId: CODEX_BOSS_PROTECTED_PROVIDER_ID,
+    providerPackage: CODEX_BOSS_PROTECTED_PROVIDER_PACKAGE,
+    providerVersion: readProviderVersion(ownValue(value, "providerVersion")),
+    providerDigest: readProviderDigest(ownValue(value, "providerDigest")),
+    artifactPath: CODEX_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH,
+    artifactOwnerUid: 0,
+    artifactOwnerGid: 0,
+    artifactMode: CODEX_BOSS_PROTECTED_PROVIDER_MODE,
+  });
+}
+
+/**
+ * Production ensure is intentionally unavailable until a protected
+ * provisioner supplies release and service identity facts outside caller data.
+ * The request is never inspected while that provisioner is absent.
+ */
+export function ensureCodexBossProtectedService(_request: unknown): never {
+  throw new CodexBossProtectedServiceError(
+    BOSS_PROTECTED_SERVICE_UNAVAILABLE,
+    "$provisioner",
+    "the protected Codex broker service provisioner is not installed",
+  );
+}

package/provider/provider.mjs

@@ -0,0 +1,34 @@
+// Generated from provider/entry.ts by scripts/build-protected-provider.mjs.
+// Do not edit this artifact directly.
+const supportedBossFeature = Object.freeze({
+    version: "intercom.broker-feature.v1",
+    feature: "boss-run-v1",
+    featureVersion: 1,
+    semanticsHash: "8943eb60d29afa5264322b5cc7df3de245b01b1cf48a8cbf9cfb6188b02fcfa9",
+    controlEnvelopeVersion: 1,
+    capabilityDigest: "239bee8bb64cc8c149d49ac00c7396f33f375a89a1d6dea6bd86ff840d551a59",
+});
+/** Immutable build-time contract only; it is not an installed-provider claim. */
+export const CODEX_BOSS_PROTECTED_PROVIDER_BUILD_IDENTITY = Object.freeze({
+    contractVersion: "codex.boss-protected-provider.v1",
+    adapterId: "codex",
+    providerPackage: "@ctliz/agent-intercom-codex",
+    supportedBaseProtocolVersions: Object.freeze([4]),
+    supportedFeatures: Object.freeze([supportedBossFeature]),
+    protocolFeatureContractHash: "dae30efe2c48d2de0fe72a7ebdfd107d3feaefc180d42056ba05df6088a94364",
+    authoritative: false,
+    providerStartAvailable: false,
+    bossAdvertisementEnabled: false,
+});
+const BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE = "BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE";
+class CodexBossProtectedProviderStartUnavailableError extends Error {
+    code = BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE;
+    constructor() {
+        super(`${BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE}: protected provider execution is not installed`);
+        this.name = "CodexBossProtectedProviderStartUnavailableError";
+    }
+}
+/** A later protected service may replace this dormant entry after release gates. */
+export function startCodexBossProtectedProvider(_request) {
+    throw new CodexBossProtectedProviderStartUnavailableError();
+}

package/scripts/build-info.mjs

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { readdir, readFile } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+
+const RUNTIME_ROOTS = [
+  "broker",
+  "codex",
+];
+const RUNTIME_FILES = [
+  "config.ts",
+  "boss-control-outbox.ts",
+  "durable-json.ts",
+  "outbound-outbox.ts",
+  "package.json",
+  "scripts/build-info.mjs",
+  "scripts/build.mjs",
+  "types.ts",
+];
+
+async function runtimeFiles(root) {
+  const files = [];
+  async function walk(path) {
+    const entries = await readdir(path, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const child = join(path, entry.name);
+      if (entry.isDirectory()) {
+        await walk(child);
+      } else if (entry.isFile() && !entry.name.endsWith(".test.ts")) {
+        files.push(child);
+      }
+    }
+  }
+  for (const directory of RUNTIME_ROOTS) await walk(join(root, directory));
+  for (const file of RUNTIME_FILES) files.push(join(root, file));
+  return files.sort((a, b) => relative(root, a).localeCompare(relative(root, b)));
+}
+
+export async function computeRuntimeSourceSha256(root = process.cwd()) {
+  const resolvedRoot = resolve(root);
+  const hash = createHash("sha256");
+  for (const path of await runtimeFiles(resolvedRoot)) {
+    const name = relative(resolvedRoot, path).replaceAll("\\", "/");
+    hash.update(name);
+    hash.update("\0");
+    hash.update(await readFile(path));
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+
+export function buildIdentityLine({ packageName, version, target, sourceSha256 }) {
+  return `[agent-intercom-build] package=${packageName} version=${version} target=${target} sourceSha256=${sourceSha256}`;
+}
+
+export function buildBanner(identity, shebang = "") {
+  const prefix = shebang ? `${shebang}\n` : "";
+  return `${prefix}process.stderr.write(${JSON.stringify(`${buildIdentityLine(identity)}\n`)});`;
+}

package/scripts/build.mjs

@@ -0,0 +1,55 @@
+import { chmod, readFile, writeFile } from "node:fs/promises";
+import { build } from "esbuild";
+import { buildBanner, computeRuntimeSourceSha256 } from "./build-info.mjs";
+
+const packageJson = JSON.parse(await readFile("package.json", "utf8"));
+const sourceSha256 = await computeRuntimeSourceSha256();
+const identity = (target) => ({
+  packageName: packageJson.name,
+  version: packageJson.version,
+  target,
+  sourceSha256,
+});
+const common = {
+  bundle: true,
+  platform: "node",
+  format: "esm",
+  target: "node22.19",
+};
+const coreExternals = [
+  "@ctliz/agent-intercom-core",
+  "@ctliz/agent-intercom-core/*",
+];
+const outputs = [
+  { entry: "codex/server.ts", outfile: "dist/codex-server.mjs", target: "codex-server", executable: true },
+  { entry: "broker/broker.ts", outfile: "dist/broker.mjs", target: "broker", executable: false },
+  { entry: "codex/bridge-daemon.ts", outfile: "dist/bridge-daemon.mjs", target: "bridge-daemon", executable: true },
+  { entry: "codex/coi.ts", outfile: "dist/coi.mjs", target: "coi", executable: true, external: ["codex", "node-pty"] },
+];
+
+await Promise.all(outputs.map((output) => build({
+  ...common,
+  entryPoints: [output.entry],
+  outfile: output.outfile,
+  banner: { js: buildBanner(identity(output.target), output.executable ? "#!/usr/bin/env node" : "") },
+  external: [...coreExternals, ...(output.external ?? [])],
+})));
+
+await writeFile("dist/build-info.json", `${JSON.stringify({
+  schemaVersion: 1,
+  package: packageJson.name,
+  version: packageJson.version,
+  sourceSha256,
+  targets: outputs.map((output) => output.target),
+}, null, 2)}\n`, { mode: 0o644 });
+
+for (const output of outputs) {
+  const built = await readFile(output.outfile, "utf8");
+  if (!built.includes(sourceSha256) || !built.includes(`target=${output.target}`)) {
+    throw new Error(`Built output omitted immutable identity: ${output.outfile}`);
+  }
+}
+
+await Promise.all(outputs
+  .filter((output) => output.executable)
+  .map((output) => chmod(output.outfile, 0o755)));