olakai-cli 0.6.6 → 0.7.0

package/dist/chunk-75YQWZ4Q.js

@@ -0,0 +1,2587 @@
+import {
+  createAgent,
+  getCurrentUser,
+  listMyAgents,
+  regenerateAgentApiKey
+} from "./chunk-KNGRF4XU.js";
+import {
+  CLAUDE_DIR,
+  OLAKAI_DIR,
+  OLAKAI_HOOK_MARKER,
+  SETTINGS_FILE,
+  deleteClaudeCodeConfig,
+  findConfiguredWorkspace,
+  getClaudeCodeConfigPath,
+  getClaudeCodeStatus,
+  getClaudeDir,
+  getLegacyClaudeMonitorConfigPath,
+  getMonitorConfigPath,
+  getSettingsPath,
+  loadClaudeCodeConfig,
+  mergeHooksSettings,
+  readJsonFile,
+  writeClaudeCodeConfig,
+  writeJsonFile
+} from "./chunk-KY6OHQZW.js";
+import {
+  getBaseUrl,
+  getValidToken
+} from "./chunk-AVB4N2UN.js";
+
+// src/monitor/plugin.ts
+var TOOL_IDS = [
+  "claude-code",
+  "codex",
+  "cursor"
+];
+var registry = /* @__PURE__ */ new Map();
+function registerPlugin(plugin) {
+  registry.set(plugin.id, plugin);
+}
+function getPlugin(id) {
+  if (!isToolId(id)) {
+    throw new Error(
+      `Unknown tool: "${id}". Supported tools: ${TOOL_IDS.join(", ")}`
+    );
+  }
+  const plugin = registry.get(id);
+  if (!plugin) {
+    throw new Error(
+      `Tool "${id}" is not registered. This is a CLI bug \u2014 please report it.`
+    );
+  }
+  return plugin;
+}
+function listPlugins() {
+  return Array.from(registry.values());
+}
+function isToolId(value) {
+  return TOOL_IDS.includes(value);
+}
+
+// src/monitor/registry.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var REGISTRY_VERSION = 1;
+var OLAKAI_HOME_DIRNAME = ".olakai";
+var REGISTRY_FILENAME = "registry.json";
+var TOOL_DESCRIPTORS = {
+  "claude-code": {
+    scope: "workspace",
+    hooksPath: (projectRoot) => path.join(projectRoot, ".claude", "settings.json"),
+    source: "CLAUDE_CODE"
+  },
+  codex: {
+    scope: "global",
+    hooksPath: (_projectRoot, homeDir) => path.join(homeDir, ".codex", "config.toml"),
+    source: "CODEX"
+  },
+  cursor: {
+    scope: "global",
+    hooksPath: (_projectRoot, homeDir) => path.join(homeDir, ".cursor", "hooks.json"),
+    source: "CURSOR"
+  }
+};
+function getToolScope(toolId) {
+  return TOOL_DESCRIPTORS[toolId].scope;
+}
+function getToolHooksPath(toolId, projectRoot, homeDir = os.homedir()) {
+  return TOOL_DESCRIPTORS[toolId].hooksPath(projectRoot, homeDir);
+}
+function getToolSource(toolId) {
+  return TOOL_DESCRIPTORS[toolId].source;
+}
+function getOlakaiHomeDir(homeDir) {
+  return path.join(homeDir, OLAKAI_HOME_DIRNAME);
+}
+function getRegistryPath(homeDir = os.homedir()) {
+  return path.join(getOlakaiHomeDir(homeDir), REGISTRY_FILENAME);
+}
+function emptyRegistry() {
+  return { version: REGISTRY_VERSION, workspaces: [] };
+}
+function isRegistryEntry(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const e = value;
+  return typeof e.path === "string" && typeof e.tool === "string" && TOOL_IDS.includes(e.tool) && (e.scope === "workspace" || e.scope === "global") && typeof e.agentId === "string" && typeof e.agentName === "string" && typeof e.source === "string" && typeof e.configPath === "string" && typeof e.hooksPath === "string" && typeof e.monitoringEndpoint === "string" && typeof e.createdAt === "string";
+}
+function readRegistry(homeDir = os.homedir()) {
+  const filePath = getRegistryPath(homeDir);
+  try {
+    if (!fs.existsSync(filePath)) return emptyRegistry();
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.workspaces)) {
+      return emptyRegistry();
+    }
+    const workspaces = parsed.workspaces.filter(
+      isRegistryEntry
+    );
+    return { version: REGISTRY_VERSION, workspaces };
+  } catch {
+    return emptyRegistry();
+  }
+}
+function writeRegistry(registry2, homeDir = os.homedir()) {
+  const dir = getOlakaiHomeDir(homeDir);
+  const filePath = getRegistryPath(homeDir);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const body = JSON.stringify(registry2, null, 2) + "\n";
+  const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    fs.writeFileSync(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function sameKey(a, path_, tool) {
+  return a.path === path_ && a.tool === tool;
+}
+function upsertEntry(entry, homeDir = os.homedir()) {
+  const registry2 = readRegistry(homeDir);
+  const idx = registry2.workspaces.findIndex(
+    (e) => sameKey(e, entry.path, entry.tool)
+  );
+  if (idx >= 0) {
+    registry2.workspaces[idx] = entry;
+  } else {
+    registry2.workspaces.push(entry);
+  }
+  writeRegistry(registry2, homeDir);
+  return registry2;
+}
+function removeEntry(entryPath, tool, homeDir = os.homedir()) {
+  const registry2 = readRegistry(homeDir);
+  const next = registry2.workspaces.filter(
+    (e) => !sameKey(e, entryPath, tool)
+  );
+  if (next.length !== registry2.workspaces.length) {
+    registry2.workspaces = next;
+    writeRegistry(registry2, homeDir);
+  }
+  return registry2;
+}
+function readOnDiskConfig(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.agentId !== "string" || typeof parsed?.agentName !== "string" || typeof parsed?.source !== "string" || typeof parsed?.monitoringEndpoint !== "string") {
+      return null;
+    }
+    return {
+      agentId: parsed.agentId,
+      agentName: parsed.agentName,
+      source: parsed.source,
+      monitoringEndpoint: parsed.monitoringEndpoint,
+      createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function reconcileCurrentWorkspace(cwd, homeDir = os.homedir()) {
+  const root = findConfiguredWorkspace(cwd, TOOL_IDS);
+  if (!root) return [];
+  let registry2 = readRegistry(homeDir);
+  let mutated = false;
+  for (const toolId of TOOL_IDS) {
+    const configPath = getMonitorConfigPath(root, toolId);
+    const alreadyRegistered = registry2.workspaces.some(
+      (e) => sameKey(e, root, toolId)
+    );
+    if (alreadyRegistered) continue;
+    const config = readOnDiskConfig(configPath);
+    if (!config) continue;
+    const descriptor = TOOL_DESCRIPTORS[toolId];
+    const entry = {
+      path: root,
+      tool: toolId,
+      scope: descriptor.scope,
+      agentId: config.agentId,
+      agentName: config.agentName,
+      source: config.source,
+      configPath,
+      hooksPath: descriptor.hooksPath(root, homeDir),
+      monitoringEndpoint: config.monitoringEndpoint,
+      createdAt: config.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    registry2.workspaces.push(entry);
+    mutated = true;
+  }
+  const legacyClaudePath = getLegacyClaudeMonitorConfigPath(root);
+  const claudeRegistered = registry2.workspaces.some(
+    (e) => sameKey(e, root, "claude-code")
+  );
+  if (!claudeRegistered) {
+    const legacyConfig = readOnDiskConfig(legacyClaudePath);
+    if (legacyConfig) {
+      const descriptor = TOOL_DESCRIPTORS["claude-code"];
+      registry2.workspaces.push({
+        path: root,
+        tool: "claude-code",
+        scope: descriptor.scope,
+        agentId: legacyConfig.agentId,
+        agentName: legacyConfig.agentName,
+        source: legacyConfig.source,
+        configPath: getMonitorConfigPath(root, "claude-code"),
+        hooksPath: descriptor.hooksPath(root, homeDir),
+        monitoringEndpoint: legacyConfig.monitoringEndpoint,
+        createdAt: legacyConfig.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      });
+      mutated = true;
+    }
+  }
+  let persisted = true;
+  if (mutated) {
+    try {
+      writeRegistry(registry2, homeDir);
+    } catch {
+      persisted = false;
+    }
+  }
+  if (persisted) {
+    registry2 = readRegistry(homeDir);
+  }
+  return registry2.workspaces.filter((e) => e.path === root);
+}
+function formatRegistryTable(registry2, configExists = (p) => fs.existsSync(p)) {
+  if (registry2.workspaces.length === 0) {
+    return "No monitored workspaces recorded on this machine.\nRun 'olakai monitor init --tool <tool>' to start monitoring.";
+  }
+  const byTool = /* @__PURE__ */ new Map();
+  for (const entry of registry2.workspaces) {
+    const list = byTool.get(entry.tool) ?? [];
+    list.push(entry);
+    byTool.set(entry.tool, list);
+  }
+  const lines = [];
+  for (const toolId of TOOL_IDS) {
+    const entries = byTool.get(toolId);
+    if (!entries || entries.length === 0) continue;
+    lines.push(`${toolId} (${entries.length}):`);
+    for (const entry of entries) {
+      const missing = configExists(entry.configPath) ? "" : " (config missing)";
+      const verified = entry.lastVerifiedAt ? ` \xB7 verified ${entry.lastVerifiedAt}` : "";
+      lines.push(
+        `  \u2022 ${entry.agentName} [${entry.scope}] \u2014 ${entry.path}${verified}${missing}`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd();
+}
+
+// src/monitor/plugins/claude-code/index.ts
+import * as fs5 from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+
+// src/commands/monitor-state.ts
+import * as fs2 from "fs";
+import * as os2 from "os";
+import * as path2 from "path";
+var STATE_DIR_SEGMENTS = [".olakai", "monitor-state"];
+function getStateDir(homeDir) {
+  return path2.join(homeDir, ...STATE_DIR_SEGMENTS);
+}
+function getStateFile(sessionId, homeDir) {
+  return path2.join(getStateDir(homeDir), `${sessionId}.json`);
+}
+var debugLogger = null;
+function setDebugLogger(logger) {
+  debugLogger = logger;
+}
+function log(label, data) {
+  if (debugLogger) {
+    try {
+      debugLogger(label, data);
+    } catch {
+    }
+  }
+}
+function loadSessionState(sessionId, homeDir = os2.homedir()) {
+  if (!sessionId) return null;
+  const filePath = getStateFile(sessionId, homeDir);
+  try {
+    if (!fs2.existsSync(filePath)) return null;
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.lastUserTimestamp !== "string" || typeof parsed?.lastReportedAt !== "string" || typeof parsed?.numTurnsAtLastReport !== "number") {
+      return null;
+    }
+    return {
+      lastUserTimestamp: parsed.lastUserTimestamp,
+      lastReportedAt: parsed.lastReportedAt,
+      numTurnsAtLastReport: parsed.numTurnsAtLastReport
+    };
+  } catch (err) {
+    log("state-load-failed", {
+      sessionId,
+      error: err.message
+    });
+    return null;
+  }
+}
+function saveSessionState(sessionId, state, homeDir = os2.homedir()) {
+  if (!sessionId) return;
+  const dir = getStateDir(homeDir);
+  const filePath = getStateFile(sessionId, homeDir);
+  try {
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    fs2.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    log("state-save-failed", {
+      sessionId,
+      error: err.message
+    });
+  }
+}
+function shouldReportTurn(existing, currentUserTimestamp) {
+  if (!currentUserTimestamp) return true;
+  if (!existing) return true;
+  return existing.lastUserTimestamp !== currentUserTimestamp;
+}
+
+// src/monitor/plugins/claude-code/install.ts
+import * as fs3 from "fs";
+
+// src/monitor/self-monitor-provision.ts
+import path3 from "path";
+
+// src/lib/git.ts
+import { spawnSync } from "child_process";
+function getGitConfigEmail() {
+  let result;
+  try {
+    result = spawnSync("git", ["config", "--global", "user.email"], {
+      encoding: "utf8",
+      // Cap stdout. A normal `user.email` value is well under 320 bytes
+      // (RFC 5321 max email length); 64KB leaves headroom for git config
+      // wrappers that print a banner without ever truncating real
+      // values. spawnSync sets `result.error` (ENOBUFS) on overflow
+      // rather than truncating silently — we check it below.
+      maxBuffer: 65536,
+      // Don't pipe stderr to our process; we treat any error as "no email".
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+  if (result.error) return null;
+  if (result.status !== 0) return null;
+  const raw = (result.stdout || "").toString().trim();
+  if (!raw) return null;
+  const EMAIL_RE = /^[^\s@.]+(?:\.[^\s@.]+)*@[^\s@.]+(?:\.[^\s@.]+)*\.[a-zA-Z]{2,}$/;
+  if (!EMAIL_RE.test(raw)) return null;
+  if (raw.length > 320) return null;
+  return raw;
+}
+
+// src/monitor/prompt.ts
+import * as readline from "readline";
+function promptUser(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+// src/monitor/self-monitor-provision.ts
+async function provisionSelfMonitorAgent(opts) {
+  const me = await getCurrentUser();
+  const localPart = (me.email.split("@")[0] ?? "user").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  const workspaceName = path3.basename(opts.projectRoot).toLowerCase();
+  const defaultName = `${workspaceName}-${localPart}`;
+  let existing = [];
+  try {
+    existing = await listMyAgents({
+      source: opts.source,
+      name: defaultName
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!message.includes("Failed to list your agents")) {
+    }
+  }
+  if (existing.length > 0) {
+    const found = existing[0];
+    console.log(
+      `
+Found your existing ${opts.displayName} agent "${found.name}".`
+    );
+    console.log(
+      "Re-using it requires rotating its API key. Any other workspace currently using this agent will start failing on the next monitor request until it re-runs 'olakai monitor init'."
+    );
+    const ack = await promptUser("Rotate the API key and reuse? [y/N]: ");
+    if (ack.trim().toLowerCase() !== "y") {
+      console.error(
+        "Cancelled. To use this workspace without affecting the other workspace, run 'olakai monitor init' again and pick a different agent name when prompted."
+      );
+      process.exit(1);
+    }
+    const rotated = await regenerateAgentApiKey(found.id);
+    return {
+      id: found.id,
+      name: found.name,
+      description: found.description,
+      role: found.role,
+      // `source` on the listMyAgents response is the AgentSource enum
+      // string; the Agent type narrows it more loosely. Cast through
+      // the shared union.
+      source: found.source,
+      apiKey: {
+        id: rotated.id,
+        key: rotated.key,
+        keyMasked: rotated.keyMasked,
+        isActive: rotated.isActive
+      },
+      workflowId: null,
+      category: opts.category
+    };
+  }
+  const nameInput = await promptUser(
+    `Enter a descriptive name for this agent or accept the recommended name [${defaultName}]: `
+  );
+  const agentName = nameInput.trim() || defaultName;
+  const vcsEmailHint = getGitConfigEmail() ?? void 0;
+  try {
+    return await createAgent({
+      name: agentName,
+      description: `${opts.displayName} local agent for ${agentName}`,
+      role: "WORKER",
+      createApiKey: true,
+      source: opts.source,
+      ...vcsEmailHint ? { vcsEmailHint } : {}
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.toLowerCase().includes("already exists") || message.toLowerCase().includes("conflict")) {
+      console.log(
+        `
+An agent named "${agentName}" already exists on this account (created by someone else or an admin).`
+      );
+      const retry = await promptUser("Try a different name: ");
+      if (!retry.trim()) {
+        console.error("No name provided. Aborting.");
+        process.exit(1);
+      }
+      return createAgent({
+        name: retry.trim(),
+        description: `${opts.displayName} local agent for ${retry.trim()}`,
+        role: "WORKER",
+        createApiKey: true,
+        source: opts.source,
+        ...vcsEmailHint ? { vcsEmailHint } : {}
+      });
+    }
+    throw err;
+  }
+}
+
+// src/monitor/plugins/claude-code/install.ts
+import path4 from "path";
+var CLAUDE_CODE_SOURCE = "claude-code";
+var CLAUDE_CODE_AGENT_SOURCE = "CLAUDE_CODE";
+var CLAUDE_CODE_AGENT_CATEGORY = "CODING";
+async function installClaudeCode(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Claude Code monitoring for this workspace...\n");
+  const agent = await provisionSelfMonitorAgent({
+    projectRoot,
+    source: CLAUDE_CODE_AGENT_SOURCE,
+    displayName: "Claude Code",
+    category: CLAUDE_CODE_AGENT_CATEGORY
+  });
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.error(
+      "Internal error: agent provisioned but no API key returned. Please re-run 'olakai monitor init'."
+    );
+    process.exit(1);
+  }
+  const claudeDir = getClaudeDir(projectRoot);
+  if (!fs3.existsSync(claudeDir)) {
+    fs3.mkdirSync(claudeDir, { recursive: true });
+  }
+  const settingsPath = getSettingsPath(projectRoot);
+  const existingSettings = readJsonFile(settingsPath) ?? {};
+  const mergedHooks = mergeHooksSettings(existingSettings.hooks);
+  const updatedSettings = {
+    ...existingSettings,
+    hooks: mergedHooks
+  };
+  writeJsonFile(settingsPath, updatedSettings);
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: CLAUDE_CODE_SOURCE,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  writeClaudeCodeConfig(projectRoot, monitorConfig);
+  const configPath = getClaudeCodeConfigPath(projectRoot);
+  const configRel = path4.relative(projectRoot, configPath);
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(
+    `\u2713 Claude Code hooks configured in ${CLAUDE_DIR}/${SETTINGS_FILE}`
+  );
+  console.log(`\u2713 Monitor config saved to ${configRel}`);
+  console.log("");
+  console.log(
+    "Congrats! Monitoring is now active. Claude Code will report activity to Olakai"
+  );
+  console.log(`on each turn.`);
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${OLAKAI_DIR}/ is in your .gitignore (it contains your API key)`
+  );
+  console.log("");
+  console.log("To check status:  olakai monitor status --tool claude-code");
+  console.log("To disable:       olakai monitor disable --tool claude-code");
+  return {
+    agentId: agent.id,
+    agentName: agent.name,
+    source: CLAUDE_CODE_SOURCE,
+    monitoringEndpoint
+  };
+}
+async function uninstallClaudeCode(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const settingsPath = getSettingsPath(projectRoot);
+  const settings = readJsonFile(settingsPath);
+  if (settings?.hooks) {
+    const cleanedHooks = {};
+    for (const [event, entries] of Object.entries(settings.hooks)) {
+      const filtered = entries.filter(
+        (e) => !e.hooks.some((h) => h.command.includes(OLAKAI_HOOK_MARKER))
+      );
+      if (filtered.length > 0) {
+        cleanedHooks[event] = filtered;
+      }
+    }
+    if (Object.keys(cleanedHooks).length > 0) {
+      settings.hooks = cleanedHooks;
+    } else {
+      delete settings.hooks;
+    }
+    writeJsonFile(settingsPath, settings);
+    console.log(`\u2713 Olakai hooks removed from ${CLAUDE_DIR}/${SETTINGS_FILE}`);
+  } else {
+    console.log("No hooks found in settings.json.");
+  }
+  if (!opts.keepConfig) {
+    const configPath = getClaudeCodeConfigPath(projectRoot);
+    const configRel = path4.relative(projectRoot, configPath);
+    if (deleteClaudeCodeConfig(projectRoot)) {
+      console.log(`\u2713 Monitor config removed (${configRel})`);
+    }
+  } else {
+    const configPath = getClaudeCodeConfigPath(projectRoot);
+    const configRel = path4.relative(projectRoot, configPath);
+    console.log(`Monitor config retained at ${configRel}`);
+  }
+  console.log("");
+  console.log(
+    "Monitoring disabled. Run 'olakai monitor init --tool claude-code' to re-enable."
+  );
+}
+
+// src/monitor/plugins/claude-code/hook.ts
+import * as fs4 from "fs";
+
+// src/commands/monitor-transcript.ts
+var FILE_EDITING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "Edit",
+  "Write",
+  "MultiEdit"
+]);
+var BASH_TOOL_NAME = "Bash";
+var SKILL_REGEX = /^\/([\w-]+)(?:\s|$)/;
+function detectSkill(userMessage) {
+  if (typeof userMessage !== "string") return void 0;
+  const trimmed = userMessage.trimStart();
+  if (!trimmed) return void 0;
+  const match = SKILL_REGEX.exec(trimmed);
+  if (!match) return void 0;
+  return match[1];
+}
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block?.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function isMetaUserMessage(line, text) {
+  if (line.isMeta === true) return true;
+  if (!text) return true;
+  return text.includes("<command-name>") || text.includes("<local-command-caveat>") || text.includes("<command-message>");
+}
+function parseTimestamp(ts) {
+  if (typeof ts !== "string" || !ts) return NaN;
+  return Date.parse(ts);
+}
+function isCompactionEntry(line) {
+  if (line.type !== "system") return false;
+  const subtype = line.subtype ?? "";
+  return subtype === "compact_boundary" || subtype === "pre_compact" || subtype === "post_compact" || /compact/i.test(subtype);
+}
+function parseTranscript(raw) {
+  const empty = {
+    prompt: "",
+    response: "",
+    tokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    modelName: null,
+    numTurns: 0,
+    toolCallCount: 0,
+    filesEditedCount: 0,
+    bashCommandCount: 0
+  };
+  if (!raw) return empty;
+  const lines = raw.split("\n");
+  let lastUserText = "";
+  let lastUserTimestamp = NaN;
+  let lastUserTimestampRaw;
+  let lastAssistantText = "";
+  let lastAssistantTimestamp = NaN;
+  let lastAssistantModel = null;
+  let lastAssistantInputTokens = 0;
+  let lastAssistantOutputTokens = 0;
+  let numTurns = 0;
+  let currentTurnUserTimestamp = NaN;
+  let toolCallCount = 0;
+  let bashCommandCount = 0;
+  let editedFilePaths = /* @__PURE__ */ new Set();
+  for (const rawLine of lines) {
+    if (!rawLine) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(rawLine);
+    } catch {
+      continue;
+    }
+    if (isCompactionEntry(parsed)) continue;
+    if (parsed.isSidechain === true) continue;
+    if (parsed.type === "user" && parsed.message) {
+      const text = extractTextContent(parsed.message.content);
+      if (isMetaUserMessage(parsed, text)) continue;
+      lastUserText = text;
+      lastUserTimestamp = parseTimestamp(parsed.timestamp);
+      currentTurnUserTimestamp = lastUserTimestamp;
+      toolCallCount = 0;
+      bashCommandCount = 0;
+      editedFilePaths = /* @__PURE__ */ new Set();
+      lastUserTimestampRaw = typeof parsed.timestamp === "string" && parsed.timestamp ? parsed.timestamp : void 0;
+    } else if (parsed.type === "assistant" && parsed.message) {
+      const text = extractTextContent(parsed.message.content);
+      numTurns += 1;
+      if (text) lastAssistantText = text;
+      if (typeof parsed.message.model === "string") {
+        lastAssistantModel = parsed.message.model;
+      }
+      const content = parsed.message.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          try {
+            if (!block || block.type !== "tool_use") continue;
+            toolCallCount += 1;
+            const name = typeof block.name === "string" ? block.name : "";
+            if (name === BASH_TOOL_NAME) {
+              bashCommandCount += 1;
+              continue;
+            }
+            if (FILE_EDITING_TOOL_NAMES.has(name)) {
+              const input = block.input;
+              if (input !== null && typeof input === "object" && "file_path" in input) {
+                const filePath = input.file_path;
+                if (typeof filePath === "string" && filePath) {
+                  editedFilePaths.add(filePath);
+                }
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      const usage = parsed.message.usage;
+      if (usage) {
+        const input = (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0);
+        const output = usage.output_tokens ?? 0;
+        lastAssistantInputTokens = input;
+        lastAssistantOutputTokens = output;
+      }
+      const ts = parseTimestamp(parsed.timestamp);
+      if (!Number.isNaN(ts)) {
+        lastAssistantTimestamp = ts;
+      }
+    }
+  }
+  const result = {
+    prompt: lastUserText,
+    response: lastAssistantText,
+    tokens: lastAssistantInputTokens + lastAssistantOutputTokens,
+    inputTokens: lastAssistantInputTokens,
+    outputTokens: lastAssistantOutputTokens,
+    modelName: lastAssistantModel,
+    numTurns,
+    toolCallCount,
+    filesEditedCount: editedFilePaths.size,
+    bashCommandCount
+  };
+  if (!Number.isNaN(currentTurnUserTimestamp) && !Number.isNaN(lastAssistantTimestamp) && lastAssistantTimestamp >= currentTurnUserTimestamp) {
+    result.latencyMs = Math.round(
+      lastAssistantTimestamp - currentTurnUserTimestamp
+    );
+  }
+  const skill = detectSkill(lastUserText);
+  if (skill) {
+    result.skill = skill;
+  }
+  if (lastUserTimestampRaw) {
+    result.userTurnTimestamp = lastUserTimestampRaw;
+  }
+  return result;
+}
+
+// src/monitor/plugins/claude-code/hook.ts
+var noopDebug = () => {
+};
+function extractFromTranscript(transcriptPath, debugLog4 = noopDebug) {
+  const empty = {
+    prompt: "",
+    response: "",
+    tokens: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    modelName: null,
+    numTurns: 0,
+    toolCallCount: 0,
+    filesEditedCount: 0,
+    bashCommandCount: 0
+  };
+  if (!transcriptPath) return empty;
+  let raw;
+  try {
+    raw = fs4.readFileSync(transcriptPath, "utf-8");
+  } catch (err) {
+    debugLog4("transcript-read-failed", {
+      transcriptPath,
+      error: err.message
+    });
+    return empty;
+  }
+  return parseTranscript(raw);
+}
+function extractSubagentName(event) {
+  const candidates = [
+    event.agent_name,
+    event.subagent_type,
+    event.agent_type,
+    event.tool_input?.subagent_type
+  ];
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function buildClaudeCodePayload(event, eventData, config) {
+  const sessionId = eventData.session_id ?? `claude-code-${Date.now()}`;
+  switch (event) {
+    case "stop":
+    case "subagent-stop": {
+      const extracted = extractFromTranscript(eventData.transcript_path);
+      const isSubagent = event === "subagent-stop";
+      const customData = {
+        hookEvent: eventData.hook_event_name ?? (isSubagent ? "SubagentStop" : "Stop"),
+        sessionId,
+        transcriptPath: eventData.transcript_path ?? "",
+        cwd: eventData.cwd ?? "",
+        stopHookActive: eventData.stop_hook_active ?? false,
+        inputTokens: extracted.inputTokens,
+        outputTokens: extracted.outputTokens,
+        numTurns: extracted.numTurns,
+        // Per-turn work signals for the Claude Code classifier (D-027).
+        // Always emitted as JSON numbers — the backend classifier and
+        // KPI formulas must see numeric 0, not missing keys or strings.
+        toolCallCount: extracted.toolCallCount,
+        filesEditedCount: extracted.filesEditedCount,
+        bashCommandCount: extracted.bashCommandCount
+      };
+      if (typeof extracted.latencyMs === "number") {
+        customData.latencyMs = extracted.latencyMs;
+      }
+      if (isSubagent) {
+        const subagent = extractSubagentName(eventData);
+        if (subagent) {
+          customData.subagent = subagent;
+        }
+      } else if (extracted.skill) {
+        customData.skill = extracted.skill;
+      }
+      const payloadAssistant = eventData.last_assistant_message;
+      const response = typeof payloadAssistant === "string" && payloadAssistant.trim() ? payloadAssistant : extracted.response;
+      return {
+        prompt: extracted.prompt,
+        response,
+        chatId: sessionId,
+        source: config.source,
+        modelName: extracted.modelName ?? void 0,
+        tokens: extracted.tokens,
+        customData
+      };
+    }
+    default:
+      return null;
+  }
+}
+
+// src/monitor/plugins/claude-code/index.ts
+var TOOL_ID = "claude-code";
+var SUPPORTED_HOOK_EVENTS = /* @__PURE__ */ new Set(["stop", "subagent-stop"]);
+function debugLog(label, data) {
+  if (process.env.OLAKAI_MONITOR_DEBUG !== "1") return;
+  try {
+    const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
+`;
+    fs5.appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function resolveProjectRootFromPayload(eventData, fallbackCwd) {
+  const payloadCwd = typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : fallbackCwd;
+  return findConfiguredWorkspace(payloadCwd, [TOOL_ID]);
+}
+var claudeCodePlugin = {
+  id: TOOL_ID,
+  displayName: "Claude Code",
+  install(opts) {
+    return installClaudeCode(opts);
+  },
+  uninstall(opts) {
+    return uninstallClaudeCode(opts);
+  },
+  status(opts) {
+    return getClaudeCodeStatus(opts);
+  },
+  async handleHook(eventName, payloadJson) {
+    setDebugLogger(debugLog);
+    const event = eventName.trim();
+    if (!SUPPORTED_HOOK_EVENTS.has(event)) {
+      debugLog("hook-unknown-event", event);
+      return null;
+    }
+    const eventData = payloadJson ?? {};
+    debugLog("event-parsed", { event, eventData });
+    const projectRoot = resolveProjectRootFromPayload(
+      eventData,
+      process.cwd()
+    );
+    if (!projectRoot) {
+      debugLog("config-not-found", {
+        startDir: typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : process.cwd()
+      });
+      return null;
+    }
+    const config = loadClaudeCodeConfig(projectRoot, () => {
+    });
+    if (!config) {
+      debugLog("config-load-failed", { projectRoot });
+      return null;
+    }
+    const payload = buildClaudeCodePayload(event, eventData, config);
+    if (!payload) return null;
+    debugLog("payload-built", payload);
+    const sessionId = typeof eventData.session_id === "string" && eventData.session_id || void 0;
+    const extracted = extractFromTranscript(
+      eventData.transcript_path,
+      debugLog
+    );
+    const userTurnTimestamp = extracted.userTurnTimestamp;
+    if (extracted.prompt.trim() === "" && extracted.response.trim() === "" && extracted.numTurns === 0) {
+      debugLog("empty-parse-skip", {
+        event,
+        sessionId,
+        transcriptPath: eventData.transcript_path
+      });
+      return null;
+    }
+    if (sessionId) {
+      const existingState = loadSessionState(sessionId);
+      if (!shouldReportTurn(existingState, userTurnTimestamp)) {
+        debugLog("turn-dedup-skip", { sessionId, userTurnTimestamp });
+        return null;
+      }
+    }
+    if (sessionId && userTurnTimestamp) {
+      saveSessionState(sessionId, {
+        lastUserTimestamp: userTurnTimestamp,
+        lastReportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        numTurnsAtLastReport: extracted.numTurns
+      });
+      debugLog("state-saved", {
+        sessionId,
+        userTurnTimestamp,
+        numTurns: extracted.numTurns
+      });
+    }
+    return {
+      payload,
+      transport: {
+        endpoint: config.monitoringEndpoint,
+        apiKey: config.apiKey,
+        projectRoot
+      }
+    };
+  },
+  async detectInstalled(opts) {
+    const projectRoot = opts?.projectRoot ?? process.cwd();
+    try {
+      if (fs5.existsSync(getMonitorConfigPath(projectRoot, TOOL_ID))) {
+        return true;
+      }
+      if (fs5.existsSync(getLegacyClaudeMonitorConfigPath(projectRoot))) {
+        return true;
+      }
+    } catch {
+    }
+    return detectClaudeBinaryOnPath();
+  }
+};
+function detectClaudeBinaryOnPath() {
+  try {
+    const probe = spawnSync2(
+      process.platform === "win32" ? "where" : "which",
+      ["claude"],
+      {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e3
+      }
+    );
+    if (probe.status === 0 && probe.stdout && probe.stdout.toString().trim()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+registerPlugin(claudeCodePlugin);
+
+// src/monitor/plugins/codex/index.ts
+import * as fs10 from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+
+// src/monitor/plugins/codex/install.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import * as TOML from "@iarna/toml";
+
+// src/monitor/plugins/codex/paths.ts
+import * as os3 from "os";
+import * as path5 from "path";
+var CODEX_HOME_DIRNAME = ".codex";
+var CODEX_CONFIG_FILENAME = "config.toml";
+var CODEX_SESSIONS_DIRNAME = "sessions";
+function getCodexHomeDir() {
+  return path5.join(os3.homedir(), CODEX_HOME_DIRNAME);
+}
+function getCodexConfigPath() {
+  return path5.join(getCodexHomeDir(), CODEX_CONFIG_FILENAME);
+}
+function getCodexSessionsDir() {
+  return path5.join(getCodexHomeDir(), CODEX_SESSIONS_DIRNAME);
+}
+
+// src/monitor/plugins/codex/hooks.ts
+var OLAKAI_HOOK_MARKER2 = "olakai monitor hook";
+var CODEX_HOOK_TIMEOUT_SECONDS = 5;
+var SUPPORTED_HOOK_EVENT_NAMES = ["Stop"];
+function buildOlakaiHookGroup(event) {
+  return {
+    hooks: [
+      {
+        type: "command",
+        command: `olakai monitor hook --tool codex ${event}`,
+        timeout: CODEX_HOOK_TIMEOUT_SECONDS
+      }
+    ]
+  };
+}
+function isOlakaiHandler(handler) {
+  return typeof handler.command === "string" && handler.command.includes(OLAKAI_HOOK_MARKER2);
+}
+function groupContainsOlakaiHandler(group) {
+  if (!Array.isArray(group.hooks)) return false;
+  return group.hooks.some(isOlakaiHandler);
+}
+function mergeCodexHooks(existing, events = SUPPORTED_HOOK_EVENT_NAMES) {
+  const merged = { ...existing ?? {} };
+  for (const event of events) {
+    const existingGroups = merged[event] ?? [];
+    const hasOlakaiHook = existingGroups.some(groupContainsOlakaiHandler);
+    if (hasOlakaiHook) {
+      merged[event] = existingGroups;
+    } else {
+      merged[event] = [...existingGroups, buildOlakaiHookGroup(event)];
+    }
+  }
+  return merged;
+}
+function stripOlakaiHooks(existing) {
+  if (!existing) return void 0;
+  const cleaned = {};
+  for (const [event, groups] of Object.entries(existing)) {
+    if (!Array.isArray(groups)) continue;
+    const filteredGroups = [];
+    for (const group of groups) {
+      const handlers = Array.isArray(group.hooks) ? group.hooks : [];
+      const remaining = handlers.filter((h) => !isOlakaiHandler(h));
+      if (remaining.length === 0 && handlers.length > 0) {
+        continue;
+      }
+      if (remaining.length === handlers.length) {
+        filteredGroups.push(group);
+      } else {
+        filteredGroups.push({ ...group, hooks: remaining });
+      }
+    }
+    if (filteredGroups.length > 0) {
+      cleaned[event] = filteredGroups;
+    }
+  }
+  return Object.keys(cleaned).length > 0 ? cleaned : void 0;
+}
+function hasOlakaiHooksInstalled(parsed) {
+  const hooks = parsed.hooks;
+  if (!hooks) return false;
+  for (const groups of Object.values(hooks)) {
+    if (!Array.isArray(groups)) continue;
+    for (const group of groups) {
+      if (groupContainsOlakaiHandler(group)) return true;
+    }
+  }
+  return false;
+}
+
+// src/monitor/plugins/codex/config.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+function getCodexConfigPath2(projectRoot) {
+  return getMonitorConfigPath(projectRoot, "codex");
+}
+function loadCodexConfig(projectRoot) {
+  const filePath = getCodexConfigPath2(projectRoot);
+  try {
+    if (!fs6.existsSync(filePath)) return null;
+    const raw = fs6.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCodexConfig(projectRoot, config) {
+  const filePath = getCodexConfigPath2(projectRoot);
+  const dir = path6.dirname(filePath);
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true });
+  }
+  fs6.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  try {
+    fs6.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function deleteCodexConfig(projectRoot) {
+  const filePath = getCodexConfigPath2(projectRoot);
+  if (!fs6.existsSync(filePath)) return false;
+  try {
+    fs6.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/monitor/plugins/codex/install.ts
+var CODEX_SOURCE = "codex";
+var CODEX_AGENT_SOURCE = "CODEX";
+var CODEX_AGENT_CATEGORY = "CODING";
+async function installCodex(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Codex CLI monitoring for this workspace...\n");
+  const agent = await provisionSelfMonitorAgent({
+    projectRoot,
+    source: CODEX_AGENT_SOURCE,
+    displayName: "Codex CLI",
+    category: CODEX_AGENT_CATEGORY
+  });
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.error(
+      "Internal error: agent provisioned but no API key returned. Please re-run 'olakai monitor init'."
+    );
+    process.exit(1);
+  }
+  const { configExisted: codexConfigExisted } = installCodexHooksConfig();
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: CODEX_SOURCE,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  writeCodexConfig(projectRoot, monitorConfig);
+  const configPath = getCodexConfigPath2(projectRoot);
+  const configRel = path7.relative(projectRoot, configPath);
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(
+    `\u2713 Codex hooks configured in ~/${CODEX_HOME_DIRNAME}/${CODEX_CONFIG_FILENAME}`
+  );
+  console.log(`\u2713 Monitor config saved to ${configRel}`);
+  console.log("");
+  console.log(
+    "Congrats! Monitoring is now active. Codex CLI will report activity to Olakai"
+  );
+  console.log(`on each turn.`);
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${OLAKAI_DIR}/ is in your .gitignore (it contains your API key).`
+  );
+  console.log(
+    `\u26A0 Codex hooks require codex >= 0.124.0. Earlier versions silently skip them.`
+  );
+  if (codexConfigExisted) {
+    console.log(
+      `\u26A0 Existing comments in ~/${CODEX_HOME_DIRNAME}/${CODEX_CONFIG_FILENAME} were not preserved (TOML serializer limitation).`
+    );
+  }
+  console.log("");
+  console.log("To check status:  olakai monitor status --tool codex");
+  console.log("To disable:       olakai monitor disable --tool codex");
+  return {
+    agentId: agent.id,
+    agentName: agent.name,
+    source: CODEX_SOURCE,
+    monitoringEndpoint
+  };
+}
+function installCodexHooksConfig() {
+  const homeDir = getCodexHomeDir();
+  const configPath = getCodexConfigPath();
+  if (!fs7.existsSync(homeDir)) {
+    fs7.mkdirSync(homeDir, { recursive: true });
+  }
+  const configExisted = fs7.existsSync(configPath);
+  const parsed = readCodexConfigToml(configPath);
+  const merged = {
+    ...parsed,
+    hooks: mergeCodexHooks(parsed.hooks, SUPPORTED_HOOK_EVENT_NAMES)
+  };
+  writeCodexConfigToml(configPath, merged);
+  return { configExisted };
+}
+async function uninstallCodex(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const removedHooks = stripCodexHooksConfig();
+  if (removedHooks) {
+    console.log(
+      `\u2713 Olakai hooks removed from ~/${CODEX_HOME_DIRNAME}/${CODEX_CONFIG_FILENAME}`
+    );
+  } else {
+    console.log("No Olakai hooks found in Codex config.");
+  }
+  if (!opts.keepConfig) {
+    const configPath = getCodexConfigPath2(projectRoot);
+    const configRel = path7.relative(projectRoot, configPath);
+    if (deleteCodexConfig(projectRoot)) {
+      console.log(`\u2713 Monitor config removed (${configRel})`);
+    }
+  } else {
+    const configPath = getCodexConfigPath2(projectRoot);
+    const configRel = path7.relative(projectRoot, configPath);
+    console.log(`Monitor config retained at ${configRel}`);
+  }
+  console.log("");
+  console.log(
+    "Monitoring disabled. Run 'olakai monitor init --tool codex' to re-enable."
+  );
+}
+function applyOlakaiStripToConfig(parsed) {
+  const cleaned = stripOlakaiHooks(parsed.hooks);
+  const next = { ...parsed };
+  if (cleaned === void 0) {
+    delete next.hooks;
+  } else {
+    next.hooks = cleaned;
+  }
+  return next;
+}
+function stripCodexHooksConfig() {
+  const configPath = getCodexConfigPath();
+  if (!fs7.existsSync(configPath)) return false;
+  const parsed = readCodexConfigToml(configPath);
+  if (!hasOlakaiHooksInstalled(parsed)) return false;
+  const next = applyOlakaiStripToConfig(parsed);
+  writeCodexConfigToml(configPath, next);
+  return true;
+}
+function readCodexConfigToml(configPath) {
+  try {
+    if (!fs7.existsSync(configPath)) return {};
+    const raw = fs7.readFileSync(configPath, "utf-8");
+    if (!raw.trim()) return {};
+    return TOML.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeCodexConfigToml(configPath, data) {
+  const dir = path7.dirname(configPath);
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
+  }
+  const serialized = TOML.stringify(data);
+  fs7.writeFileSync(configPath, serialized, "utf-8");
+}
+
+// src/monitor/plugins/codex/status.ts
+import path8 from "path";
+import * as fs8 from "fs";
+async function getCodexStatus(opts) {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  const configPath = getCodexConfigPath2(projectRoot);
+  const config = loadCodexConfig(projectRoot);
+  const hooksConfigured = isHooksBlockInstalled();
+  if (!config) {
+    return {
+      toolId: "codex",
+      configured: false,
+      hooksConfigured,
+      configPath,
+      notes: hooksConfigured ? [
+        `Codex hooks present in ~/${CODEX_HOME_DIRNAME}/${CODEX_CONFIG_FILENAME} but no monitor config in this workspace \u2014 re-run init.`
+      ] : []
+    };
+  }
+  return {
+    toolId: "codex",
+    configured: true,
+    hooksConfigured,
+    agentId: config.agentId,
+    agentName: config.agentName,
+    source: config.source,
+    apiKeyMasked: config.apiKey.slice(0, 12) + "...",
+    monitoringEndpoint: config.monitoringEndpoint,
+    configuredAt: config.createdAt,
+    configPath
+  };
+}
+function isHooksBlockInstalled() {
+  const homeConfig = getCodexConfigPath();
+  if (!fs8.existsSync(homeConfig)) return false;
+  const parsed = readCodexConfigToml(homeConfig);
+  return hasOlakaiHooksInstalled(parsed);
+}
+
+// src/monitor/plugins/codex/transcript.ts
+import * as fs9 from "fs";
+import * as path9 from "path";
+function emptyRollout() {
+  return {
+    prompt: "",
+    response: "",
+    modelName: null,
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedInputTokens: 0,
+    reasoningOutputTokens: 0,
+    tokens: 0,
+    numTurns: 0
+  };
+}
+var noopDebug2 = () => {
+};
+var DEFAULT_LIMITS = {
+  maxDirs: 200,
+  maxFiles: 5e3
+};
+function findRolloutPathForSession(sessionId, sessionsDir = getCodexSessionsDir(), limits = {}) {
+  const merged = { ...DEFAULT_LIMITS, ...limits };
+  if (!sessionId) return null;
+  if (!fs9.existsSync(sessionsDir)) return null;
+  const suffix = `-${sessionId}.jsonl`;
+  const matches = [];
+  let dirsScanned = 0;
+  let filesScanned = 0;
+  const queue = [sessionsDir];
+  while (queue.length > 0) {
+    const dir = queue.shift();
+    if (dirsScanned++ > merged.maxDirs) break;
+    let entries;
+    try {
+      entries = fs9.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (filesScanned++ > merged.maxFiles) break;
+      const full = path9.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        queue.push(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (!entry.name.endsWith(suffix)) continue;
+      if (!entry.name.startsWith("rollout-")) continue;
+      try {
+        const stat = fs9.statSync(full);
+        matches.push({ path: full, mtimeMs: stat.mtimeMs });
+      } catch {
+      }
+    }
+  }
+  if (matches.length === 0) return null;
+  matches.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return matches[0].path;
+}
+function parseRolloutContent(raw, debugLog4 = noopDebug2) {
+  const result = emptyRollout();
+  if (!raw) return result;
+  const lines = raw.split("\n");
+  let lastUserMessage = "";
+  let lastAssistantMessage = "";
+  let lastTokenUsage = null;
+  let totalTokenUsage = null;
+  let modelName = null;
+  let userTurnCount = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (err) {
+      debugLog4("rollout-line-parse-failed", {
+        line: trimmed.slice(0, 120),
+        error: err.message
+      });
+      continue;
+    }
+    const type = parsed.type;
+    const payload = parsed.payload;
+    if (!type || !payload) continue;
+    if (type === "session_meta") {
+      continue;
+    }
+    if (type === "event_msg") {
+      const ev = payload;
+      const evType = ev.type;
+      if (evType === "user_message" && typeof ev.message === "string") {
+        lastUserMessage = ev.message;
+        userTurnCount += 1;
+      } else if (evType === "agent_message" && typeof ev.message === "string") {
+        lastAssistantMessage = ev.message;
+      } else if (evType === "token_count" && ev.info) {
+        if (ev.info.last_token_usage) {
+          lastTokenUsage = ev.info.last_token_usage;
+        }
+        if (ev.info.total_token_usage) {
+          totalTokenUsage = ev.info.total_token_usage;
+        }
+      } else if (evType === "session_configured" && typeof ev.model === "string" && ev.model) {
+        modelName = ev.model;
+      }
+      continue;
+    }
+    if (type === "response_item") {
+      const ri = payload;
+      if (ri.type === "message" && Array.isArray(ri.content)) {
+        const text = extractTextFromContent(ri.content);
+        if (!text) continue;
+        if (ri.role === "user") {
+          lastUserMessage = text;
+          userTurnCount += 1;
+        } else if (ri.role === "assistant") {
+          lastAssistantMessage = text;
+        }
+      }
+      continue;
+    }
+  }
+  result.prompt = lastUserMessage;
+  result.response = lastAssistantMessage;
+  result.modelName = modelName;
+  result.numTurns = userTurnCount;
+  const tokenSource = lastTokenUsage ?? totalTokenUsage;
+  if (tokenSource) {
+    result.inputTokens = numberOrZero(tokenSource.input_tokens);
+    result.outputTokens = numberOrZero(tokenSource.output_tokens);
+    result.cachedInputTokens = numberOrZero(tokenSource.cached_input_tokens);
+    result.reasoningOutputTokens = numberOrZero(
+      tokenSource.reasoning_output_tokens
+    );
+    result.tokens = numberOrZero(tokenSource.total_tokens) || result.inputTokens + result.outputTokens;
+  }
+  return result;
+}
+function extractTextFromContent(content) {
+  const parts = [];
+  for (const block of content) {
+    if (typeof block.text !== "string") continue;
+    if (block.type === "output_text" || block.type === "input_text" || block.type === "text") {
+      parts.push(block.text);
+    }
+  }
+  return parts.join("\n").trim();
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function loadRolloutForSession(sessionId, options = {}) {
+  const debugLog4 = options.debugLog ?? noopDebug2;
+  const sessionsDir = options.sessionsDir ?? getCodexSessionsDir();
+  const result = emptyRollout();
+  const rolloutPath = findRolloutPathForSession(sessionId, sessionsDir);
+  if (!rolloutPath) {
+    debugLog4("rollout-not-found", {
+      sessionId,
+      sessionsDir
+    });
+    return result;
+  }
+  let raw;
+  try {
+    raw = fs9.readFileSync(rolloutPath, "utf-8");
+  } catch (err) {
+    debugLog4("rollout-read-failed", {
+      rolloutPath,
+      error: err.message
+    });
+    return result;
+  }
+  const parsed = parseRolloutContent(raw, debugLog4);
+  parsed.rolloutPath = rolloutPath;
+  return parsed;
+}
+
+// src/monitor/plugins/codex/hook.ts
+var noopDebug3 = () => {
+};
+var SUPPORTED_EVENTS = /* @__PURE__ */ new Set(["Stop", "UserPromptSubmit"]);
+function isSupportedCodexEvent(eventName) {
+  return SUPPORTED_EVENTS.has(eventName);
+}
+function buildCodexPayload(eventName, eventData, config, rollout = emptyRollout()) {
+  if (!isSupportedCodexEvent(eventName)) return null;
+  if (eventName === "UserPromptSubmit") return null;
+  const sessionId = typeof eventData.session_id === "string" && eventData.session_id ? eventData.session_id : `codex-${Date.now()}`;
+  const cwd = typeof eventData.cwd === "string" ? eventData.cwd : "";
+  const turnId = typeof eventData.turn_id === "string" ? eventData.turn_id : "";
+  const permissionMode = typeof eventData.permission_mode === "string" ? eventData.permission_mode : "";
+  const transcriptPath = typeof eventData.transcript_path === "string" ? eventData.transcript_path : "";
+  const modelName = (typeof eventData.model === "string" && eventData.model.trim() ? eventData.model : null) ?? rollout.modelName;
+  const customData = {
+    hookEvent: eventData.hook_event_name ?? eventName,
+    sessionId,
+    cwd,
+    turnId,
+    permissionMode,
+    transcriptPath,
+    inputTokens: rollout.inputTokens,
+    outputTokens: rollout.outputTokens,
+    cachedInputTokens: rollout.cachedInputTokens,
+    reasoningOutputTokens: rollout.reasoningOutputTokens,
+    numTurns: rollout.numTurns
+  };
+  if (rollout.rolloutPath) {
+    customData.rolloutPath = rollout.rolloutPath;
+  }
+  if (typeof eventData.stop_hook_active === "boolean") {
+    customData.stopHookActive = eventData.stop_hook_active;
+  }
+  const inlineAssistant = typeof eventData.last_assistant_message === "string" && eventData.last_assistant_message.trim() ? eventData.last_assistant_message : "";
+  const response = inlineAssistant || rollout.response;
+  return {
+    prompt: rollout.prompt,
+    response,
+    chatId: sessionId,
+    source: config.source,
+    modelName: modelName ?? void 0,
+    tokens: rollout.tokens,
+    customData
+  };
+}
+function handleCodexHook(eventName, payloadJson, config, options = {}) {
+  const debugLog4 = options.debugLog ?? noopDebug3;
+  if (!isSupportedCodexEvent(eventName)) {
+    debugLog4("hook-unknown-event", eventName);
+    return null;
+  }
+  if (eventName === "UserPromptSubmit") {
+    debugLog4("user-prompt-submit-dropped", { eventName });
+    return null;
+  }
+  const eventData = payloadJson ?? {};
+  debugLog4("event-parsed", { eventName, eventData });
+  const sessionId = typeof eventData.session_id === "string" ? eventData.session_id : "";
+  let rollout = emptyRollout();
+  if (eventName === "Stop" && sessionId) {
+    rollout = loadRolloutForSession(sessionId, {
+      debugLog: debugLog4,
+      sessionsDir: options.sessionsDir
+    });
+  }
+  const payload = buildCodexPayload(eventName, eventData, config, rollout);
+  if (!payload) return null;
+  if (!payload.prompt && !payload.response) {
+    debugLog4("payload-empty", { eventName, sessionId });
+    return null;
+  }
+  debugLog4("payload-built", payload);
+  return payload;
+}
+
+// src/monitor/plugins/codex/index.ts
+var TOOL_ID2 = "codex";
+function debugLog2(label, data) {
+  if (process.env.OLAKAI_MONITOR_DEBUG !== "1") return;
+  try {
+    const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] codex/${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
+`;
+    fs10.appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function resolveCodexProjectRoot(eventData, fallbackCwd) {
+  const payloadCwd = typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : fallbackCwd;
+  return findConfiguredWorkspace(payloadCwd, [TOOL_ID2]);
+}
+var codexPlugin = {
+  id: TOOL_ID2,
+  displayName: "OpenAI Codex CLI",
+  install(opts) {
+    return installCodex(opts);
+  },
+  uninstall(opts) {
+    return uninstallCodex(opts);
+  },
+  status(opts) {
+    return getCodexStatus(opts);
+  },
+  async handleHook(eventName, payloadJson) {
+    const eventData = payloadJson ?? {};
+    debugLog2("hook-fired", { eventName, hasPayload: payloadJson != null });
+    const projectRoot = resolveCodexProjectRoot(eventData, process.cwd());
+    if (!projectRoot) {
+      debugLog2("config-not-found", {
+        startDir: typeof eventData.cwd === "string" && eventData.cwd.trim() ? eventData.cwd : process.cwd()
+      });
+      return null;
+    }
+    const config = loadCodexConfig(projectRoot);
+    if (!config) {
+      debugLog2("monitor-config-missing", { projectRoot });
+      return null;
+    }
+    const payload = handleCodexHook(eventName, eventData, config, {
+      debugLog: debugLog2
+    });
+    if (!payload) return null;
+    return {
+      payload,
+      transport: {
+        endpoint: config.monitoringEndpoint,
+        apiKey: config.apiKey,
+        projectRoot
+      }
+    };
+  },
+  async detectInstalled(opts) {
+    const projectRoot = opts?.projectRoot ?? process.cwd();
+    try {
+      if (fs10.existsSync(getCodexConfigPath2(projectRoot))) {
+        return true;
+      }
+    } catch {
+    }
+    try {
+      if (fs10.existsSync(getCodexConfigPath())) {
+        return true;
+      }
+      if (fs10.existsSync(getCodexHomeDir())) {
+        return true;
+      }
+    } catch {
+    }
+    return detectCodexBinaryOnPath();
+  }
+};
+function detectCodexBinaryOnPath() {
+  try {
+    const probe = spawnSync3(
+      process.platform === "win32" ? "where" : "which",
+      ["codex"],
+      {
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 1e3
+      }
+    );
+    if (probe.status === 0 && probe.stdout && probe.stdout.toString().trim()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+registerPlugin(codexPlugin);
+
+// src/monitor/plugins/cursor/index.ts
+import * as fs15 from "fs";
+import * as os8 from "os";
+
+// src/monitor/plugins/cursor/install.ts
+import * as fs12 from "fs";
+import * as os5 from "os";
+import * as path12 from "path";
+
+// src/monitor/plugins/cursor/config.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+function getCursorConfigPath(projectRoot) {
+  return getMonitorConfigPath(projectRoot, "cursor");
+}
+function loadCursorConfig(projectRoot) {
+  const filePath = getCursorConfigPath(projectRoot);
+  try {
+    if (!fs11.existsSync(filePath)) return null;
+    const raw = fs11.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCursorConfig(projectRoot, config) {
+  const filePath = getCursorConfigPath(projectRoot);
+  const dir = path10.dirname(filePath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
+  }
+  fs11.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  try {
+    fs11.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function deleteCursorConfig(projectRoot) {
+  const filePath = getCursorConfigPath(projectRoot);
+  if (!fs11.existsSync(filePath)) return false;
+  try {
+    fs11.unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/monitor/plugins/cursor/paths.ts
+import * as os4 from "os";
+import * as path11 from "path";
+var CURSOR_DIR_NAME = ".cursor";
+var CURSOR_HOOKS_FILE = "hooks.json";
+function getCursorUserDir(homeDir = os4.homedir()) {
+  return path11.join(homeDir, CURSOR_DIR_NAME);
+}
+function getCursorHooksPath(homeDir = os4.homedir()) {
+  return path11.join(getCursorUserDir(homeDir), CURSOR_HOOKS_FILE);
+}
+
+// src/monitor/plugins/cursor/hooks-config.ts
+var OLAKAI_HOOK_MARKER3 = "olakai monitor hook --tool cursor";
+var CURSOR_HOOK_DEFINITIONS = {
+  beforeSubmitPrompt: [
+    {
+      command: "olakai monitor hook --tool cursor beforeSubmitPrompt",
+      timeout: 5
+    }
+  ],
+  afterAgentResponse: [
+    {
+      command: "olakai monitor hook --tool cursor afterAgentResponse",
+      timeout: 5
+    }
+  ],
+  sessionEnd: [
+    {
+      command: "olakai monitor hook --tool cursor sessionEnd",
+      timeout: 5
+    }
+  ],
+  stop: [
+    {
+      command: "olakai monitor hook --tool cursor stop",
+      timeout: 5
+    }
+  ]
+};
+var CURSOR_HOOKS_VERSION = 1;
+function mergeCursorHooks(existing, definitions = CURSOR_HOOK_DEFINITIONS) {
+  const base = existing ? { ...existing } : {};
+  if (typeof base.version !== "number") {
+    base.version = CURSOR_HOOKS_VERSION;
+  }
+  const mergedHooks = {
+    ...base.hooks ?? {}
+  };
+  for (const [event, defaultEntries] of Object.entries(definitions)) {
+    const existingEntries = mergedHooks[event] ?? [];
+    const hasOlakaiEntry = existingEntries.some(
+      (e) => typeof e?.command === "string" && e.command.includes(OLAKAI_HOOK_MARKER3)
+    );
+    if (hasOlakaiEntry) {
+      mergedHooks[event] = existingEntries;
+    } else {
+      mergedHooks[event] = [...existingEntries, ...defaultEntries];
+    }
+  }
+  return {
+    ...base,
+    hooks: mergedHooks
+  };
+}
+function removeOlakaiCursorHooks(existing) {
+  const base = existing ? { ...existing } : {};
+  const sourceHooks = base.hooks ?? {};
+  const cleaned = {};
+  for (const [event, entries] of Object.entries(sourceHooks)) {
+    const filtered = entries.filter(
+      (e) => typeof e?.command !== "string" || !e.command.includes(OLAKAI_HOOK_MARKER3)
+    );
+    if (filtered.length > 0) {
+      cleaned[event] = filtered;
+    }
+  }
+  if (Object.keys(cleaned).length > 0) {
+    base.hooks = cleaned;
+  } else {
+    delete base.hooks;
+  }
+  return base;
+}
+function hasOlakaiCursorHooks(config) {
+  if (!config?.hooks) return false;
+  return Object.values(config.hooks).some(
+    (entries) => entries.some(
+      (e) => typeof e?.command === "string" && e.command.includes(OLAKAI_HOOK_MARKER3)
+    )
+  );
+}
+
+// src/monitor/plugins/cursor/install.ts
+var CURSOR_SOURCE = "cursor";
+var CURSOR_AGENT_SOURCE = "CURSOR";
+var CURSOR_AGENT_CATEGORY = "CODING";
+function readJsonFileTolerant(filePath) {
+  try {
+    if (!fs12.existsSync(filePath)) return null;
+    const raw = fs12.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeJsonFileWithDir(filePath, data) {
+  const dir = path12.dirname(filePath);
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
+  }
+  fs12.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+async function installCursor(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os5.homedir();
+  const token = getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run 'olakai login' first.");
+    process.exit(1);
+  }
+  console.log("Setting up Cursor monitoring for this workspace...\n");
+  console.log(
+    "Note: Cursor hooks are installed globally per user (~/.cursor/hooks.json)."
+  );
+  console.log(
+    `Activity from this workspace (${projectRoot}) will be associated with`
+  );
+  console.log("the agent you select below.\n");
+  const agent = await provisionSelfMonitorAgent({
+    projectRoot,
+    source: CURSOR_AGENT_SOURCE,
+    displayName: "Cursor",
+    category: CURSOR_AGENT_CATEGORY
+  });
+  const monitoringEndpoint = `${getBaseUrl()}/api/monitoring/prompt`;
+  const apiKey = agent.apiKey?.key;
+  if (!apiKey) {
+    console.error(
+      "Internal error: agent provisioned but no API key returned. Please re-run 'olakai monitor init'."
+    );
+    process.exit(1);
+  }
+  const cursorDir = getCursorUserDir(homeDir);
+  if (!fs12.existsSync(cursorDir)) {
+    fs12.mkdirSync(cursorDir, { recursive: true });
+  }
+  const hooksPath = getCursorHooksPath(homeDir);
+  const existingHooks = readJsonFileTolerant(hooksPath);
+  const mergedHooks = mergeCursorHooks(existingHooks);
+  writeJsonFileWithDir(hooksPath, mergedHooks);
+  const monitorConfig = {
+    agentId: agent.id,
+    apiKey,
+    agentName: agent.name,
+    source: CURSOR_SOURCE,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    monitoringEndpoint
+  };
+  writeCursorConfig(projectRoot, monitorConfig);
+  const configPath = getCursorConfigPath(projectRoot);
+  const configRel = path12.relative(projectRoot, configPath);
+  const hooksDisplay = `~/${path12.join(CURSOR_DIR_NAME, CURSOR_HOOKS_FILE)}`;
+  console.log("");
+  console.log(`\u2713 Agent "${agent.name}" configured (ID: ${agent.id})`);
+  if (agent.apiKey?.key) {
+    console.log("\u2713 API key generated");
+  }
+  console.log(`\u2713 Cursor hooks installed at ${hooksDisplay}`);
+  console.log(`\u2713 Monitor config saved to ${configRel}`);
+  console.log("");
+  console.log(
+    "Congrats! Monitoring is now active. Restart Cursor for the new hooks to take effect."
+  );
+  console.log("");
+  console.log(
+    `\u26A0 Ensure ${OLAKAI_DIR}/ is in your .gitignore (it contains your API key)`
+  );
+  console.log("");
+  console.log("To check status:  olakai monitor status --tool cursor");
+  console.log("To disable:       olakai monitor disable --tool cursor");
+  return {
+    agentId: agent.id,
+    agentName: agent.name,
+    source: CURSOR_SOURCE,
+    monitoringEndpoint
+  };
+}
+async function uninstallCursor(opts) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const homeDir = opts.homeDir ?? os5.homedir();
+  const hooksPath = getCursorHooksPath(homeDir);
+  const existingHooks = readJsonFileTolerant(hooksPath);
+  if (existingHooks) {
+    const cleaned = removeOlakaiCursorHooks(existingHooks);
+    if (!cleaned.hooks || Object.keys(cleaned.hooks).length === 0) {
+      const otherKeys = Object.keys(cleaned).filter(
+        (k) => k !== "hooks" && k !== "version"
+      );
+      const onlyDefaults = otherKeys.length === 0 && (cleaned.version === 1 || cleaned.version === void 0);
+      if (onlyDefaults) {
+        try {
+          fs12.unlinkSync(hooksPath);
+        } catch {
+        }
+      } else {
+        writeJsonFileWithDir(hooksPath, cleaned);
+      }
+    } else {
+      writeJsonFileWithDir(hooksPath, cleaned);
+    }
+    console.log(
+      `\u2713 Olakai hooks removed from ~/${path12.join(CURSOR_DIR_NAME, CURSOR_HOOKS_FILE)}`
+    );
+  } else {
+    console.log("No Cursor hooks file found.");
+  }
+  if (!opts.keepConfig) {
+    const configPath = getCursorConfigPath(projectRoot);
+    const configRel = path12.relative(projectRoot, configPath);
+    if (deleteCursorConfig(projectRoot)) {
+      console.log(`\u2713 Monitor config removed (${configRel})`);
+    }
+  } else {
+    const configPath = getCursorConfigPath(projectRoot);
+    const configRel = path12.relative(projectRoot, configPath);
+    console.log(`Monitor config retained at ${configRel}`);
+  }
+  console.log("");
+  console.log(
+    "Monitoring disabled. Run 'olakai monitor init --tool cursor' to re-enable."
+  );
+  console.log("Restart Cursor for the change to take effect.");
+}
+
+// src/monitor/plugins/cursor/status.ts
+import * as fs13 from "fs";
+import * as os6 from "os";
+import * as path13 from "path";
+async function getCursorStatus(opts) {
+  const projectRoot = opts?.projectRoot ?? process.cwd();
+  const homeDir = opts?.homeDir ?? os6.homedir();
+  const configPath = getCursorConfigPath(projectRoot);
+  const config = loadCursorConfig(projectRoot);
+  let hooksConfigured = false;
+  const hooksPath = getCursorHooksPath(homeDir);
+  if (fs13.existsSync(hooksPath)) {
+    try {
+      const raw = fs13.readFileSync(hooksPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      hooksConfigured = hasOlakaiCursorHooks(parsed);
+    } catch {
+    }
+  }
+  if (!config) {
+    return {
+      toolId: "cursor",
+      configured: false,
+      hooksConfigured,
+      configPath,
+      notes: hooksConfigured ? [
+        "Cursor hooks installed but no monitor config in this workspace \u2014 run 'olakai monitor init --tool cursor' to associate it with an agent."
+      ] : []
+    };
+  }
+  return {
+    toolId: "cursor",
+    configured: true,
+    hooksConfigured,
+    agentId: config.agentId,
+    agentName: config.agentName,
+    source: config.source,
+    apiKeyMasked: config.apiKey.slice(0, 12) + "...",
+    monitoringEndpoint: config.monitoringEndpoint,
+    configuredAt: config.createdAt,
+    configPath
+  };
+}
+
+// src/monitor/plugins/cursor/hook.ts
+var SUPPORTED_CURSOR_EVENTS = /* @__PURE__ */ new Set([
+  "beforeSubmitPrompt",
+  "afterAgentResponse",
+  "sessionEnd",
+  "stop"
+]);
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value !== "number") return 0;
+  if (!Number.isFinite(value)) return 0;
+  return value;
+}
+function extractCursorTokens(payload) {
+  return {
+    inputTokens: asNumber(payload.input_tokens),
+    outputTokens: asNumber(payload.output_tokens),
+    cacheReadTokens: asNumber(payload.cache_read_tokens),
+    cacheWriteTokens: asNumber(payload.cache_write_tokens)
+  };
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item === "string" && item.trim()) out.push(item);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function extractPromptText(payload) {
+  if (typeof payload.prompt === "string") return payload.prompt;
+  if (payload.prompt && typeof payload.prompt === "object" && typeof payload.prompt.text === "string") {
+    return payload.prompt.text;
+  }
+  return "";
+}
+function extractResponseText(payload) {
+  if (typeof payload.response === "string") return payload.response;
+  if (payload.response && typeof payload.response === "object" && typeof payload.response.text === "string") {
+    return payload.response.text;
+  }
+  if (typeof payload.text === "string") return payload.text;
+  return "";
+}
+function extractAttachments(payload) {
+  if (Array.isArray(payload.attachments)) return payload.attachments;
+  if (payload.prompt && typeof payload.prompt === "object" && Array.isArray(payload.prompt.attachments)) {
+    return payload.prompt.attachments;
+  }
+  return void 0;
+}
+function buildPairedPayload(inputs, config) {
+  const customData = {
+    hookEvent: "afterAgentResponse",
+    conversationId: inputs.conversationId
+  };
+  if (inputs.generationId) customData.generationId = inputs.generationId;
+  if (inputs.cursorVersion) customData.cursorVersion = inputs.cursorVersion;
+  if (inputs.workspaceRoots) customData.workspaceRoots = inputs.workspaceRoots;
+  if (inputs.transcriptPath) customData.transcriptPath = inputs.transcriptPath;
+  if (inputs.attachments && inputs.attachments.length > 0) {
+    customData.attachmentCount = inputs.attachments.length;
+  }
+  if (inputs.userEmail) customData.userEmail = inputs.userEmail;
+  const inputTokens = asNumber(inputs.inputTokens);
+  const outputTokens = asNumber(inputs.outputTokens);
+  const cacheReadTokens = asNumber(inputs.cacheReadTokens);
+  const cacheWriteTokens = asNumber(inputs.cacheWriteTokens);
+  customData.inputTokens = inputTokens;
+  customData.outputTokens = outputTokens;
+  customData.cacheReadTokens = cacheReadTokens;
+  customData.cacheWriteTokens = cacheWriteTokens;
+  if (inputs.unknownFields && Object.keys(inputs.unknownFields).length > 0) {
+    customData.unknownPayloadFields = inputs.unknownFields;
+  }
+  return {
+    prompt: inputs.prompt,
+    response: inputs.response,
+    chatId: inputs.conversationId,
+    source: config.source,
+    modelName: inputs.model,
+    tokens: inputTokens + outputTokens,
+    customData
+  };
+}
+function buildOrphanPayload(inputs, config, reason = "orphan-prompt") {
+  const base = buildPairedPayload({ ...inputs, response: "" }, config);
+  return {
+    ...base,
+    customData: {
+      ...base.customData,
+      hookEvent: "sessionEnd",
+      partial: true,
+      partialReason: reason
+    }
+  };
+}
+var KNOWN_PAYLOAD_KEYS = /* @__PURE__ */ new Set([
+  "event",
+  "conversation_id",
+  "generation_id",
+  "model",
+  "cursor_version",
+  "workspace_roots",
+  "user_email",
+  "transcript_path",
+  "prompt",
+  "response",
+  "text",
+  "attachments",
+  "input_tokens",
+  "output_tokens",
+  "cache_read_tokens",
+  "cache_write_tokens"
+]);
+function collectUnknownFields(payload) {
+  const out = {};
+  for (const key of Object.keys(payload)) {
+    if (!KNOWN_PAYLOAD_KEYS.has(key)) {
+      out[key] = payload[key];
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normalizeEventName(event) {
+  const lower = event.trim();
+  if (!lower) return null;
+  const exact = lower;
+  if (SUPPORTED_CURSOR_EVENTS.has(exact)) return exact;
+  for (const known of SUPPORTED_CURSOR_EVENTS) {
+    if (known.toLowerCase() === lower.toLowerCase()) return known;
+  }
+  return null;
+}
+function extractCursorMeta(payload) {
+  return {
+    conversationId: asString(payload.conversation_id),
+    generationId: asString(payload.generation_id),
+    model: asString(payload.model),
+    cursorVersion: asString(payload.cursor_version),
+    workspaceRoots: asStringArray(payload.workspace_roots),
+    userEmail: asString(payload.user_email),
+    transcriptPath: asString(payload.transcript_path)
+  };
+}
+
+// src/monitor/plugins/cursor/pairing-state.ts
+import * as fs14 from "fs";
+import * as os7 from "os";
+import * as path14 from "path";
+var STATE_DIR_SEGMENTS2 = [".olakai", "cursor-pairings"];
+function getPairingsDir(homeDir) {
+  return path14.join(homeDir, ...STATE_DIR_SEGMENTS2);
+}
+function sanitizeKeyFragment(value) {
+  return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function getPairingKey(conversationId, generationId) {
+  const conv = sanitizeKeyFragment(conversationId);
+  if (!generationId) return conv;
+  return `${conv}__${sanitizeKeyFragment(generationId)}`;
+}
+function getPairingFile(conversationId, generationId, homeDir) {
+  return path14.join(
+    getPairingsDir(homeDir),
+    `${getPairingKey(conversationId, generationId)}.json`
+  );
+}
+function stashPendingPrompt(pending, homeDir = os7.homedir()) {
+  if (!pending.conversationId) return;
+  const dir = getPairingsDir(homeDir);
+  try {
+    if (!fs14.existsSync(dir)) {
+      fs14.mkdirSync(dir, { recursive: true });
+    }
+    const filePath = getPairingFile(
+      pending.conversationId,
+      pending.generationId,
+      homeDir
+    );
+    fs14.writeFileSync(
+      filePath,
+      JSON.stringify(pending, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch {
+  }
+}
+function takePendingPrompt(conversationId, generationId, homeDir = os7.homedir()) {
+  if (!conversationId) return null;
+  const candidates = [];
+  if (generationId) {
+    candidates.push(getPairingFile(conversationId, generationId, homeDir));
+  }
+  candidates.push(getPairingFile(conversationId, void 0, homeDir));
+  for (const filePath of candidates) {
+    let raw;
+    try {
+      if (!fs14.existsSync(filePath)) continue;
+      raw = fs14.readFileSync(filePath, "utf-8");
+    } catch {
+      continue;
+    }
+    try {
+      fs14.unlinkSync(filePath);
+    } catch {
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed.conversationId === "string") {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function listPendingPrompts(homeDir = os7.homedir()) {
+  const dir = getPairingsDir(homeDir);
+  if (!fs14.existsSync(dir)) return [];
+  let files;
+  try {
+    files = fs14.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const result = [];
+  for (const name of files) {
+    if (!name.endsWith(".json")) continue;
+    const filePath = path14.join(dir, name);
+    try {
+      const raw = fs14.readFileSync(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed.conversationId === "string") {
+        result.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return result;
+}
+function clearPendingPrompt(conversationId, generationId, homeDir = os7.homedir()) {
+  if (!conversationId) return;
+  const candidates = [];
+  if (generationId) {
+    candidates.push(getPairingFile(conversationId, generationId, homeDir));
+  }
+  candidates.push(getPairingFile(conversationId, void 0, homeDir));
+  for (const filePath of candidates) {
+    try {
+      if (fs14.existsSync(filePath)) {
+        fs14.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/monitor/plugins/cursor/index.ts
+var TOOL_ID3 = "cursor";
+function debugLog3(label, data) {
+  if (process.env.OLAKAI_MONITOR_DEBUG !== "1") return;
+  try {
+    const logPath = `/tmp/olakai-monitor-debug-${process.pid}.log`;
+    const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] cursor:${label}: ${typeof data === "string" ? data : JSON.stringify(data, null, 2)}
+`;
+    fs15.appendFileSync(logPath, line, "utf-8");
+  } catch {
+  }
+}
+function resolveCursorProjectRoot(payload, fallbackCwd = process.cwd()) {
+  const roots = Array.isArray(payload.workspace_roots) ? payload.workspace_roots.filter(
+    (r) => typeof r === "string" && r.trim().length > 0
+  ) : [];
+  const candidates = roots.length > 0 ? roots : [fallbackCwd];
+  for (const candidate of candidates) {
+    const found = findConfiguredWorkspace(candidate, [TOOL_ID3]);
+    if (found) return found;
+  }
+  return null;
+}
+async function handleCursorHook(eventName, payloadJson, opts = {}) {
+  const event = normalizeEventName(eventName);
+  if (!event) {
+    debugLog3("hook-unknown-event", eventName);
+    return null;
+  }
+  const payload = payloadJson && typeof payloadJson === "object" ? payloadJson : {};
+  debugLog3("event-parsed", { event, payload });
+  const meta = extractCursorMeta(payload);
+  const homeDir = opts.homeDir ?? os8.homedir();
+  switch (event) {
+    case "beforeSubmitPrompt": {
+      if (!meta.conversationId) {
+        debugLog3("missing-conversation-id", { event });
+        return null;
+      }
+      stashPendingPrompt(
+        {
+          prompt: extractPromptText(payload),
+          userEmail: meta.userEmail,
+          model: meta.model,
+          cursorVersion: meta.cursorVersion,
+          conversationId: meta.conversationId,
+          generationId: meta.generationId,
+          workspaceRoots: meta.workspaceRoots,
+          transcriptPath: meta.transcriptPath,
+          attachments: extractAttachments(payload),
+          stashedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          extra: collectUnknownFields(payload)
+        },
+        homeDir
+      );
+      return null;
+    }
+    case "afterAgentResponse": {
+      if (!meta.conversationId) {
+        debugLog3("missing-conversation-id", { event });
+        return null;
+      }
+      const projectRoot = resolveCursorProjectRoot(
+        payload,
+        opts.projectRoot ?? process.cwd()
+      );
+      if (!projectRoot) {
+        debugLog3("config-not-found", {
+          workspaceRoots: meta.workspaceRoots,
+          fallbackCwd: opts.projectRoot ?? process.cwd()
+        });
+        takePendingPrompt(meta.conversationId, meta.generationId, homeDir);
+        return null;
+      }
+      const config = loadCursorConfig(projectRoot);
+      if (!config) {
+        debugLog3("config-load-failed", { projectRoot });
+        takePendingPrompt(meta.conversationId, meta.generationId, homeDir);
+        return null;
+      }
+      const stashed = takePendingPrompt(
+        meta.conversationId,
+        meta.generationId,
+        homeDir
+      );
+      const responseText = extractResponseText(payload);
+      const promptText = stashed?.prompt ?? extractPromptText(payload);
+      const userEmail = meta.userEmail ?? stashed?.userEmail;
+      const model = meta.model ?? stashed?.model;
+      const cursorVersion = meta.cursorVersion ?? stashed?.cursorVersion;
+      const workspaceRoots = meta.workspaceRoots ?? stashed?.workspaceRoots;
+      const transcriptPath = meta.transcriptPath ?? stashed?.transcriptPath;
+      const attachments = extractAttachments(payload) ?? stashed?.attachments;
+      const tokens = extractCursorTokens(payload);
+      const unknownFields = mergeUnknownFields(
+        collectUnknownFields(payload),
+        stashed?.extra
+      );
+      const built = buildPairedPayload(
+        {
+          conversationId: meta.conversationId,
+          generationId: meta.generationId ?? stashed?.generationId,
+          prompt: promptText,
+          response: responseText,
+          userEmail,
+          model,
+          cursorVersion,
+          workspaceRoots,
+          transcriptPath,
+          attachments,
+          inputTokens: tokens.inputTokens,
+          outputTokens: tokens.outputTokens,
+          cacheReadTokens: tokens.cacheReadTokens,
+          cacheWriteTokens: tokens.cacheWriteTokens,
+          unknownFields
+        },
+        config
+      );
+      const finalPayload = userEmail ? { ...built, email: userEmail } : built;
+      debugLog3("payload-built", finalPayload);
+      return {
+        payload: finalPayload,
+        transport: {
+          endpoint: config.monitoringEndpoint,
+          apiKey: config.apiKey,
+          projectRoot
+        }
+      };
+    }
+    case "sessionEnd":
+    case "stop": {
+      const orphan = pickOrphanForFlush(meta.conversationId, homeDir);
+      if (!orphan) return null;
+      const projectRoot = resolveCursorProjectRoot(
+        // Synthesize a payload-like for resolution — orphan carries
+        // the workspace_roots from the stashed beforeSubmitPrompt.
+        {
+          workspace_roots: orphan.workspaceRoots
+        },
+        opts.projectRoot ?? process.cwd()
+      );
+      if (!projectRoot) {
+        debugLog3("orphan-config-not-found", {
+          conversationId: orphan.conversationId
+        });
+        clearPendingPrompt(
+          orphan.conversationId,
+          orphan.generationId,
+          homeDir
+        );
+        return null;
+      }
+      const config = loadCursorConfig(projectRoot);
+      if (!config) {
+        debugLog3("orphan-config-load-failed", { projectRoot });
+        clearPendingPrompt(
+          orphan.conversationId,
+          orphan.generationId,
+          homeDir
+        );
+        return null;
+      }
+      clearPendingPrompt(
+        orphan.conversationId,
+        orphan.generationId,
+        homeDir
+      );
+      const built = buildOrphanPayload(
+        {
+          conversationId: orphan.conversationId,
+          generationId: orphan.generationId,
+          prompt: orphan.prompt,
+          response: "",
+          userEmail: orphan.userEmail,
+          model: orphan.model,
+          cursorVersion: orphan.cursorVersion,
+          workspaceRoots: orphan.workspaceRoots,
+          transcriptPath: orphan.transcriptPath,
+          attachments: orphan.attachments,
+          unknownFields: orphan.extra
+        },
+        config,
+        event === "sessionEnd" ? "session-end" : "orphan-prompt"
+      );
+      const finalPayload = orphan.userEmail ? { ...built, email: orphan.userEmail } : built;
+      return {
+        payload: finalPayload,
+        transport: {
+          endpoint: config.monitoringEndpoint,
+          apiKey: config.apiKey,
+          projectRoot
+        }
+      };
+    }
+  }
+}
+function mergeUnknownFields(primary, fallback) {
+  if (!primary && !fallback) return void 0;
+  return { ...fallback ?? {}, ...primary ?? {} };
+}
+function pickOrphanForFlush(conversationId, homeDir) {
+  const pending = listPendingPrompts(homeDir);
+  if (pending.length === 0) return null;
+  if (conversationId) {
+    const match = pending.find((p) => p.conversationId === conversationId);
+    if (match) return match;
+  }
+  return pending.sort(
+    (a, b) => (a.stashedAt || "").localeCompare(b.stashedAt || "")
+  )[0];
+}
+var cursorPlugin = {
+  id: TOOL_ID3,
+  displayName: "Cursor",
+  install(opts) {
+    return installCursor(opts);
+  },
+  uninstall(opts) {
+    return uninstallCursor(opts);
+  },
+  status(opts) {
+    return getCursorStatus(opts);
+  },
+  handleHook(eventName, payloadJson, opts) {
+    return handleCursorHook(eventName, payloadJson, opts);
+  },
+  async detectInstalled() {
+    try {
+      if (fs15.existsSync(getCursorUserDir())) return true;
+      return whichCursorOnPath();
+    } catch {
+      return false;
+    }
+  }
+};
+function whichCursorOnPath() {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return false;
+  const sep = process.platform === "win32" ? ";" : ":";
+  const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+  for (const dir of pathEnv.split(sep)) {
+    for (const ext of exts) {
+      const candidate = `${dir}/cursor${ext.toLowerCase()}`;
+      try {
+        if (fs15.existsSync(candidate)) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+registerPlugin(cursorPlugin);
+
+// src/monitor/install.ts
+async function runMonitorInstall(toolId, opts = {}) {
+  const plugin = getPlugin(toolId);
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const result = await plugin.install({
+    projectRoot,
+    interactive: opts.interactive ?? true
+  });
+  recordInstall(toolId, projectRoot, result);
+  return result;
+}
+function recordInstall(toolId, projectRoot, result) {
+  try {
+    const entry = {
+      path: projectRoot,
+      tool: toolId,
+      scope: getToolScope(toolId),
+      agentId: result.agentId,
+      agentName: result.agentName,
+      source: result.source,
+      configPath: getMonitorConfigPath(projectRoot, toolId),
+      hooksPath: getToolHooksPath(toolId, projectRoot),
+      monitoringEndpoint: result.monitoringEndpoint,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    upsertEntry(entry);
+  } catch {
+  }
+}
+
+export {
+  promptUser,
+  isInteractive,
+  getCodexHomeDir,
+  getCodexConfigPath,
+  TOOL_IDS,
+  getPlugin,
+  listPlugins,
+  isToolId,
+  loadCodexConfig,
+  writeCodexConfig,
+  installCodexHooksConfig,
+  loadCursorConfig,
+  writeCursorConfig,
+  getCursorHooksPath,
+  mergeCursorHooks,
+  getToolScope,
+  getToolSource,
+  readRegistry,
+  upsertEntry,
+  removeEntry,
+  reconcileCurrentWorkspace,
+  formatRegistryTable,
+  runMonitorInstall
+};
+//# sourceMappingURL=chunk-75YQWZ4Q.js.map