@ctliz/agent-intercom-claude 0.13.1 → 0.14.1

package/dist/inbox-monitor.mjs

@@ -1,11 +1,34 @@
 #!/usr/bin/env node
 
 // claude/inbox-monitor.ts
-import { existsSync, readFileSync } from "node:fs";
-import { setTimeout as delay } from "node:timers/promises";
-import { basename } from "node:path";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { setTimeout as delay2 } from "node:timers/promises";
+import { basename as basename3 } from "node:path";
+
+// claude/inbox.ts
+import { dirname, join as join2 } from "node:path";
+
+// broker/paths.ts
+import { isAbsolute, join, resolve } from "path";
+import { homedir } from "os";
+function getAgentDirPath(env = process.env, homeDir = homedir(), cwd = process.cwd()) {
+  const configured = env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return join(homeDir, ".pi/agent");
+  }
+  return isAbsolute(configured) ? configured : resolve(cwd, configured);
+}
+function getIntercomDirPath(agentDir = getAgentDirPath()) {
+  return join(agentDir, "intercom");
+}
 
 // claude/inbox.ts
+function sanitizeInboxSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "session";
+}
+function defaultInboxPath(sessionId, intercomDir = getIntercomDirPath()) {
+  return join2(intercomDir, `inbox-${sanitizeInboxSegment(sessionId)}.jsonl`);
+}
 function formatInboxLine(entry) {
   const who = entry.fromName ? `${entry.fromName} (${entry.fromId.slice(0, 8)})` : entry.fromId;
   const kind = entry.expectsReply ? " [asking \u2014 awaiting your reply]" : "";
@@ -26,37 +49,275 @@ function inboxBatchFrom(content, alreadyEmitted) {
   return { entries, total };
 }
 
+// claude/session-lifecycle.ts
+import { execFileSync } from "node:child_process";
+import { closeSync, openSync, readFileSync, readSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join4 } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+import { setTimeout as delay } from "node:timers/promises";
+
+// claude/runtime.ts
+import { randomUUID, createHash } from "crypto";
+import { basename } from "path";
+import { cwd as processCwd } from "process";
+
+// broker/client.ts
+import { POLICY_SEMANTICS_HASH, POLICY_SEMANTICS_VERSION } from "@ctliz/agent-intercom-core";
+
+// broker/framing.ts
+var MAX_FRAME_BYTES = 1024 * 1024;
+
+// protocol-v4/contract.ts
+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";
+
+// broker/boss-contracts.ts
+import {
+  BOSS_CAPABILITY_FEATURE_DIGEST,
+  BOSS_POLICY_SEMANTICS_HASH,
+  BOSS_RUN_FEATURE,
+  BOSS_RUN_FEATURE_CONTRACT,
+  INTERCOM_BASE_PROTOCOL_VERSION,
+  evaluateBrokerCompatibility,
+  parseBossControlEnvelope,
+  parseBossParticipantBinding,
+  parseBossParticipantCredentialEnvelope,
+  parseBossPolicyPrincipal,
+  parseBossRunFeatureContract,
+  parseBrokerCapabilityAdvertisement,
+  isTerminalParticipantState,
+  parseParticipantState,
+  parseWorkerIdentityV2
+} from "@ctliz/agent-intercom-core/boss";
+import {
+  ContractValidationError,
+  assertExactKeys,
+  assertRecord,
+  readHexDigest
+} from "@ctliz/agent-intercom-core/canonical";
+
+// broker/spawn.ts
+import { join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import { POLICY_SEMANTICS_HASH as POLICY_SEMANTICS_HASH2, POLICY_SEMANTICS_VERSION as POLICY_SEMANTICS_VERSION2 } from "@ctliz/agent-intercom-core";
+var INTERCOM_DIR = getIntercomDirPath();
+var EXTENSION_DIR = join3(dirname2(fileURLToPath(import.meta.url)), "..");
+var BROKER_PID = join3(INTERCOM_DIR, "broker.pid");
+var BROKER_SPAWN_LOCK = join3(INTERCOM_DIR, "broker.spawn.lock");
+
+// config.ts
+var DEFAULT_ASK_TIMEOUT_MS = 45 * 1e3;
+var MAX_ASK_TIMEOUT_MS = 120 * 1e3;
+
+// claude/team.ts
+import { PARTICIPANT_STATES, TERMINAL_PARTICIPANT_STATES } from "@ctliz/agent-intercom-core/boss";
+import { readTeamManifestAsync, TeamManifestError } from "@ctliz/agent-intercom-core/team-manifest";
+var BOSS_NONTERMINAL_STATES = new Set(
+  PARTICIPANT_STATES.filter((state) => !TERMINAL_PARTICIPANT_STATES.includes(state))
+);
+
+// claude/runtime.ts
+function shortHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+var GENERIC_SESSION_ID_REGEX = /^[A-Za-z0-9_-]{1,128}$/;
+function buildClaudeRuntimeIdentity(env = process.env, cwd = env.PWD || processCwd(), pid = process.pid) {
+  let sessionId = env.CLAUDE_INTERCOM_SESSION_ID?.trim() || env.CLAUDE_PEER_ID?.trim();
+  if (!sessionId && env.AGENT_INTERCOM_SESSION_ID !== void 0) {
+    const raw = env.AGENT_INTERCOM_SESSION_ID.trim();
+    if (raw) {
+      if (!GENERIC_SESSION_ID_REGEX.test(raw)) {
+        throw new Error("Invalid AGENT_INTERCOM_SESSION_ID: must match ^[A-Za-z0-9_-]{1,128}$");
+      }
+      sessionId = raw;
+    }
+  }
+  if (!sessionId) {
+    sessionId = `claude-${pid}-${shortHash(cwd)}`;
+  }
+  const cwdName = basename(cwd) || "workspace";
+  const name = env.CLAUDE_INTERCOM_NAME?.trim() || env.CLAUDE_PEER_NAME?.trim() || (env.AGENT_INTERCOM_SESSION_NAME !== void 0 && env.AGENT_INTERCOM_SESSION_NAME.trim() ? env.AGENT_INTERCOM_SESSION_NAME.trim() : void 0) || `claude-${cwdName}-${pid}`;
+  return {
+    sessionId,
+    name,
+    cwd,
+    model: env.CLAUDE_INTERCOM_MODEL?.trim() || env.CLAUDE_MODEL?.trim() || "claude",
+    startedAt: Date.now()
+  };
+}
+
+// claude/session-lifecycle.ts
+function findClaudeHost(pid = process.ppid) {
+  for (let depth = 0; pid > 1 && depth < 16; depth++) {
+    let parts;
+    try {
+      parts = execFileSync(
+        "ps",
+        ["-p", String(pid), "-o", "ppid=", "-o", "lstart=", "-o", "comm="],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim().split(/\s+/);
+    } catch {
+      return void 0;
+    }
+    const command = basename2(parts.slice(6).join(" "));
+    if (/^claude(?:\.exe)?$/i.test(command)) {
+      return { pid, startedAt: parts.slice(1, 6).join(" ") };
+    }
+    if (!/^(sh|bash|zsh|dash|fish)$/.test(command)) return void 0;
+    pid = Number(parts[0]);
+  }
+  return void 0;
+}
+function claudeSessionMetadataPath(host) {
+  return join4(getIntercomDirPath(), `claude-host-${host.pid}.json`);
+}
+function readClaudeSessionMetadata(path, host) {
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    if (data.hostStartedAt !== host.startedAt || typeof data.sessionId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(data.sessionId) || typeof data.cwd !== "string" || typeof data.transcriptPath !== "string" || typeof data.startedAt !== "number" || typeof data.ended !== "boolean" || data.name !== void 0 && typeof data.name !== "string" || data.model !== void 0 && typeof data.model !== "string") return void 0;
+    return data;
+  } catch {
+    return void 0;
+  }
+}
+function claudeIdentityForSession(metadata, env = process.env, pid = process.pid) {
+  const identity = buildClaudeRuntimeIdentity(env, metadata?.cwd ?? env.PWD ?? process.cwd(), pid);
+  if (!metadata) return identity;
+  if (!env.CLAUDE_INTERCOM_SESSION_ID?.trim() && !env.CLAUDE_PEER_ID?.trim() && !env.AGENT_INTERCOM_SESSION_ID?.trim()) {
+    identity.sessionId = `claude-${metadata.sessionId}`;
+  }
+  identity.name = metadata.name?.trim() || identity.name;
+  if (!env.CLAUDE_INTERCOM_MODEL?.trim()) identity.model = metadata.model?.trim() || identity.model;
+  identity.startedAt = metadata.startedAt;
+  return identity;
+}
+var ClaudeSessionReader = class {
+  constructor(path, host) {
+    this.path = path;
+    this.host = host;
+  }
+  path;
+  host;
+  transcriptPath = "";
+  sessionId = "";
+  offset = 0;
+  partial = "";
+  decoder = new StringDecoder("utf8");
+  name;
+  startedAt = 0;
+  read() {
+    const metadata = readClaudeSessionMetadata(this.path, this.host);
+    if (!metadata || metadata.ended) return metadata;
+    if (metadata.sessionId !== this.sessionId || metadata.transcriptPath !== this.transcriptPath || metadata.startedAt !== this.startedAt) {
+      this.sessionId = metadata.sessionId;
+      this.transcriptPath = metadata.transcriptPath;
+      this.startedAt = metadata.startedAt;
+      this.name = void 0;
+      this.partial = "";
+      this.decoder = new StringDecoder("utf8");
+      try {
+        this.offset = Math.max(0, statSync(this.transcriptPath).size - 64 * 1024);
+      } catch {
+        this.offset = 0;
+      }
+    }
+    let fd;
+    try {
+      fd = openSync(this.transcriptPath, "r");
+      const size = statSync(this.transcriptPath).size;
+      if (size < this.offset) {
+        this.offset = 0;
+        this.partial = "";
+        this.decoder = new StringDecoder("utf8");
+      }
+      const buffer = Buffer.alloc(Math.min(size - this.offset, 64 * 1024));
+      const count = readSync(fd, buffer, 0, buffer.length, this.offset);
+      this.offset += count;
+      const lines = (this.partial + this.decoder.write(buffer.subarray(0, count))).split("\n");
+      this.partial = lines.pop() ?? "";
+      if (this.partial.length > 64 * 1024) this.partial = "";
+      for (const line of lines) {
+        if (!line.includes('"custom-title"')) continue;
+        try {
+          const record = JSON.parse(line);
+          if (record.type === "custom-title" && record.sessionId === metadata.sessionId && typeof record.customTitle === "string" && record.customTitle.trim()) this.name = record.customTitle;
+        } catch {
+        }
+      }
+    } catch {
+    } finally {
+      if (fd !== void 0) closeSync(fd);
+    }
+    return { ...metadata, name: this.name ?? metadata.name };
+  }
+};
+async function waitForClaudeSession(reader) {
+  for (let attempt = 0; attempt < 20; attempt++) {
+    const metadata = reader.read();
+    if (metadata) return metadata;
+    await delay(50);
+  }
+  return reader.read();
+}
+
 // claude/inbox-monitor.ts
 var POLL_MS = 1e3;
 function readContent(path) {
   try {
-    return existsSync(path) ? readFileSync(path, "utf-8") : "";
+    return existsSync(path) ? readFileSync2(path, "utf-8") : "";
   } catch {
     return "";
   }
 }
-async function runInboxMonitor(path, signal) {
-  let emitted = inboxBatchFrom(readContent(path), 0).total;
+async function runInboxMonitor(source, signal) {
+  let path = "";
+  let emitted = 0;
   for (; ; ) {
     if (signal?.aborted) return;
-    const { entries, total } = inboxBatchFrom(readContent(path), emitted);
+    const next = typeof source === "string" ? { path: source } : source();
+    const content = readContent(next.path);
+    if (path !== next.path) {
+      path = next.path;
+      const backlog = inboxBatchFrom(content, 0);
+      emitted = next.startedAt === void 0 ? backlog.total : backlog.entries.filter((entry) => entry.ts < next.startedAt).length;
+    }
+    const { entries, total } = inboxBatchFrom(content, emitted);
     for (const entry of entries) {
       process.stdout.write(`${formatInboxLine(entry)}
 `);
     }
     emitted = total;
-    await delay(POLL_MS);
+    await delay2(POLL_MS);
   }
 }
 async function main() {
-  const path = process.env.CLAUDE_INTERCOM_INBOX || process.argv[2];
-  if (!path) {
-    process.stderr.write("inbox-monitor: no inbox path (set CLAUDE_INTERCOM_INBOX or pass a path)\n");
-    process.exit(1);
+  const explicitPath = process.env.CLAUDE_INTERCOM_INBOX || process.argv[2];
+  const host = findClaudeHost();
+  if (!host) {
+    if (!explicitPath) throw new Error("Cannot determine this Claude session's inbox");
+    await runInboxMonitor(explicitPath);
+    return;
   }
-  await runInboxMonitor(path);
+  const reader = new ClaudeSessionReader(claudeSessionMetadataPath(host), host);
+  await waitForClaudeSession(reader);
+  await runInboxMonitor(() => {
+    const metadata = reader.read();
+    const identity = claudeIdentityForSession(metadata, process.env, host.pid);
+    return { path: explicitPath || defaultInboxPath(identity.sessionId), startedAt: metadata?.startedAt };
+  });
 }
-if (process.argv[1] && (basename(process.argv[1]) === "inbox-monitor.ts" || basename(process.argv[1]) === "inbox-monitor.mjs")) {
+if (process.argv[1] && (basename3(process.argv[1]) === "inbox-monitor.ts" || basename3(process.argv[1]) === "inbox-monitor.mjs")) {
   void main().catch((error) => {
     process.stderr.write(`inbox-monitor: ${error instanceof Error ? error.message : String(error)}
 `);

package/dist/session-hook.mjs

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+
+// claude/session-hook.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+
+// claude/session-lifecycle.ts
+import { execFileSync } from "node:child_process";
+import { closeSync, openSync, readFileSync as readFileSync2, readSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { basename as basename2, dirname as dirname2, join as join3 } from "node:path";
+
+// broker/paths.ts
+import { chmodSync, mkdirSync, readFileSync } from "fs";
+import { isAbsolute, join, resolve } from "path";
+import { homedir } from "os";
+var INTERCOM_DIR_MODE = 448;
+function getAgentDirPath(env = process.env, homeDir = homedir(), cwd = process.cwd()) {
+  const configured = env.PI_CODING_AGENT_DIR?.trim();
+  if (!configured) {
+    return join(homeDir, ".pi/agent");
+  }
+  return isAbsolute(configured) ? configured : resolve(cwd, configured);
+}
+function getIntercomDirPath(agentDir = getAgentDirPath()) {
+  return join(agentDir, "intercom");
+}
+function ensureIntercomRuntimeDir(intercomDir = getIntercomDirPath(), platform = process.platform) {
+  mkdirSync(intercomDir, { recursive: true, mode: INTERCOM_DIR_MODE });
+  if (platform !== "win32") {
+    chmodSync(intercomDir, INTERCOM_DIR_MODE);
+  }
+}
+
+// claude/runtime.ts
+import { randomUUID, createHash } from "crypto";
+import { basename } from "path";
+import { cwd as processCwd } from "process";
+
+// broker/client.ts
+import { POLICY_SEMANTICS_HASH, POLICY_SEMANTICS_VERSION } from "@ctliz/agent-intercom-core";
+
+// broker/framing.ts
+var MAX_FRAME_BYTES = 1024 * 1024;
+
+// protocol-v4/contract.ts
+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";
+
+// broker/boss-contracts.ts
+import {
+  BOSS_CAPABILITY_FEATURE_DIGEST,
+  BOSS_POLICY_SEMANTICS_HASH,
+  BOSS_RUN_FEATURE,
+  BOSS_RUN_FEATURE_CONTRACT,
+  INTERCOM_BASE_PROTOCOL_VERSION,
+  evaluateBrokerCompatibility,
+  parseBossControlEnvelope,
+  parseBossParticipantBinding,
+  parseBossParticipantCredentialEnvelope,
+  parseBossPolicyPrincipal,
+  parseBossRunFeatureContract,
+  parseBrokerCapabilityAdvertisement,
+  isTerminalParticipantState,
+  parseParticipantState,
+  parseWorkerIdentityV2
+} from "@ctliz/agent-intercom-core/boss";
+import {
+  ContractValidationError,
+  assertExactKeys,
+  assertRecord,
+  readHexDigest
+} from "@ctliz/agent-intercom-core/canonical";
+
+// broker/spawn.ts
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import { POLICY_SEMANTICS_HASH as POLICY_SEMANTICS_HASH2, POLICY_SEMANTICS_VERSION as POLICY_SEMANTICS_VERSION2 } from "@ctliz/agent-intercom-core";
+var INTERCOM_DIR = getIntercomDirPath();
+var EXTENSION_DIR = join2(dirname(fileURLToPath(import.meta.url)), "..");
+var BROKER_PID = join2(INTERCOM_DIR, "broker.pid");
+var BROKER_SPAWN_LOCK = join2(INTERCOM_DIR, "broker.spawn.lock");
+
+// config.ts
+var DEFAULT_ASK_TIMEOUT_MS = 45 * 1e3;
+var MAX_ASK_TIMEOUT_MS = 120 * 1e3;
+
+// claude/team.ts
+import { PARTICIPANT_STATES, TERMINAL_PARTICIPANT_STATES } from "@ctliz/agent-intercom-core/boss";
+import { readTeamManifestAsync, TeamManifestError } from "@ctliz/agent-intercom-core/team-manifest";
+var BOSS_NONTERMINAL_STATES = new Set(
+  PARTICIPANT_STATES.filter((state) => !TERMINAL_PARTICIPANT_STATES.includes(state))
+);
+
+// claude/runtime.ts
+function shortHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+var GENERIC_SESSION_ID_REGEX = /^[A-Za-z0-9_-]{1,128}$/;
+function buildClaudeRuntimeIdentity(env = process.env, cwd = env.PWD || processCwd(), pid = process.pid) {
+  let sessionId = env.CLAUDE_INTERCOM_SESSION_ID?.trim() || env.CLAUDE_PEER_ID?.trim();
+  if (!sessionId && env.AGENT_INTERCOM_SESSION_ID !== void 0) {
+    const raw = env.AGENT_INTERCOM_SESSION_ID.trim();
+    if (raw) {
+      if (!GENERIC_SESSION_ID_REGEX.test(raw)) {
+        throw new Error("Invalid AGENT_INTERCOM_SESSION_ID: must match ^[A-Za-z0-9_-]{1,128}$");
+      }
+      sessionId = raw;
+    }
+  }
+  if (!sessionId) {
+    sessionId = `claude-${pid}-${shortHash(cwd)}`;
+  }
+  const cwdName = basename(cwd) || "workspace";
+  const name = env.CLAUDE_INTERCOM_NAME?.trim() || env.CLAUDE_PEER_NAME?.trim() || (env.AGENT_INTERCOM_SESSION_NAME !== void 0 && env.AGENT_INTERCOM_SESSION_NAME.trim() ? env.AGENT_INTERCOM_SESSION_NAME.trim() : void 0) || `claude-${cwdName}-${pid}`;
+  return {
+    sessionId,
+    name,
+    cwd,
+    model: env.CLAUDE_INTERCOM_MODEL?.trim() || env.CLAUDE_MODEL?.trim() || "claude",
+    startedAt: Date.now()
+  };
+}
+
+// claude/session-lifecycle.ts
+function findClaudeHost(pid = process.ppid) {
+  for (let depth = 0; pid > 1 && depth < 16; depth++) {
+    let parts;
+    try {
+      parts = execFileSync(
+        "ps",
+        ["-p", String(pid), "-o", "ppid=", "-o", "lstart=", "-o", "comm="],
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+      ).trim().split(/\s+/);
+    } catch {
+      return void 0;
+    }
+    const command = basename2(parts.slice(6).join(" "));
+    if (/^claude(?:\.exe)?$/i.test(command)) {
+      return { pid, startedAt: parts.slice(1, 6).join(" ") };
+    }
+    if (!/^(sh|bash|zsh|dash|fish)$/.test(command)) return void 0;
+    pid = Number(parts[0]);
+  }
+  return void 0;
+}
+function claudeSessionMetadataPath(host) {
+  return join3(getIntercomDirPath(), `claude-host-${host.pid}.json`);
+}
+function readClaudeSessionMetadata(path, host) {
+  try {
+    const data = JSON.parse(readFileSync2(path, "utf8"));
+    if (data.hostStartedAt !== host.startedAt || typeof data.sessionId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(data.sessionId) || typeof data.cwd !== "string" || typeof data.transcriptPath !== "string" || typeof data.startedAt !== "number" || typeof data.ended !== "boolean" || data.name !== void 0 && typeof data.name !== "string" || data.model !== void 0 && typeof data.model !== "string") return void 0;
+    return data;
+  } catch {
+    return void 0;
+  }
+}
+function publishClaudeSessionMetadata(input, host, env = process.env, path = claudeSessionMetadataPath(host)) {
+  if (typeof input.session_id !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(input.session_id)) return;
+  const previous = readClaudeSessionMetadata(path, host);
+  const ended = input.hook_event_name === "SessionEnd";
+  if (ended && previous?.sessionId !== input.session_id) return;
+  if (!ended && (typeof input.cwd !== "string" || typeof input.transcript_path !== "string")) return;
+  const name = typeof input.session_title === "string" && input.session_title.trim() ? input.session_title : buildClaudeRuntimeIdentity(env, input.cwd, host.pid).name;
+  const data = ended ? { ...previous, ended: true } : {
+    hostStartedAt: host.startedAt,
+    sessionId: input.session_id,
+    cwd: input.cwd,
+    transcriptPath: input.transcript_path,
+    name,
+    ...typeof input.model === "string" ? { model: input.model } : {},
+    startedAt: Date.now(),
+    ended: false
+  };
+  ensureIntercomRuntimeDir(dirname2(path));
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify(data)}
+`, { mode: 384 });
+  renameSync(temp, path);
+}
+
+// claude/session-hook.ts
+try {
+  const input = JSON.parse(readFileSync3(0, "utf8"));
+  const host = findClaudeHost();
+  if (host && input && typeof input === "object" && !Array.isArray(input)) {
+    publishClaudeSessionMetadata(input, host);
+  }
+} catch (error) {
+  process.stderr.write(`claude-intercom hook: ${error instanceof Error ? error.message : String(error)}
+`);
+}

package/hooks/hooks.json

@@ -0,0 +1,26 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/dist/session-hook.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/dist/session-hook.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ctliz/agent-intercom-claude",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "description": "Claude Code MCP plugin and wakeable worker for local messaging with Pi, Codex, OpenCode, Grok Build, and AGY agents.",
   "license": "AGPL-3.0-or-later",
   "type": "module",
@@ -27,6 +27,7 @@
     "!scripts/build-protected-provider.mjs",
     "skills/**/*",
     "commands/**/*",
+    "hooks/**/*",
     "monitors/**/*",
     "types.ts",
     "config.ts",

package/scripts/build.mjs

@@ -46,6 +46,12 @@ const buildResults = await Promise.all([
     outfile: "dist/ccim.mjs",
     banner: { js: "#!/usr/bin/env node" },
   }),
+  build({
+    ...common,
+    entryPoints: ["claude/session-hook.ts"],
+    outfile: "dist/session-hook.mjs",
+    banner: { js: "#!/usr/bin/env node" },
+  }),
   build({
     ...common,
     entryPoints: ["claude/inbox-monitor.ts"],
@@ -68,4 +74,5 @@ await Promise.all([
   chmod("dist/cci.mjs", 0o755),
   chmod("dist/ccim.mjs", 0o755),
   chmod("dist/inbox-monitor.mjs", 0o755),
+  chmod("dist/session-hook.mjs", 0o755),
 ]);

package/scripts/verify-packed-runtime.mjs

@@ -13,8 +13,10 @@ const coreConsumers = new Set([
   "ccim.mjs",
   "claude-server.mjs",
   "worker-daemon.mjs",
+  "session-hook.mjs",
+  "inbox-monitor.mjs",
 ]);
-const bundles = [...coreConsumers, "inbox-monitor.mjs"];
+const bundles = [...coreConsumers];
 
 function tarString(buffer, offset, length) {
   const end = buffer.indexOf(0, offset);
@@ -112,6 +114,15 @@ try {
     throw new Error(`monitors.json missing intercom-inbox command referencing dist/inbox-monitor.mjs: ${JSON.stringify(inboxMonitor)}`);
   }
 
+  const hooksEntry = entries.get("package/hooks/hooks.json");
+  if (!hooksEntry) throw new Error("Packed adapter is missing hooks/hooks.json");
+  const hooks = JSON.parse(hooksEntry.toString("utf8")).hooks;
+  for (const event of ["SessionStart", "SessionEnd"]) {
+    if (!hooks?.[event]?.[0]?.hooks?.[0]?.command?.includes("/dist/session-hook.mjs")) {
+      throw new Error(`Packed ${event} hook does not reference session-hook.mjs`);
+    }
+  }
+
   // 4. Assert Plugin -> Skills & Commands exist in packed archive
   if (typeof plugin.skills !== "string") throw new Error("plugin.json missing skills declaration");
   const skillEntry = entries.get("package/skills/claude-intercom/SKILL.md");