@ctliz/agent-intercom-claude 0.12.0-connect.3

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-claude-link.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 alonw0
+
+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/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/monitors/monitors.json

@@ -0,0 +1,8 @@
+[
+  {
+    "name": "intercom-inbox",
+    "command": "node \"${CLAUDE_PLUGIN_ROOT}/dist/inbox-monitor.mjs\"",
+    "description": "Inbound intercom messages addressed to this session",
+    "when": "always"
+  }
+]

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,93 @@
+{
+  "name": "@ctliz/agent-intercom-claude",
+  "version": "0.12.0-connect.3",
+  "description": "Claude Code MCP plugin and wakeable worker for direct local messaging with Pi, Codex, and Claude coding-agent sessions.",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "main": "dist/claude-server.mjs",
+  "bin": {
+    "claude-intercom-mcp": "dist/claude-server.mjs",
+    "claude-intercom-worker": "dist/worker-daemon.mjs",
+    "cci": "dist/cci.mjs",
+    "ccim": "dist/ccim.mjs"
+  },
+  "files": [
+    "assets/**/*",
+    "dist/**/*",
+    "claude/**/*.ts",
+    "!claude/**/*.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/build-protected-provider.mjs",
+    "skills/**/*",
+    "commands/**/*",
+    "monitors/**/*",
+    "types.ts",
+    "config.ts",
+    "durable-json.ts",
+    "outbound-outbox.ts",
+    ".claude-plugin/**/*",
+    ".mcp.json",
+    "README.md",
+    "CHANGELOG.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",
+    "pretest": "npm run build",
+    "claude:mcp": "tsx claude/server.ts",
+    "claude:worker": "tsx claude/worker-daemon.ts",
+    "cci": "tsx claude/cci.ts",
+    "ccim": "tsx claude/ccim.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test protocol-v4/*.test.ts broker/*.test.ts outbound-outbox.test.ts claude/*.test.ts provider/*.test.ts test/*.test.ts",
+    "verify:core": "node scripts/verify-core-provenance.mjs",
+    "verify:pack": "node scripts/verify-packed-runtime.mjs"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "mcp",
+    "intercom",
+    "multi-agent",
+    "pi",
+    "codex"
+  ],
+  "peerDependencies": {
+    "@ctliz/agent-intercom-core": "0.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"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ctliz/agent-intercom-claude.git"
+  },
+  "homepage": "https://github.com/ctliz/agent-intercom-claude#readme",
+  "bugs": {
+    "url": "https://github.com/ctliz/agent-intercom-claude/issues"
+  }
+}

package/protocol-v4/contract.ts

@@ -0,0 +1,45 @@
+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 const INTERCOM_REGISTRATION_METADATA_ERROR = "Registration metadata is invalid" as const;
+
+export function parseIntercomScopeIdForRegistration(value: unknown): string | undefined {
+  try {
+    return parseIntercomScopeId(value, "registrationMetadata");
+  } catch {
+    throw new Error(INTERCOM_REGISTRATION_METADATA_ERROR);
+  }
+}
+
+export function intercomScopeIdFromEnvForRegistration(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  try {
+    return intercomScopeIdFromEnv(env);
+  } catch {
+    throw new Error(INTERCOM_REGISTRATION_METADATA_ERROR);
+  }
+}
+
+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 CLAUDE_BOSS_PROTECTED_PROVIDER_ID = "claude" as const;
+export const CLAUDE_BOSS_PROTECTED_PROVIDER_PACKAGE = "@ctliz/agent-intercom-claude" as const;
+export const CLAUDE_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH =
+  `${BROKER_PROTECTED_PROVIDER_ROOT}${CLAUDE_BOSS_PROTECTED_PROVIDER_ID}/provider.mjs` as const;
+export const BOSS_PROTECTED_SERVICE_UNAVAILABLE = "BOSS_PROTECTED_SERVICE_UNAVAILABLE" as const;
+
+const CLAUDE_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 ClaudeBossProtectedProviderArtifactCandidate {
+  adapterId: typeof CLAUDE_BOSS_PROTECTED_PROVIDER_ID;
+  providerPackage: typeof CLAUDE_BOSS_PROTECTED_PROVIDER_PACKAGE;
+  providerVersion: string;
+  providerDigest: string;
+  artifactPath: typeof CLAUDE_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH;
+  artifactOwnerUid: 0;
+  artifactOwnerGid: 0;
+  artifactMode: typeof CLAUDE_BOSS_PROTECTED_PROVIDER_MODE;
+}
+
+export type ClaudeBossProtectedServiceErrorCode =
+  | "INVALID_CLAUDE_PROTECTED_PROVIDER_CANDIDATE"
+  | typeof BOSS_PROTECTED_SERVICE_UNAVAILABLE;
+
+export class ClaudeBossProtectedServiceError extends Error {
+  readonly code: ClaudeBossProtectedServiceErrorCode;
+  readonly path: string;
+
+  constructor(code: ClaudeBossProtectedServiceErrorCode, path: string, message: string) {
+    super(`${path}: ${message}`);
+    this.name = "ClaudeBossProtectedServiceError";
+    this.code = code;
+    this.path = path;
+  }
+}
+
+function invalid(path: string, message: string): never {
+  throw new ClaudeBossProtectedServiceError(
+    "INVALID_CLAUDE_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 Claude 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 Claude provider.
+ * This parser cannot verify installation, signatures, service identities, or
+ * authority. Its frozen result remains explicitly non-authoritative.
+ */
+export function parseClaudeBossProtectedProviderArtifactCandidate(
+  value: unknown,
+): Readonly<ClaudeBossProtectedProviderArtifactCandidate> {
+  assertExactOwnDataCandidate(value);
+
+  if (ownValue(value, "adapterId") !== CLAUDE_BOSS_PROTECTED_PROVIDER_ID) {
+    invalid("$candidate.adapterId", "must identify the Claude provider");
+  }
+  if (ownValue(value, "providerPackage") !== CLAUDE_BOSS_PROTECTED_PROVIDER_PACKAGE) {
+    invalid("$candidate.providerPackage", "must identify the canonical Claude package");
+  }
+  if (ownValue(value, "artifactPath") !== CLAUDE_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH) {
+    invalid("$candidate.artifactPath", "must equal the canonical protected Claude provider path");
+  }
+  if (ownValue(value, "artifactOwnerUid") !== 0 || ownValue(value, "artifactOwnerGid") !== 0) {
+    invalid("$candidate.artifactOwnerUid", "must describe a root:root artifact");
+  }
+  if (ownValue(value, "artifactMode") !== CLAUDE_BOSS_PROTECTED_PROVIDER_MODE) {
+    invalid("$candidate.artifactMode", "must be read/execute-only mode 0555");
+  }
+
+  return Object.freeze({
+    adapterId: CLAUDE_BOSS_PROTECTED_PROVIDER_ID,
+    providerPackage: CLAUDE_BOSS_PROTECTED_PROVIDER_PACKAGE,
+    providerVersion: readProviderVersion(ownValue(value, "providerVersion")),
+    providerDigest: readProviderDigest(ownValue(value, "providerDigest")),
+    artifactPath: CLAUDE_BOSS_PROTECTED_PROVIDER_ARTIFACT_PATH,
+    artifactOwnerUid: 0,
+    artifactOwnerGid: 0,
+    artifactMode: CLAUDE_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 ensureClaudeBossProtectedService(_request: unknown): never {
+  throw new ClaudeBossProtectedServiceError(
+    BOSS_PROTECTED_SERVICE_UNAVAILABLE,
+    "$provisioner",
+    "the protected Claude 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 CLAUDE_BOSS_PROTECTED_PROVIDER_BUILD_IDENTITY = Object.freeze({
+    contractVersion: "claude.boss-protected-provider.v1",
+    adapterId: "claude",
+    providerPackage: "@ctliz/agent-intercom-claude",
+    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 ClaudeBossProtectedProviderStartUnavailableError extends Error {
+    code = BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE;
+    constructor() {
+        super(`${BOSS_PROTECTED_PROVIDER_START_UNAVAILABLE}: protected provider execution is not installed`);
+        this.name = "ClaudeBossProtectedProviderStartUnavailableError";
+    }
+}
+/** A later protected service may replace this dormant entry after release gates. */
+export function startClaudeBossProtectedProvider(_request) {
+    throw new ClaudeBossProtectedProviderStartUnavailableError();
+}

package/scripts/build.mjs

@@ -0,0 +1,71 @@
+import { chmod } from "node:fs/promises";
+import { build } from "esbuild";
+
+const common = {
+  bundle: true,
+  metafile: true,
+  platform: "node",
+  format: "esm",
+  target: "node20",
+  // Core is a runtime peer. Keep both its root entry point and every exported
+  // subpath as imports so all adapter bundles share the consumer's one Core
+  // module instance instead of embedding private copies.
+  external: [
+    "@ctliz/agent-intercom-core",
+    "@ctliz/agent-intercom-core/*",
+  ],
+};
+
+const buildResults = await Promise.all([
+  build({
+    ...common,
+    entryPoints: ["claude/server.ts"],
+    outfile: "dist/claude-server.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
+  build({
+    ...common,
+    entryPoints: ["broker/broker.ts"],
+    outfile: "dist/broker.mjs",
+  }),
+  build({
+    ...common,
+    entryPoints: ["claude/worker-daemon.ts"],
+    outfile: "dist/worker-daemon.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
+  build({
+    ...common,
+    entryPoints: ["claude/cci.ts"],
+    outfile: "dist/cci.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
+  build({
+    ...common,
+    entryPoints: ["claude/ccim.ts"],
+    outfile: "dist/ccim.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
+  build({
+    ...common,
+    entryPoints: ["claude/inbox-monitor.ts"],
+    outfile: "dist/inbox-monitor.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
+]);
+
+for (const result of buildResults) {
+  for (const input of Object.keys(result.metafile.inputs)) {
+    if (input.includes("node_modules/@ctliz/agent-intercom-core/")) {
+      throw new Error(`Core runtime was embedded in an adapter bundle through ${input}`);
+    }
+  }
+}
+
+await Promise.all([
+  chmod("dist/claude-server.mjs", 0o755),
+  chmod("dist/worker-daemon.mjs", 0o755),
+  chmod("dist/cci.mjs", 0o755),
+  chmod("dist/ccim.mjs", 0o755),
+  chmod("dist/inbox-monitor.mjs", 0o755),
+]);

package/scripts/verify-core-provenance.mjs

@@ -0,0 +1,64 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+export const APPROVED_CORE = Object.freeze({
+  name: "@ctliz/agent-intercom-core",
+  version: "0.1.0",
+  commit: "37e074970e2a9de32a16fc325607c3b476b0bd45",
+  integrity: "sha512-b5MXnfKh/RCjKoVor0tsFO+NKAqPROWgkgbHt7jiHxhdVbSh7gWvOdnVUtpSdPwJLYKSQrYXT+TJl7QocdJEPA==",
+});
+
+const repositoryRoot = join(dirname(fileURLToPath(import.meta.url)), "..");
+const devSpec = `git+https://github.com/ctliz/agent-intercom-core.git#${APPROVED_CORE.commit}`;
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function requireEqual(actual, expected, field) {
+  if (actual !== expected) {
+    throw new Error(`${field} must be ${JSON.stringify(expected)}; received ${JSON.stringify(actual)}`);
+  }
+}
+
+function verifyLocalProvenance() {
+  const manifest = readJson(join(repositoryRoot, "package.json"));
+  const lock = readJson(join(repositoryRoot, "package-lock.json"));
+  const lockRoot = lock.packages?.[""];
+  const lockedCore = lock.packages?.[`node_modules/${APPROVED_CORE.name}`];
+
+  requireEqual(manifest.peerDependencies?.[APPROVED_CORE.name], APPROVED_CORE.version, "Core peer dependency");
+  requireEqual(manifest.dependencies?.[APPROVED_CORE.name], undefined, "Core production dependency");
+  requireEqual(manifest.peerDependenciesMeta?.[APPROVED_CORE.name]?.optional, undefined, "Core peer optionality");
+  requireEqual(manifest.devDependencies?.[APPROVED_CORE.name], devSpec, "Core development provenance");
+  requireEqual(lockRoot?.peerDependencies?.[APPROVED_CORE.name], APPROVED_CORE.version, "locked Core peer dependency");
+  requireEqual(lockRoot?.devDependencies?.[APPROVED_CORE.name], devSpec, "locked Core development provenance");
+  requireEqual(lockedCore?.version, APPROVED_CORE.version, "supplied Core version");
+  requireEqual(lockedCore?.resolved, devSpec, "supplied Core commit");
+  requireEqual(lockedCore?.integrity, APPROVED_CORE.integrity, "supplied Core artifact integrity");
+  requireEqual(lockedCore?.dev, true, "supplied Core dependency class");
+}
+
+function verifyPublishedProvenance() {
+  const result = spawnSync("npm", [
+    "view",
+    `${APPROVED_CORE.name}@${APPROVED_CORE.version}`,
+    "version",
+    "dist.integrity",
+    "gitHead",
+    "--json",
+  ], { encoding: "utf8" });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`Unable to inspect published Core ${APPROVED_CORE.version}: ${(result.stderr || result.stdout).trim()}`);
+  }
+  const published = JSON.parse(result.stdout);
+  requireEqual(published.version, APPROVED_CORE.version, "published Core version");
+  requireEqual(published["dist.integrity"] ?? published.dist?.integrity, APPROVED_CORE.integrity, "published Core artifact integrity");
+  requireEqual(published.gitHead, APPROVED_CORE.commit, "published Core commit");
+}
+
+verifyLocalProvenance();
+if (process.argv.includes("--published")) verifyPublishedProvenance();