@indigoai-us/hq-cloud 6.0.3 → 6.2.0

package/src/skill-telemetry.test.ts

@@ -2,7 +2,12 @@ import { describe, it, expect } from "vitest";
 import { promises as fs } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { extractSkillEvents, collectAndSendSkillTelemetry } from "./skill-telemetry.js";
+import {
+  extractSkillEvents,
+  extractCodexSkillEvents,
+  parseCodexSessionMeta,
+  collectAndSendSkillTelemetry,
+} from "./skill-telemetry.js";
 import type { SkillInvocationBatch } from "./vault-client.js";
 
 describe("extractSkillEvents", () => {
@@ -96,6 +101,78 @@ describe("extractSkillEvents", () => {
   });
 });
 
+describe("extractCodexSkillEvents (Codex CLI rollouts)", () => {
+  const ctx = { sessionId: "019ea34e-4a2b-7241-b8e3-1023abb57c6b", cwd: "/home/ec2-user/hq" };
+
+  it("extracts a typed slash skill from a user_message, attributing session ctx", () => {
+    const row = {
+      timestamp: "2026-06-07T18:17:57.722Z",
+      type: "event_msg",
+      payload: { type: "user_message", message: "/indigo:hello-world", images: [], local_images: [], text_elements: [] },
+    };
+    expect(extractCodexSkillEvents(row, ctx)).toEqual([
+      {
+        skill: "indigo:hello-world",
+        source: "typed",
+        sessionId: ctx.sessionId,
+        timestamp: "2026-06-07T18:17:57.722Z",
+        cwd: ctx.cwd,
+        uuid: `codex:${ctx.sessionId}:2026-06-07T18:17:57.722Z:indigo:hello-world`,
+        hasArgs: false,
+      },
+    ]);
+  });
+
+  it("sets hasArgs true when the command has trailing args, without leaking them", () => {
+    const row = {
+      timestamp: "2026-06-07T18:18:00.000Z",
+      type: "event_msg",
+      payload: { type: "user_message", message: "/indigo:signals refresh secret-arg-value" },
+    };
+    const ev = extractCodexSkillEvents(row, ctx)[0];
+    expect(ev).toMatchObject({ skill: "indigo:signals", source: "typed", hasArgs: true });
+    expect(JSON.stringify(ev)).not.toContain("secret-arg-value");
+  });
+
+  it("rejects file-path-like and non-command user messages", () => {
+    const mk = (message: string) => ({ type: "event_msg", payload: { type: "user_message", message } });
+    expect(extractCodexSkillEvents(mk("/etc/hosts please read this"), ctx)).toEqual([]);
+    expect(extractCodexSkillEvents(mk("just a normal prompt"), ctx)).toEqual([]);
+    expect(extractCodexSkillEvents(mk(""), ctx)).toEqual([]);
+  });
+
+  it("ignores non-user_message rows (session_meta, lifecycle, assistant)", () => {
+    expect(
+      extractCodexSkillEvents({ type: "session_meta", payload: { id: "x", cwd: "/y" } }, ctx),
+    ).toEqual([]);
+    expect(
+      extractCodexSkillEvents({ type: "event_msg", payload: { type: "task_started" } }, ctx),
+    ).toEqual([]);
+    // The duplicate `response_item` (role:user) Codex also writes must NOT
+    // double-count — only the `event_msg` user_message is the signal.
+    expect(
+      extractCodexSkillEvents(
+        { type: "response_item", payload: { type: "message", role: "user", content: [{ type: "input_text", text: "/indigo:hello-world" }] } },
+        ctx,
+      ),
+    ).toEqual([]);
+    expect(extractCodexSkillEvents(null, ctx)).toEqual([]);
+  });
+
+  it("omits the synthesized uuid when session ctx is missing (safe-fail)", () => {
+    const row = { timestamp: "2026-06-07T18:17:57.722Z", type: "event_msg", payload: { type: "user_message", message: "/deploy" } };
+    expect(extractCodexSkillEvents(row, {})[0]).toMatchObject({ skill: "deploy", source: "typed", uuid: undefined });
+  });
+
+  it("parseCodexSessionMeta reads id + cwd, and returns null for other rows", () => {
+    expect(
+      parseCodexSessionMeta({ type: "session_meta", payload: { id: "sess-x", cwd: "/home/ec2-user/hq", originator: "codex_exec" } }),
+    ).toEqual({ sessionId: "sess-x", cwd: "/home/ec2-user/hq" });
+    expect(parseCodexSessionMeta({ type: "event_msg", payload: {} })).toBeNull();
+    expect(parseCodexSessionMeta(null)).toBeNull();
+  });
+});
+
 describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
   function stubClient(captured: SkillInvocationBatch[]) {
     return {
@@ -146,6 +223,7 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
       installerVersion: "test",
       hqRoot,
       claudeProjectsRoot: projects,
+      codexSessionsRoot: path.join(tmp, "codex"),
       cursorPath: path.join(tmp, "cursor.json"),
     });
 
@@ -172,9 +250,9 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
     const captured: SkillInvocationBatch[] = [];
     const client = stubClient(captured);
 
-    const r1 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    const r1 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
     expect(r1.eventsSent).toBe(1);
-    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
     expect(r2.eventsSent).toBe(0); // cursor at EOF → nothing re-sent
 
     await fs.rm(tmp, { recursive: true, force: true });
@@ -207,11 +285,11 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
       },
     };
 
-    const r1 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    const r1 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
     expect(r1.eventsSent).toBe(0); // post threw → nothing committed
     expect(captured).toHaveLength(0);
 
-    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
     expect(r2.eventsSent).toBe(1); // re-scanned from offset 0 and delivered
     expect(captured.flatMap((b) => b.events.map((e) => e.skill))).toEqual(["deploy"]);
 
@@ -233,7 +311,7 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
     const captured: SkillInvocationBatch[] = [];
     const client = stubClient(captured);
 
-    await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
 
     // New invocation appended after the first clean run.
     await fs.appendFile(
@@ -242,7 +320,7 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
       "utf-8",
     );
 
-    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, cursorPath });
+    const r2 = await collectAndSendSkillTelemetry({ client, machineId: "m", installerVersion: "t", claudeProjectsRoot: projects, codexSessionsRoot: path.join(tmp, "codex"), cursorPath });
     expect(r2.eventsSent).toBe(1);
     // Only the appended event — not the original — is re-sent.
     const lastBatch = captured[captured.length - 1];
@@ -268,6 +346,7 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
       machineId: "m-test",
       installerVersion: "test",
       claudeProjectsRoot: projects,
+      codexSessionsRoot: path.join(tmp, "codex"),
       cursorPath: path.join(tmp, "cursor.json"),
     });
 
@@ -276,4 +355,138 @@ describe("collectAndSendSkillTelemetry — hqRoot scoping", () => {
 
     await fs.rm(tmp, { recursive: true, force: true });
   });
+
+  // ── Codex CLI rollouts ────────────────────────────────────────────────────
+
+  // Build a realistic Codex rollout: a leading session_meta, the environment
+  // boilerplate Codex writes (which must be ignored), then the typed commands.
+  function codexRollout(sessionId: string, cwd: string, messages: string[]): string {
+    const lines = [
+      row({ timestamp: "2026-06-07T18:16:56.480Z", type: "session_meta", payload: { id: sessionId, cwd, originator: "codex_exec", cli_version: "0.137.0", source: "exec" } }),
+      row({ timestamp: "2026-06-07T18:16:56.718Z", type: "response_item", payload: { type: "message", role: "user", content: [{ type: "input_text", text: "<environment_context>\n  <cwd>" + cwd + "</cwd>\n</environment_context>" }] } }),
+      ...messages.flatMap((message, i) => [
+        // Codex writes BOTH a response_item (role:user) and an event_msg for the
+        // same input; only the event_msg must be counted (no double-count).
+        row({ timestamp: `2026-06-07T18:17:0${i}.000Z`, type: "response_item", payload: { type: "message", role: "user", content: [{ type: "input_text", text: message }] } }),
+        row({ timestamp: `2026-06-07T18:17:0${i}.000Z`, type: "event_msg", payload: { type: "user_message", message, images: [], local_images: [], text_elements: [] } }),
+      ]),
+    ];
+    return lines.join("\n") + "\n";
+  }
+
+  it("captures Codex typed slash skills scoped to hqRoot, excluding other cwds + dupes", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "skill-tel-codex-"));
+    const codex = path.join(tmp, "sessions", "2026", "06", "07");
+    await fs.mkdir(codex, { recursive: true });
+    const hqRoot = "/home/ec2-user/hq";
+
+    await fs.writeFile(
+      path.join(codex, "rollout-2026-06-07T18-16-56-aaaa.jsonl"),
+      codexRollout("sess-codex-1", hqRoot, ["/indigo:hello-world", "/indigo:signals refresh"]),
+      "utf-8",
+    );
+    // A second rollout from a different repo — must be excluded by hqRoot scope.
+    await fs.writeFile(
+      path.join(codex, "rollout-2026-06-07T18-20-00-bbbb.jsonl"),
+      codexRollout("sess-codex-2", "/home/ec2-user/other", ["/secret-skill"]),
+      "utf-8",
+    );
+
+    const captured: SkillInvocationBatch[] = [];
+    const result = await collectAndSendSkillTelemetry({
+      client: stubClient(captured),
+      machineId: "m",
+      installerVersion: "t",
+      hqRoot,
+      claudeProjectsRoot: path.join(tmp, "no-claude"),
+      codexSessionsRoot: path.join(tmp, "sessions"),
+      cursorPath: path.join(tmp, "cursor.json"),
+    });
+
+    const events = captured.flatMap((b) => b.events);
+    // No double-count from the duplicate response_item rows.
+    expect(result.eventsSent).toBe(2);
+    expect(events.map((e) => e.skill).sort()).toEqual(["indigo:hello-world", "indigo:signals"]);
+    // Codex invocations are recorded as the typed source.
+    expect(events.every((e) => e.source === "typed")).toBe(true);
+    // The other-repo Codex invocation never leaves the machine.
+    expect(events.map((e) => e.skill)).not.toContain("secret-skill");
+
+    await fs.rm(tmp, { recursive: true, force: true });
+  });
+
+  it("captures Claude and Codex skills together in a single run", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "skill-tel-both-"));
+    const projects = path.join(tmp, "projects", "-home-ec2-user-hq");
+    const codex = path.join(tmp, "sessions", "2026", "06", "07");
+    await fs.mkdir(projects, { recursive: true });
+    await fs.mkdir(codex, { recursive: true });
+    const hqRoot = "/home/ec2-user/hq";
+
+    await fs.writeFile(
+      path.join(projects, "a.jsonl"),
+      row({ type: "assistant", sessionId: "s1", timestamp: "2026-06-07T10:00:00Z", cwd: hqRoot, message: { role: "assistant", content: [{ type: "tool_use", id: "t1", name: "Skill", input: { skill: "indigo:crm-management" } }] } }) + "\n",
+      "utf-8",
+    );
+    await fs.writeFile(
+      path.join(codex, "rollout-x.jsonl"),
+      codexRollout("sess-codex-1", hqRoot, ["/indigo:hello-world"]),
+      "utf-8",
+    );
+
+    const captured: SkillInvocationBatch[] = [];
+    const result = await collectAndSendSkillTelemetry({
+      client: stubClient(captured),
+      machineId: "m",
+      installerVersion: "t",
+      hqRoot,
+      claudeProjectsRoot: path.join(tmp, "projects"),
+      codexSessionsRoot: path.join(tmp, "sessions"),
+      cursorPath: path.join(tmp, "cursor.json"),
+    });
+
+    expect(result.eventsSent).toBe(2);
+    const events = captured.flatMap((b) => b.events);
+    expect(events.find((e) => e.skill === "indigo:crm-management")?.source).toBe("model");
+    expect(events.find((e) => e.skill === "indigo:hello-world")?.source).toBe("typed");
+
+    await fs.rm(tmp, { recursive: true, force: true });
+  });
+
+  it("reads Codex session ctx from the top on an incremental (cursor mid-file) run", async () => {
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "skill-tel-incr-"));
+    const codex = path.join(tmp, "sessions", "2026", "06", "07");
+    await fs.mkdir(codex, { recursive: true });
+    const hqRoot = "/home/ec2-user/hq";
+    const file = path.join(codex, "rollout-incr.jsonl");
+
+    await fs.writeFile(file, codexRollout("sess-incr", hqRoot, ["/indigo:hello-world"]), "utf-8");
+    const cursorPath = path.join(tmp, "cursor.json");
+    const captured: SkillInvocationBatch[] = [];
+    const client = stubClient(captured);
+    const base = { client, machineId: "m", installerVersion: "t", hqRoot, claudeProjectsRoot: path.join(tmp, "no-claude"), codexSessionsRoot: path.join(tmp, "sessions"), cursorPath };
+
+    const r1 = await collectAndSendSkillTelemetry(base);
+    expect(r1.eventsSent).toBe(1);
+
+    // Append a new typed command AFTER the session_meta line. The cursor now
+    // sits mid-file, so the new event's cwd/sessionId must still come from the
+    // session_meta at the top — proving readCodexSessionContext reads offset 0.
+    await fs.appendFile(
+      file,
+      row({ timestamp: "2026-06-07T18:30:00.000Z", type: "event_msg", payload: { type: "user_message", message: "/indigo:action-items" } }) + "\n",
+      "utf-8",
+    );
+
+    const r2 = await collectAndSendSkillTelemetry(base);
+    expect(r2.eventsSent).toBe(1);
+    const last = captured[captured.length - 1].events[0];
+    expect(last.skill).toBe("indigo:action-items");
+    // cwd survived → it passed the hqRoot scope filter (would be dropped if the
+    // session_meta weren't re-read from the top on this mid-file run).
+    expect(last.cwd).toBe(hqRoot);
+    expect(last.sessionId).toBe("sess-incr");
+
+    await fs.rm(tmp, { recursive: true, force: true });
+  });
 });

package/src/skill-telemetry.ts

@@ -23,6 +23,15 @@
  *     `name === "Skill"` and `input.skill` names the skill.
  * The two are mutually exclusive per invocation, so there is no double-count.
  *
+ * Codex CLI is captured too, from its own rollout logs at
+ * `~/.codex/sessions/YYYY/MM/DD/rollout-<ISO>-<uuid>.jsonl`. Codex records cwd +
+ * sessionId ONCE in a leading `session_meta` line (not on every row), and a
+ * typed slash command — including an HQ skill, e.g. `/indigo:hello-world` — is
+ * logged verbatim as a later `event_msg` `user_message` (Codex does not expand
+ * it). That parallels Claude's typed path exactly; Codex has no discrete "skill
+ * tool_use" event, so only the typed source is captured for it. Both runtimes
+ * funnel into the same wire shape, scope filter, batcher, and per-file cursor.
+ *
  * Privacy: raw `<command-args>` / `input.args` content is NEVER sent to the
  * cloud — only a `hasArgs` boolean. This matches the message-stripping posture
  * of `./telemetry.ts::sanitizeRow`, which deliberately drops all prompt/tool
@@ -68,6 +77,8 @@ export interface CollectSkillTelemetryOptions {
   hqRoot?: string;
   /** Override `~/.claude/projects` for tests. */
   claudeProjectsRoot?: string;
+  /** Override `~/.codex/sessions` (the Codex CLI rollout root) for tests. */
+  codexSessionsRoot?: string;
   /** Override `~/.hq/skill-telemetry-cursor.json` for tests. */
   cursorPath?: string;
   /** Override `~/.hq/menubar.json` (the offline opt-in fallback) for tests. */
@@ -230,6 +241,74 @@ export function extractSkillEvents(row: unknown): SkillEvent[] {
   return [];
 }
 
+// ── Codex rollout extractor ───────────────────────────────────────────────────
+
+/** Match a leading slash command in a Codex `user_message`: a single token
+ *  (no internal "/", so file paths like "/etc/hosts" are rejected) optionally
+ *  followed by whitespace + args. Group 1 = skill/command, group 2 = args. */
+const CODEX_CMD = /^\/([^/\s]+)(?:\s+([\s\S]*))?$/;
+
+/** Parse cwd + sessionId from a Codex `session_meta` rollout line. Returns null
+ *  for any other line type. */
+export function parseCodexSessionMeta(
+  row: unknown,
+): { sessionId?: string; cwd?: string } | null {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return null;
+  const obj = row as Record<string, unknown>;
+  if (obj.type !== "session_meta") return null;
+  const payload =
+    obj.payload && typeof obj.payload === "object" && !Array.isArray(obj.payload)
+      ? (obj.payload as Record<string, unknown>)
+      : {};
+  const sessionId = typeof payload.id === "string" ? payload.id : undefined;
+  const cwd = typeof payload.cwd === "string" ? payload.cwd : undefined;
+  return { sessionId, cwd };
+}
+
+/**
+ * Extract a typed skill/slash-command invocation from a Codex `event_msg`
+ * `user_message` row. Session context (cwd, sessionId) lives in the file's
+ * leading `session_meta` line and is threaded in via `ctx`. Returns 0 or 1
+ * event (a Codex user_message carries at most one command).
+ */
+export function extractCodexSkillEvents(
+  row: unknown,
+  ctx: { sessionId?: string; cwd?: string },
+): SkillEvent[] {
+  if (!row || typeof row !== "object" || Array.isArray(row)) return [];
+  const obj = row as Record<string, unknown>;
+  if (obj.type !== "event_msg") return [];
+  const payload =
+    obj.payload && typeof obj.payload === "object" && !Array.isArray(obj.payload)
+      ? (obj.payload as Record<string, unknown>)
+      : undefined;
+  if (!payload || payload.type !== "user_message") return [];
+  const message = typeof payload.message === "string" ? payload.message : "";
+  const m = CODEX_CMD.exec(message.trim());
+  if (!m) return [];
+  const skill = m[1].trim();
+  if (!skill) return [];
+  const timestamp = typeof obj.timestamp === "string" ? obj.timestamp : undefined;
+  // Codex events carry no per-event id, so synthesize a stable, content-derived
+  // uuid (sessionId + timestamp + skill are unique per invocation) for
+  // idempotent re-delivery — the server dedups on the composite eventKey.
+  const uuid =
+    ctx.sessionId !== undefined && timestamp !== undefined
+      ? `codex:${ctx.sessionId}:${timestamp}:${skill}`
+      : undefined;
+  return [
+    {
+      skill,
+      source: "typed",
+      sessionId: ctx.sessionId,
+      timestamp,
+      cwd: ctx.cwd,
+      uuid,
+      hasArgs: Boolean(m[2] && m[2].trim()),
+    },
+  ];
+}
+
 /** Shape the event for the wire. Drops raw args unless explicitly enabled. */
 function toWireRow(ev: SkillEvent): Record<string, unknown> {
   const row: Record<string, unknown> = {
@@ -273,6 +352,34 @@ async function listJsonlFiles(root: string): Promise<string[]> {
   return out;
 }
 
+// Codex's `session_meta` is always the first, small line of a rollout. Read a
+// bounded prefix from the top so a mid-file (cursor-resumed) scan still has
+// session context without slurping a multi-MiB transcript.
+const CODEX_META_PREFIX_BYTES = 64 * 1024;
+
+/** Read cwd + sessionId from a Codex rollout's leading `session_meta` line.
+ *  Always reads from offset 0 (independent of the byte cursor). Best-effort:
+ *  any error → empty context (events then fail the hqRoot scope filter, which
+ *  is the safe default). */
+async function readCodexSessionContext(
+  filePath: string,
+): Promise<{ sessionId?: string; cwd?: string }> {
+  try {
+    const fh = await fs.open(filePath, "r");
+    try {
+      const buf = Buffer.alloc(CODEX_META_PREFIX_BYTES);
+      const { bytesRead } = await fh.read(buf, 0, CODEX_META_PREFIX_BYTES, 0);
+      const firstLine = buf.toString("utf-8", 0, bytesRead).split("\n", 1)[0]?.trim();
+      if (!firstLine) return {};
+      return parseCodexSessionMeta(JSON.parse(firstLine)) ?? {};
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return {};
+  }
+}
+
 const MAX_BATCH_BYTES = 1_000_000;
 
 // ── Main entry point ──────────────────────────────────────────────────────────
@@ -301,6 +408,8 @@ export async function collectAndSendSkillTelemetry(
   const home = os.homedir();
   const claudeProjectsRoot =
     opts.claudeProjectsRoot ?? path.join(home, ".claude", "projects");
+  const codexSessionsRoot =
+    opts.codexSessionsRoot ?? path.join(home, ".codex", "sessions");
   const cursorPath =
     opts.cursorPath ?? path.join(home, ".hq", "skill-telemetry-cursor.json");
   const menubarPath = opts.menubarPath ?? path.join(home, ".hq", "menubar.json");
@@ -327,9 +436,16 @@ export async function collectAndSendSkillTelemetry(
     return { enabled: false, optInSource, filesScanned: 0, eventsSent: 0, batchesSent: 0 };
   }
 
-  // 2. Cursor + file enumeration.
+  // 2. Cursor + file enumeration. Both runtimes share one cursor (keyed by
+  //    absolute path — the roots never collide) and one batcher. Each file is
+  //    tagged with its runtime so the scan picks the right line extractor.
   const cursor = await loadCursor(cursorPath);
-  const files = await listJsonlFiles(claudeProjectsRoot);
+  const claudeFiles = await listJsonlFiles(claudeProjectsRoot);
+  const codexFiles = await listJsonlFiles(codexSessionsRoot);
+  const files: { filePath: string; kind: "claude" | "codex" }[] = [
+    ...claudeFiles.map((f) => ({ filePath: f, kind: "claude" as const })),
+    ...codexFiles.map((f) => ({ filePath: f, kind: "codex" as const })),
+  ];
 
   // 3. Scan every file from its stored offset, collecting events tagged with
   //    the byte offset of the line they came from (for per-batch commit).
@@ -348,7 +464,7 @@ export async function collectAndSendSkillTelemetry(
   const rotationResets: Record<string, CursorEntry> = {};
   const sourced: Sourced[] = [];
 
-  for (const filePath of files) {
+  for (const { filePath, kind } of files) {
     let stat;
     try {
       stat = await fs.stat(filePath);
@@ -392,6 +508,11 @@ export async function collectAndSendSkillTelemetry(
       continue;
     }
 
+    // Codex events lack per-row cwd/sessionId — they live in the file's leading
+    // `session_meta` line, which we read from the top regardless of the cursor.
+    const codexCtx =
+      kind === "codex" ? await readCodexSessionContext(filePath) : undefined;
+
     // Compute the absolute end-byte offset of each line in the read region.
     const segments = content.split("\n");
     let cumulative = offset;
@@ -408,7 +529,11 @@ export async function collectAndSendSkillTelemetry(
       } catch {
         continue;
       }
-      for (const ev of extractSkillEvents(parsed)) {
+      const events =
+        kind === "codex"
+          ? extractCodexSkillEvents(parsed, codexCtx ?? {})
+          : extractSkillEvents(parsed);
+      for (const ev of events) {
         // Scope filter: only emit invocations made from the HQ project.
         if (scopeCwd !== undefined && (ev.cwd === undefined || normalizePath(ev.cwd) !== scopeCwd)) {
           continue;