@rulemetric/cli 0.2.1 → 0.2.3

package/dist/chunk-B5KNTGMJ.js

@@ -0,0 +1,1788 @@
+import {
+  __require
+} from "./chunk-NSBPE2FW.js";
+
+// ../../packages/session/dist/types.js
+var SESSION_TOOLS = ["claude_code", "cursor", "vscode_copilot", "copilot_agent", "rulemetric_mcp", "codex", "pi", "opencode", "antigravity"];
+var SESSION_EVENT_TYPES = [
+  "user_message",
+  "assistant_message",
+  "tool_call",
+  "tool_result",
+  "thinking",
+  "error"
+];
+
+// ../../packages/session/dist/adapters/claude-code.js
+var ClaudeCodeAdapter = class {
+  tool = "claude_code";
+  parse(input) {
+    const lines = input.split("\n").filter((line) => line.trim());
+    const records = [];
+    for (const line of lines) {
+      try {
+        records.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    const messageRecords = records.filter((r) => r.type === "user" || r.type === "assistant");
+    let projectPath = null;
+    let gitBranch = null;
+    const metadata = {};
+    const firstUser = records.find((r) => r.type === "user");
+    if (firstUser) {
+      projectPath = firstUser.cwd ?? null;
+      gitBranch = firstUser.gitBranch ?? null;
+      if (firstUser.version)
+        metadata.claudeCodeVersion = firstUser.version;
+      if (firstUser.sessionId)
+        metadata.sessionId = firstUser.sessionId;
+    }
+    const firstAssistant = records.find((r) => r.type === "assistant");
+    if (firstAssistant?.message?.model)
+      metadata.model = firstAssistant.message.model;
+    const events = [];
+    let sequence = 0;
+    for (const record of messageRecords) {
+      const timestamp = record.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+      if (record.type === "user") {
+        const messageContent = record.message?.content;
+        if (typeof messageContent === "string") {
+          events.push({
+            sequence: sequence++,
+            eventType: "user_message",
+            content: messageContent,
+            toolName: null,
+            toolInput: null,
+            toolOutput: null,
+            tokenUsage: null,
+            timestamp,
+            metadata: {}
+          });
+        } else if (Array.isArray(messageContent)) {
+          for (const block of messageContent) {
+            if (block.type === "tool_result") {
+              events.push({
+                sequence: sequence++,
+                eventType: "tool_result",
+                content: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+                toolName: null,
+                toolInput: null,
+                toolOutput: null,
+                tokenUsage: null,
+                timestamp,
+                metadata: { toolUseId: block.tool_use_id }
+              });
+            }
+          }
+        }
+      } else if (record.type === "assistant") {
+        const contentBlocks = Array.isArray(record.message?.content) ? record.message.content : [];
+        const usage = record.message?.usage;
+        const tokenUsage = usage ? {
+          input: usage.input_tokens ?? 0,
+          output: usage.output_tokens ?? 0,
+          cacheRead: usage.cache_read_input_tokens ?? 0,
+          cacheWrite: usage.cache_creation_input_tokens ?? 0
+        } : null;
+        const assistantMeta = {};
+        if (record.message?.model)
+          assistantMeta.model = record.message.model;
+        if (record.message?.stop_reason)
+          assistantMeta.stopReason = record.message.stop_reason;
+        if (record.requestId)
+          assistantMeta.requestId = record.requestId;
+        if (usage?.service_tier)
+          assistantMeta.serviceTier = usage.service_tier;
+        if (usage?.speed)
+          assistantMeta.speed = usage.speed;
+        if (usage?.cache_creation)
+          assistantMeta.cacheCreationDetail = usage.cache_creation;
+        if (usage?.server_tool_use)
+          assistantMeta.serverToolUse = usage.server_tool_use;
+        for (const block of contentBlocks) {
+          if (block.type === "text") {
+            events.push({
+              sequence: sequence++,
+              eventType: "assistant_message",
+              content: block.text ?? "",
+              toolName: null,
+              toolInput: null,
+              toolOutput: null,
+              tokenUsage,
+              timestamp,
+              metadata: assistantMeta
+            });
+          } else if (block.type === "thinking") {
+            events.push({
+              sequence: sequence++,
+              eventType: "thinking",
+              content: block.thinking ?? "",
+              toolName: null,
+              toolInput: null,
+              toolOutput: null,
+              tokenUsage,
+              timestamp,
+              metadata: assistantMeta
+            });
+          } else if (block.type === "tool_use") {
+            events.push({
+              sequence: sequence++,
+              eventType: "tool_call",
+              content: null,
+              toolName: block.name ?? "unknown",
+              toolInput: block.input ?? null,
+              toolOutput: null,
+              tokenUsage,
+              timestamp,
+              metadata: { ...assistantMeta, toolUseId: block.id }
+            });
+          }
+        }
+      }
+    }
+    const timestamps = events.map((e) => e.timestamp).sort();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      tool: "claude_code",
+      projectPath,
+      gitBranch,
+      startedAt: timestamps[0] ?? now,
+      endedAt: timestamps[timestamps.length - 1] ?? null,
+      events,
+      metadata
+    };
+  }
+};
+
+// ../../packages/session/dist/adapters/cursor.js
+var CursorAdapter = class {
+  tool = "cursor";
+  /**
+   * Parse from a SQLite database file path.
+   * Reads `composer.composerData` from the ItemTable.
+   */
+  parse(dbPath) {
+    const Database = __require("better-sqlite3");
+    const db = new Database(dbPath, { readonly: true });
+    try {
+      const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
+      if (!row) {
+        return this.emptySession();
+      }
+      return this.parseComposerJson(row.value);
+    } finally {
+      db.close();
+    }
+  }
+  /**
+   * Parse from raw composer data JSON (for testing without SQLite).
+   */
+  parseComposerJson(json) {
+    let data;
+    try {
+      data = JSON.parse(json);
+    } catch {
+      return this.emptySession();
+    }
+    const composers = Object.values(data.allComposers ?? {});
+    if (composers.length === 0) {
+      return this.emptySession();
+    }
+    const composer = composers.sort((a, b) => {
+      const aTime = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+      const bTime = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+      return bTime - aTime;
+    })[0];
+    const bubbles = composer.conversation ?? [];
+    const events = [];
+    for (let i = 0; i < bubbles.length; i++) {
+      const bubble = bubbles[i];
+      const timestamp = bubble.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      events.push({
+        sequence: i,
+        eventType: bubble.type === 1 ? "user_message" : "assistant_message",
+        content: bubble.text,
+        toolName: null,
+        toolInput: null,
+        toolOutput: null,
+        tokenUsage: null,
+        timestamp,
+        metadata: {}
+      });
+    }
+    const timestamps = events.map((e) => e.timestamp).sort();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      tool: "cursor",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: timestamps[0] ?? now,
+      endedAt: timestamps[timestamps.length - 1] ?? null,
+      events,
+      metadata: { composerId: composer.composerId }
+    };
+  }
+  emptySession() {
+    return {
+      tool: "cursor",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      events: [],
+      metadata: {}
+    };
+  }
+};
+
+// ../../packages/session/dist/adapters/vscode-copilot.js
+var VSCodeCopilotAdapter = class {
+  tool = "vscode_copilot";
+  parse(input) {
+    let data;
+    try {
+      data = JSON.parse(input);
+    } catch {
+      return this.emptySession();
+    }
+    const requests = data.requests ?? [];
+    const events = [];
+    let sequence = 0;
+    for (const req of requests) {
+      const userTimestamp = req.timestamp ? new Date(req.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      events.push({
+        sequence: sequence++,
+        eventType: "user_message",
+        content: req.message,
+        toolName: null,
+        toolInput: null,
+        toolOutput: null,
+        tokenUsage: null,
+        timestamp: userTimestamp,
+        metadata: {}
+      });
+      if (req.response) {
+        const assistantTimestamp = req.response.timestamp ? new Date(req.response.timestamp).toISOString() : userTimestamp;
+        events.push({
+          sequence: sequence++,
+          eventType: "assistant_message",
+          content: req.response.message,
+          toolName: null,
+          toolInput: null,
+          toolOutput: null,
+          tokenUsage: null,
+          timestamp: assistantTimestamp,
+          metadata: {}
+        });
+      }
+    }
+    const timestamps = events.map((e) => e.timestamp).sort();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      tool: "vscode_copilot",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: timestamps[0] ?? now,
+      endedAt: timestamps[timestamps.length - 1] ?? null,
+      events,
+      metadata: {
+        ...data.requesterUsername && { username: data.requesterUsername },
+        ...data.customTitle && { title: data.customTitle }
+      }
+    };
+  }
+  emptySession() {
+    return {
+      tool: "vscode_copilot",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      events: [],
+      metadata: {}
+    };
+  }
+};
+
+// ../../packages/session/dist/adapters/copilot-agent.js
+var CopilotAgentAdapter = class {
+  tool = "copilot_agent";
+  parse(input) {
+    let data;
+    try {
+      data = JSON.parse(input);
+    } catch {
+      return this.emptySession();
+    }
+    const requests = data.requests ?? [];
+    const events = [];
+    let sequence = 0;
+    for (const req of requests) {
+      const userTimestamp = req.timestamp ? new Date(req.timestamp).toISOString() : (/* @__PURE__ */ new Date()).toISOString();
+      events.push({
+        sequence: sequence++,
+        eventType: "user_message",
+        content: req.message,
+        toolName: null,
+        toolInput: null,
+        toolOutput: null,
+        tokenUsage: null,
+        timestamp: userTimestamp,
+        metadata: {}
+      });
+      if (req.toolCalls) {
+        for (const tc of req.toolCalls) {
+          const toolTimestamp = tc.timestamp ? new Date(tc.timestamp).toISOString() : userTimestamp;
+          events.push({
+            sequence: sequence++,
+            eventType: "tool_call",
+            content: null,
+            toolName: tc.name ?? "unknown",
+            toolInput: tc.input ?? null,
+            toolOutput: tc.output ?? null,
+            tokenUsage: null,
+            timestamp: toolTimestamp,
+            metadata: {}
+          });
+        }
+      }
+      if (req.response) {
+        const assistantTimestamp = req.response.timestamp ? new Date(req.response.timestamp).toISOString() : userTimestamp;
+        events.push({
+          sequence: sequence++,
+          eventType: "assistant_message",
+          content: req.response.message,
+          toolName: null,
+          toolInput: null,
+          toolOutput: null,
+          tokenUsage: null,
+          timestamp: assistantTimestamp,
+          metadata: {}
+        });
+      }
+    }
+    const timestamps = events.map((e) => e.timestamp).sort();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      tool: "copilot_agent",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: timestamps[0] ?? now,
+      endedAt: timestamps[timestamps.length - 1] ?? null,
+      events,
+      metadata: {
+        ...data.requesterUsername && { username: data.requesterUsername },
+        ...data.customTitle && { title: data.customTitle },
+        ...data.agentMode != null && { agentMode: data.agentMode }
+      }
+    };
+  }
+  emptySession() {
+    return {
+      tool: "copilot_agent",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      events: [],
+      metadata: {}
+    };
+  }
+};
+
+// ../../packages/session/dist/adapters/rulemetric-mcp.js
+var RuleMetricMcpAdapter = class {
+  tool = "rulemetric_mcp";
+  parse(input) {
+    let data;
+    try {
+      data = JSON.parse(input);
+    } catch {
+      return this.emptySession();
+    }
+    const rawEvents = data.events ?? [];
+    const events = rawEvents.map((e, i) => ({
+      sequence: e.sequence ?? i,
+      eventType: this.normalizeEventType(e.eventType),
+      content: e.content ?? null,
+      toolName: e.toolName ?? null,
+      toolInput: e.toolInput ?? null,
+      toolOutput: e.toolOutput ?? null,
+      tokenUsage: e.tokenUsage ?? null,
+      timestamp: e.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: e.metadata ?? {}
+    }));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      tool: "rulemetric_mcp",
+      projectPath: data.projectPath ?? null,
+      gitBranch: data.gitBranch ?? null,
+      startedAt: data.startedAt ?? events[0]?.timestamp ?? now,
+      endedAt: data.endedAt ?? events[events.length - 1]?.timestamp ?? null,
+      events,
+      metadata: data.metadata ?? {}
+    };
+  }
+  normalizeEventType(type) {
+    const valid = ["user_message", "assistant_message", "tool_call", "tool_result", "thinking", "error"];
+    if (type && valid.includes(type))
+      return type;
+    return "assistant_message";
+  }
+  emptySession() {
+    return {
+      tool: "rulemetric_mcp",
+      projectPath: null,
+      gitBranch: null,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      endedAt: null,
+      events: [],
+      metadata: {}
+    };
+  }
+};
+
+// ../../packages/session/dist/registry.js
+var adapters = {
+  claude_code: () => new ClaudeCodeAdapter(),
+  cursor: () => new CursorAdapter(),
+  vscode_copilot: () => new VSCodeCopilotAdapter(),
+  copilot_agent: () => new CopilotAgentAdapter(),
+  rulemetric_mcp: () => new RuleMetricMcpAdapter()
+};
+function getAdapter(tool) {
+  const factory = adapters[tool];
+  if (!factory) {
+    throw new Error(`Unknown session tool: ${tool}`);
+  }
+  return factory();
+}
+function detectTool(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("{")) {
+    const firstLine = trimmed.split("\n")[0];
+    let parsed = null;
+    try {
+      parsed = JSON.parse(firstLine);
+    } catch {
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+      }
+    }
+    if (parsed) {
+      if (parsed.type === "user" || parsed.type === "assistant") {
+        return "claude_code";
+      }
+      if (Array.isArray(parsed.events) && !parsed.requests && !parsed.allComposers) {
+        return "rulemetric_mcp";
+      }
+      if (Array.isArray(parsed.requests)) {
+        const hasToolCalls = parsed.requests.some((r) => Array.isArray(r.toolCalls));
+        if (hasToolCalls || parsed.agentMode) {
+          return "copilot_agent";
+        }
+        return "vscode_copilot";
+      }
+      if (parsed.allComposers) {
+        return "cursor";
+      }
+    }
+    if (!parsed) {
+      try {
+        const lines = trimmed.split("\n").filter((l) => l.trim());
+        if (lines.length > 1) {
+          const first = JSON.parse(lines[0]);
+          if (first.type === "user" || first.type === "assistant") {
+            return "claude_code";
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+
+// ../../packages/session/dist/analyzer.js
+function buildAnalysisPrompt(events, instructions) {
+  const instructionSection = instructions.length > 0 ? instructions.map((i) => `### ${i.name} (ID: ${i.id})
+
+${i.content}`).join("\n\n---\n\n") : "No instructions were linked to this session.";
+  const eventSummary = events.map((e) => {
+    const prefix = `[${e.sequence}] ${e.eventType}`;
+    if (e.eventType === "tool_call") {
+      return `${prefix}: ${e.toolName}(${JSON.stringify(e.toolInput)})`;
+    }
+    if (e.eventType === "tool_result") {
+      const preview2 = e.content?.slice(0, 200) ?? "";
+      return `${prefix}: ${preview2}${e.content && e.content.length > 200 ? "..." : ""}`;
+    }
+    const preview = e.content?.slice(0, 300) ?? "";
+    return `${prefix}: ${preview}${e.content && e.content.length > 300 ? "..." : ""}`;
+  }).join("\n");
+  return `You are analyzing an AI coding session to evaluate how well the agent followed its instructions and to suggest improvements.
+
+## Active Instructions
+
+${instructionSection}
+
+## Session Transcript
+
+${eventSummary}
+
+## Analysis Tasks
+
+1. **Adherence Score** (0-100): Rate how well the agent followed each active instruction. 100 = perfect adherence.
+2. **Deviations**: List specific events where the agent deviated from instructions. Each deviation needs:
+   - eventSequence: the event number
+   - instructionId: which instruction was violated
+   - description: what went wrong
+   - severity: "low", "medium", or "high"
+3. **Suggestions**: For each gap or deviation, propose a specific edit to the instruction. Each suggestion needs:
+   - instructionId: which instruction to improve
+   - currentContent: the relevant excerpt from the instruction
+   - suggestedContent: your proposed replacement text
+   - rationale: why this change would help
+   - confidence: 0-100 how confident you are this would improve outcomes
+4. **Summary**: One paragraph summarizing the session quality.
+
+Return your response as JSON matching this schema:
+{
+  "adherenceScore": <number 0-100>,
+  "deviations": [{ "eventSequence": <number>, "instructionId": "<string>", "description": "<string>", "severity": "<low|medium|high>" }],
+  "suggestions": [{ "instructionId": "<string>", "currentContent": "<string>", "suggestedContent": "<string>", "rationale": "<string>", "confidence": <number 0-100> }],
+  "summary": "<string>"
+}
+
+Return valid JSON only.`;
+}
+function parseAnalysisResponse(response) {
+  try {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch)
+      return null;
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (typeof parsed.adherenceScore !== "number" || !Array.isArray(parsed.deviations) || !Array.isArray(parsed.suggestions) || typeof parsed.summary !== "string") {
+      return null;
+    }
+    return {
+      adherenceScore: parsed.adherenceScore,
+      deviations: parsed.deviations,
+      suggestions: parsed.suggestions,
+      summary: parsed.summary,
+      analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ../../packages/session/dist/providers/claude-code.js
+import { readdir, stat } from "fs/promises";
+import { basename, join } from "path";
+import { homedir } from "os";
+var shortNames = {
+  "claude-opus-4-7": "Opus 4.7",
+  "claude-opus-4-6": "Opus 4.6",
+  "claude-opus-4-5": "Opus 4.5",
+  "claude-opus-4-1": "Opus 4.1",
+  "claude-opus-4": "Opus 4",
+  "claude-sonnet-4-6": "Sonnet 4.6",
+  "claude-sonnet-4-5": "Sonnet 4.5",
+  "claude-sonnet-4": "Sonnet 4",
+  "claude-3-7-sonnet": "Sonnet 3.7",
+  "claude-3-5-sonnet": "Sonnet 3.5",
+  "claude-haiku-4-5": "Haiku 4.5",
+  "claude-3-5-haiku": "Haiku 3.5"
+};
+function getClaudeDir() {
+  return process.env["CLAUDE_CONFIG_DIR"] || join(homedir(), ".claude");
+}
+function getProjectsDir() {
+  return join(getClaudeDir(), "projects");
+}
+function getDesktopSessionsDir() {
+  if (process.platform === "darwin")
+    return join(homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+  if (process.platform === "win32")
+    return join(homedir(), "AppData", "Roaming", "Claude", "local-agent-mode-sessions");
+  return join(homedir(), ".config", "Claude", "local-agent-mode-sessions");
+}
+async function findDesktopProjectDirs(base) {
+  const results = [];
+  async function walk(dir, depth) {
+    if (depth > 8)
+      return;
+    const entries = await readdir(dir).catch(() => []);
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === ".git")
+        continue;
+      const full = join(dir, entry);
+      const s = await stat(full).catch(() => null);
+      if (!s?.isDirectory())
+        continue;
+      if (entry === "projects") {
+        const projectDirs = await readdir(full).catch(() => []);
+        for (const pd of projectDirs) {
+          const pdFull = join(full, pd);
+          const pdStat = await stat(pdFull).catch(() => null);
+          if (pdStat?.isDirectory())
+            results.push(pdFull);
+        }
+      } else {
+        await walk(full, depth + 1);
+      }
+    }
+  }
+  await walk(base, 0);
+  return results;
+}
+var claudeCode = {
+  name: "claude",
+  displayName: "Claude Code",
+  modelDisplayName(model) {
+    const canonical = model.replace(/@.*$/, "").replace(/-\d{8}$/, "");
+    for (const [key, name] of Object.entries(shortNames)) {
+      if (canonical.startsWith(key))
+        return name;
+    }
+    return canonical;
+  },
+  toolDisplayName(rawTool) {
+    return rawTool;
+  },
+  async discoverSessions() {
+    const sources = [];
+    const projectsDir = getProjectsDir();
+    try {
+      const entries = await readdir(projectsDir);
+      for (const dirName of entries) {
+        const dirPath = join(projectsDir, dirName);
+        const dirStat = await stat(dirPath).catch(() => null);
+        if (dirStat?.isDirectory()) {
+          sources.push({ path: dirPath, project: dirName, provider: "claude" });
+        }
+      }
+    } catch {
+    }
+    const desktopDirs = await findDesktopProjectDirs(getDesktopSessionsDir());
+    for (const dirPath of desktopDirs) {
+      sources.push({ path: dirPath, project: basename(dirPath), provider: "claude" });
+    }
+    return sources;
+  },
+  createSessionParser() {
+    return {
+      async *parse() {
+      }
+    };
+  }
+};
+
+// ../../packages/session/dist/providers/codex.js
+import { readdir as readdir2, readFile, stat as stat2 } from "fs/promises";
+import { basename as basename2, join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var modelDisplayNames = {
+  "gpt-5.3-codex": "GPT-5.3 Codex",
+  "gpt-5.4-mini": "GPT-5.4 Mini",
+  "gpt-5.4": "GPT-5.4",
+  "gpt-5": "GPT-5",
+  "gpt-4o-mini": "GPT-4o Mini",
+  "gpt-4o": "GPT-4o"
+};
+var toolNameMap = {
+  exec_command: "Bash",
+  read_file: "Read",
+  write_file: "Edit",
+  apply_diff: "Edit",
+  apply_patch: "Edit",
+  spawn_agent: "Agent",
+  close_agent: "Agent",
+  wait_agent: "Agent",
+  read_dir: "Glob"
+};
+function getCodexDir() {
+  return process.env["CODEX_HOME"] ?? join2(homedir2(), ".codex");
+}
+function sanitizeProject(cwd) {
+  return cwd.replace(/^\//, "").replace(/\//g, "-");
+}
+async function readFirstLine(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const line = content.split("\n")[0];
+    if (!line?.trim())
+      return null;
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+async function isValidCodexSession(filePath) {
+  const entry = await readFirstLine(filePath);
+  if (!entry)
+    return { valid: false };
+  const valid = entry.type === "session_meta" && typeof entry.payload?.originator === "string" && entry.payload.originator.toLowerCase().startsWith("codex");
+  return { valid, meta: valid ? entry : void 0 };
+}
+async function discoverSessionsInDir(codexDir) {
+  const sessionsDir = join2(codexDir, "sessions");
+  const sources = [];
+  let years;
+  try {
+    years = await readdir2(sessionsDir);
+  } catch {
+    return sources;
+  }
+  for (const year of years) {
+    if (!/^\d{4}$/.test(year))
+      continue;
+    const yearDir = join2(sessionsDir, year);
+    const months = await readdir2(yearDir).catch(() => []);
+    for (const month of months) {
+      if (!/^\d{2}$/.test(month))
+        continue;
+      const monthDir = join2(yearDir, month);
+      const days = await readdir2(monthDir).catch(() => []);
+      for (const day of days) {
+        if (!/^\d{2}$/.test(day))
+          continue;
+        const dayDir = join2(monthDir, day);
+        const files = await readdir2(dayDir).catch(() => []);
+        for (const file of files) {
+          if (!file.startsWith("rollout-") || !file.endsWith(".jsonl"))
+            continue;
+          const filePath = join2(dayDir, file);
+          const s = await stat2(filePath).catch(() => null);
+          if (!s?.isFile())
+            continue;
+          const { valid, meta } = await isValidCodexSession(filePath);
+          if (!valid || !meta)
+            continue;
+          const cwd = meta.payload?.cwd ?? "unknown";
+          sources.push({ path: filePath, project: sanitizeProject(cwd), provider: "codex" });
+        }
+      }
+    }
+  }
+  return sources;
+}
+function resolveModel(info, sessionModel) {
+  return info?.info?.model ?? info?.info?.model_name ?? sessionModel ?? "gpt-5";
+}
+function createParser(source, seenKeys) {
+  return {
+    async *parse() {
+      let content;
+      try {
+        content = await readFile(source.path, "utf-8");
+      } catch {
+        return;
+      }
+      const lines = content.split("\n").filter((l) => l.trim());
+      let sessionModel;
+      let sessionId = "";
+      let prevCumulativeTotal = 0;
+      let prevInput = 0;
+      let prevCached = 0;
+      let prevOutput = 0;
+      let prevReasoning = 0;
+      let pendingTools = [];
+      let pendingUserMessage = "";
+      for (const line of lines) {
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry.type === "session_meta") {
+          sessionId = entry.payload?.session_id ?? basename2(source.path, ".jsonl");
+          sessionModel = entry.payload?.model;
+          continue;
+        }
+        if (entry.type === "response_item" && entry.payload?.type === "function_call") {
+          const rawName = entry.payload.name ?? "";
+          pendingTools.push(toolNameMap[rawName] ?? rawName);
+          continue;
+        }
+        if (entry.type === "response_item" && entry.payload?.type === "message" && entry.payload?.role === "user") {
+          const texts = (entry.payload.content ?? []).filter((c) => c.type === "input_text").map((c) => c.text ?? "").filter(Boolean);
+          if (texts.length > 0)
+            pendingUserMessage = texts.join(" ");
+          continue;
+        }
+        if (entry.type === "event_msg" && entry.payload?.type === "token_count") {
+          const info = entry.payload.info;
+          if (!info)
+            continue;
+          const cumulativeTotal = info.total_token_usage?.total_tokens ?? 0;
+          if (cumulativeTotal > 0 && cumulativeTotal === prevCumulativeTotal)
+            continue;
+          prevCumulativeTotal = cumulativeTotal;
+          const last = info.last_token_usage;
+          let inputTokens = 0;
+          let cachedInputTokens = 0;
+          let outputTokens = 0;
+          let reasoningTokens = 0;
+          if (last) {
+            inputTokens = last.input_tokens ?? 0;
+            cachedInputTokens = last.cached_input_tokens ?? 0;
+            outputTokens = last.output_tokens ?? 0;
+            reasoningTokens = last.reasoning_output_tokens ?? 0;
+          } else if (cumulativeTotal > 0) {
+            const total = info.total_token_usage;
+            if (!total)
+              continue;
+            inputTokens = (total.input_tokens ?? 0) - prevInput;
+            cachedInputTokens = (total.cached_input_tokens ?? 0) - prevCached;
+            outputTokens = (total.output_tokens ?? 0) - prevOutput;
+            reasoningTokens = (total.reasoning_output_tokens ?? 0) - prevReasoning;
+          }
+          if (!last) {
+            const total = info.total_token_usage;
+            if (total) {
+              prevInput = total.input_tokens ?? 0;
+              prevCached = total.cached_input_tokens ?? 0;
+              prevOutput = total.output_tokens ?? 0;
+              prevReasoning = total.reasoning_output_tokens ?? 0;
+            }
+          }
+          const totalTokens = inputTokens + cachedInputTokens + outputTokens + reasoningTokens;
+          if (totalTokens === 0)
+            continue;
+          const uncachedInputTokens = Math.max(0, inputTokens - cachedInputTokens);
+          const model = resolveModel(entry.payload, sessionModel);
+          const timestamp = entry.timestamp ?? "";
+          const dedupKey = `codex:${source.path}:${timestamp}:${cumulativeTotal}`;
+          if (seenKeys.has(dedupKey))
+            continue;
+          seenKeys.add(dedupKey);
+          yield {
+            provider: "codex",
+            model,
+            inputTokens: uncachedInputTokens,
+            outputTokens,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: cachedInputTokens,
+            cachedInputTokens,
+            reasoningTokens,
+            costUSD: 0,
+            // Cost calculated downstream
+            tools: pendingTools,
+            bashCommands: [],
+            timestamp,
+            speed: "standard",
+            deduplicationKey: dedupKey,
+            userMessage: pendingUserMessage,
+            sessionId
+          };
+          pendingTools = [];
+          pendingUserMessage = "";
+        }
+      }
+    }
+  };
+}
+var codex = {
+  name: "codex",
+  displayName: "Codex",
+  modelDisplayName(model) {
+    for (const [key, name] of Object.entries(modelDisplayNames)) {
+      if (model.startsWith(key))
+        return name;
+    }
+    return model;
+  },
+  toolDisplayName(rawTool) {
+    return toolNameMap[rawTool] ?? rawTool;
+  },
+  async discoverSessions() {
+    return discoverSessionsInDir(getCodexDir());
+  },
+  createSessionParser(source, seenKeys) {
+    return createParser(source, seenKeys);
+  }
+};
+
+// ../../packages/session/dist/providers/copilot.js
+import { readdir as readdir3, readFile as readFile2, stat as stat3 } from "fs/promises";
+import { basename as basename3, dirname, join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+var modelDisplayNames2 = {
+  "gpt-4.1-nano": "GPT-4.1 Nano",
+  "gpt-4.1-mini": "GPT-4.1 Mini",
+  "gpt-4.1": "GPT-4.1",
+  "gpt-4o-mini": "GPT-4o Mini",
+  "gpt-4o": "GPT-4o",
+  "gpt-5-mini": "GPT-5 Mini",
+  "gpt-5": "GPT-5",
+  "claude-sonnet-4-5": "Sonnet 4.5",
+  "claude-sonnet-4": "Sonnet 4",
+  "claude-3-7-sonnet": "Sonnet 3.7",
+  "claude-3-5-sonnet": "Sonnet 3.5",
+  "o4-mini": "o4-mini",
+  "o3": "o3"
+};
+var toolNameMap2 = {
+  bash: "Bash",
+  read_file: "Read",
+  write_file: "Edit",
+  edit_file: "Edit",
+  create_file: "Write",
+  delete_file: "Delete",
+  search_files: "Grep",
+  find_files: "Glob",
+  list_directory: "LS",
+  web_search: "WebSearch",
+  fetch_webpage: "WebFetch",
+  github_repo: "GitHub"
+};
+var modelDisplayEntries = Object.entries(modelDisplayNames2).sort((a, b) => b[0].length - a[0].length);
+function getCopilotSessionStateDir() {
+  return join3(homedir3(), ".copilot", "session-state");
+}
+function parseCwd(yaml) {
+  const match = yaml.match(/^cwd:\s*(.+)$/m);
+  if (!match?.[1])
+    return null;
+  return match[1].replace(/\s*#.*$/, "").replace(/^['"]|['"]$/g, "").trim() || null;
+}
+function createParser2(source, seenKeys) {
+  return {
+    async *parse() {
+      let content;
+      try {
+        content = await readFile2(source.path, "utf-8");
+      } catch {
+        return;
+      }
+      const sessionId = basename3(dirname(source.path));
+      const lines = content.split("\n").filter((l) => l.trim());
+      let currentModel = "";
+      let pendingUserMessage = "";
+      for (const line of lines) {
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (event.type === "session.model_change") {
+          currentModel = event.data.newModel ?? currentModel;
+          continue;
+        }
+        if (event.type === "user.message") {
+          pendingUserMessage = event.data.content ?? "";
+          continue;
+        }
+        if (event.type === "assistant.message") {
+          const { messageId, outputTokens, toolRequests = [] } = event.data;
+          if (outputTokens === 0)
+            continue;
+          if (!currentModel)
+            continue;
+          const dedupKey = `copilot:${sessionId}:${messageId}`;
+          if (seenKeys.has(dedupKey))
+            continue;
+          seenKeys.add(dedupKey);
+          const tools = toolRequests.map((t) => t.name ?? "").filter(Boolean).map((n) => toolNameMap2[n] ?? n);
+          yield {
+            provider: "copilot",
+            model: currentModel,
+            inputTokens: 0,
+            // Copilot only logs outputTokens
+            outputTokens,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: 0,
+            cachedInputTokens: 0,
+            reasoningTokens: 0,
+            costUSD: 0,
+            tools,
+            bashCommands: [],
+            timestamp: event.timestamp ?? "",
+            speed: "standard",
+            deduplicationKey: dedupKey,
+            userMessage: pendingUserMessage,
+            sessionId
+          };
+          pendingUserMessage = "";
+        }
+      }
+    }
+  };
+}
+async function discoverSessionsInDir2(sessionStateDir) {
+  const sources = [];
+  let sessionDirs;
+  try {
+    sessionDirs = await readdir3(sessionStateDir);
+  } catch {
+    return sources;
+  }
+  for (const sessionId of sessionDirs) {
+    const eventsPath = join3(sessionStateDir, sessionId, "events.jsonl");
+    const s = await stat3(eventsPath).catch(() => null);
+    if (!s?.isFile())
+      continue;
+    let project = sessionId;
+    try {
+      const yaml = await readFile2(join3(sessionStateDir, sessionId, "workspace.yaml"), "utf-8");
+      const cwd = parseCwd(yaml);
+      if (cwd)
+        project = basename3(cwd);
+    } catch {
+    }
+    sources.push({ path: eventsPath, project, provider: "copilot" });
+  }
+  return sources;
+}
+var copilot = {
+  name: "copilot",
+  displayName: "GitHub Copilot",
+  modelDisplayName(model) {
+    for (const [key, name] of modelDisplayEntries) {
+      if (model === key || model.startsWith(key + "-"))
+        return name;
+    }
+    return model;
+  },
+  toolDisplayName(rawTool) {
+    return toolNameMap2[rawTool] ?? rawTool;
+  },
+  async discoverSessions() {
+    return discoverSessionsInDir2(getCopilotSessionStateDir());
+  },
+  createSessionParser(source, seenKeys) {
+    return createParser2(source, seenKeys);
+  }
+};
+
+// ../../packages/session/dist/providers/pi.js
+import { readdir as readdir4, readFile as readFile3, stat as stat4 } from "fs/promises";
+import { basename as basename4, join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+var modelDisplayNames3 = {
+  "gpt-5.4": "GPT-5.4",
+  "gpt-5.4-mini": "GPT-5.4 Mini",
+  "gpt-5": "GPT-5",
+  "gpt-4o": "GPT-4o",
+  "gpt-4o-mini": "GPT-4o Mini"
+};
+var toolNameMap3 = {
+  bash: "Bash",
+  read: "Read",
+  edit: "Edit",
+  write: "Write",
+  glob: "Glob",
+  grep: "Grep",
+  task: "Agent",
+  dispatch_agent: "Agent",
+  fetch: "WebFetch",
+  search: "WebSearch",
+  todo: "TodoWrite",
+  patch: "Patch"
+};
+var modelDisplayEntries2 = Object.entries(modelDisplayNames3).sort((a, b) => b[0].length - a[0].length);
+function getPiSessionsDir() {
+  return join4(homedir4(), ".pi", "agent", "sessions");
+}
+async function readFirstEntry(filePath) {
+  try {
+    const content = await readFile3(filePath, "utf-8");
+    const line = content.split("\n")[0];
+    if (!line?.trim())
+      return null;
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function extractBashCommands(cmd) {
+  return cmd.split(/[;&|]+/).map((s) => s.trim().split(/\s+/)[0]).filter(Boolean);
+}
+async function discoverSessionsInDir3(sessionsDir) {
+  const sources = [];
+  let projectDirs;
+  try {
+    projectDirs = await readdir4(sessionsDir);
+  } catch {
+    return sources;
+  }
+  for (const dirName of projectDirs) {
+    const dirPath = join4(sessionsDir, dirName);
+    const dirStat = await stat4(dirPath).catch(() => null);
+    if (!dirStat?.isDirectory())
+      continue;
+    let files;
+    try {
+      files = await readdir4(dirPath);
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      if (!file.endsWith(".jsonl"))
+        continue;
+      const filePath = join4(dirPath, file);
+      const fileStat = await stat4(filePath).catch(() => null);
+      if (!fileStat?.isFile())
+        continue;
+      const first = await readFirstEntry(filePath);
+      if (!first || first.type !== "session")
+        continue;
+      const cwd = first.cwd ?? dirName;
+      sources.push({ path: filePath, project: basename4(cwd), provider: "pi" });
+    }
+  }
+  return sources;
+}
+function createParser3(source, seenKeys) {
+  return {
+    async *parse() {
+      let content;
+      try {
+        content = await readFile3(source.path, "utf-8");
+      } catch {
+        return;
+      }
+      const lines = content.split("\n").filter((l) => l.trim());
+      let sessionId = basename4(source.path, ".jsonl");
+      let pendingUserMessage = "";
+      for (const [lineIdx, line] of lines.entries()) {
+        let entry;
+        try {
+          entry = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (entry.type === "session") {
+          sessionId = entry.id ?? sessionId;
+          continue;
+        }
+        if (entry.type !== "message")
+          continue;
+        const msg = entry.message;
+        if (!msg)
+          continue;
+        if (msg.role === "user") {
+          const texts = (msg.content ?? []).filter((c) => c.type === "text").map((c) => c.text ?? "").filter(Boolean);
+          if (texts.length > 0)
+            pendingUserMessage = texts.join(" ");
+          continue;
+        }
+        if (msg.role !== "assistant" || !msg.usage)
+          continue;
+        const { input, output, cacheRead, cacheWrite } = msg.usage;
+        if (input === 0 && output === 0)
+          continue;
+        const model = msg.model ?? "gpt-5";
+        const responseId = msg.responseId ?? "";
+        const dedupKey = `pi:${source.path}:${responseId || entry.id || entry.timestamp || String(lineIdx)}`;
+        if (seenKeys.has(dedupKey))
+          continue;
+        seenKeys.add(dedupKey);
+        const toolCalls = (msg.content ?? []).filter((c) => c.type === "toolCall" && c.name);
+        const tools = toolCalls.map((c) => toolNameMap3[c.name] ?? c.name);
+        const bashCommands = toolCalls.filter((c) => c.name === "bash").flatMap((c) => {
+          const cmd = c.arguments?.["command"];
+          return typeof cmd === "string" ? extractBashCommands(cmd) : [];
+        });
+        const timestamp = entry.timestamp ?? "";
+        yield {
+          provider: "pi",
+          model,
+          inputTokens: input,
+          outputTokens: output,
+          cacheCreationInputTokens: cacheWrite,
+          cacheReadInputTokens: cacheRead,
+          cachedInputTokens: cacheRead,
+          reasoningTokens: 0,
+          costUSD: 0,
+          tools,
+          bashCommands,
+          timestamp,
+          speed: "standard",
+          deduplicationKey: dedupKey,
+          userMessage: pendingUserMessage,
+          sessionId
+        };
+        pendingUserMessage = "";
+      }
+    }
+  };
+}
+var pi = {
+  name: "pi",
+  displayName: "Pi",
+  modelDisplayName(model) {
+    for (const [key, name] of modelDisplayEntries2) {
+      if (model.startsWith(key))
+        return name;
+    }
+    return model;
+  },
+  toolDisplayName(rawTool) {
+    return toolNameMap3[rawTool] ?? rawTool;
+  },
+  async discoverSessions() {
+    return discoverSessionsInDir3(getPiSessionsDir());
+  },
+  createSessionParser(source, seenKeys) {
+    return createParser3(source, seenKeys);
+  }
+};
+
+// ../../packages/session/dist/providers/index.js
+var coreProviders = [claudeCode, codex, copilot, pi];
+var cursorProvider = null;
+var cursorLoadAttempted = false;
+async function loadCursor() {
+  if (cursorLoadAttempted)
+    return cursorProvider;
+  cursorLoadAttempted = true;
+  try {
+    const { cursor } = await import("./cursor-BGQJ4CWI.js");
+    cursorProvider = cursor;
+    return cursor;
+  } catch {
+    return null;
+  }
+}
+var opencodeProvider = null;
+var opencodeLoadAttempted = false;
+async function loadOpenCode() {
+  if (opencodeLoadAttempted)
+    return opencodeProvider;
+  opencodeLoadAttempted = true;
+  try {
+    const { opencode } = await import("./opencode-IQ7X5YMJ.js");
+    opencodeProvider = opencode;
+    return opencode;
+  } catch {
+    return null;
+  }
+}
+async function getAllProviders() {
+  const [cursor, opencode] = await Promise.all([loadCursor(), loadOpenCode()]);
+  const all = [...coreProviders];
+  if (cursor)
+    all.push(cursor);
+  if (opencode)
+    all.push(opencode);
+  return all;
+}
+async function discoverAllSessions(providerFilter) {
+  const allProviders = await getAllProviders();
+  const filtered = providerFilter && providerFilter !== "all" ? allProviders.filter((p) => p.name === providerFilter) : allProviders;
+  const all = [];
+  for (const provider of filtered) {
+    const sessions = await provider.discoverSessions();
+    all.push(...sessions);
+  }
+  return all;
+}
+async function getProvider(name) {
+  if (name === "cursor")
+    return await loadCursor() ?? void 0;
+  if (name === "opencode")
+    return await loadOpenCode() ?? void 0;
+  return coreProviders.find((p) => p.name === name);
+}
+
+// ../../packages/session/dist/launchers/claude-code.js
+import { spawn as spawn2 } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join5 } from "node:path";
+
+// ../../packages/session/dist/terminal/tmux.js
+import { spawn } from "node:child_process";
+function sanitizeTmuxName(input) {
+  const cleaned = input.trim().replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return `rm-${cleaned || "session"}`;
+}
+function buildTmuxLaunchArgs(input) {
+  const claudeArgs = input.runId ? ["env", `RULEMETRIC_RUN_ID=${input.runId}`, "claude"] : ["claude"];
+  if (input.resumeSessionId) {
+    claudeArgs.push("--resume", input.resumeSessionId);
+  }
+  if (input.model) {
+    claudeArgs.push("--model", input.model);
+  }
+  return [
+    "new-session",
+    "-d",
+    "-s",
+    input.sessionName,
+    "-c",
+    input.projectPath,
+    "--",
+    ...claudeArgs
+  ];
+}
+function buildTmuxSendKeysArgs(target, message, options = {}) {
+  if (options.literal === false) {
+    return ["send-keys", "-t", target, message];
+  }
+  return ["send-keys", "-t", target, "-l", "--", message];
+}
+function buildTmuxHasSessionArgs(target) {
+  return ["has-session", "-t", target];
+}
+function buildTmuxAttachCommand(target) {
+  return `tmux attach -t ${target}`;
+}
+function tmuxSpawnEnv() {
+  const extraDirs = ["/opt/homebrew/bin", "/usr/local/bin"];
+  const parts = (process.env.PATH ?? "").split(":").filter(Boolean);
+  const missing = extraDirs.filter((d) => !parts.includes(d));
+  if (missing.length === 0)
+    return process.env;
+  return { ...process.env, PATH: [...parts, ...missing].join(":") };
+}
+function runTmux(args) {
+  return new Promise((resolve) => {
+    const proc = spawn("tmux", args, {
+      stdio: ["ignore", "ignore", "pipe"],
+      env: tmuxSpawnEnv()
+    });
+    let stderr = "";
+    proc.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    proc.on("close", (code) => resolve({ code, stderr }));
+    proc.on("error", (err) => resolve({ code: null, stderr: err.message }));
+  });
+}
+async function isTmuxAvailable() {
+  const result = await runTmux(["-V"]);
+  return result.code === 0;
+}
+
+// ../../packages/session/dist/launchers/claude-code.js
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function validateRunId(runId) {
+  if (runId === void 0)
+    return void 0;
+  if (UUID_RE.test(runId))
+    return runId;
+  console.warn(`[claude-code-launcher] dropping non-uuid runId (RULEMETRIC_RUN_ID not injected): ${JSON.stringify(runId)}`);
+  return void 0;
+}
+function shellSingleQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+var ClaudeCodeLauncher = class {
+  options;
+  tool = "claude_code";
+  constructor(options = {}) {
+    this.options = options;
+  }
+  capabilities = {
+    headless: true,
+    interactive: true,
+    remoteSpawn: true
+  };
+  async launch(config) {
+    const sessionId = randomUUID();
+    const safeConfig = { ...config, runId: validateRunId(config.runId) };
+    if (safeConfig.mode === "headless") {
+      return this.launchHeadless(safeConfig, sessionId);
+    }
+    return this.launchInteractive(safeConfig, sessionId);
+  }
+  async launchHeadless(config, sessionId) {
+    const args = ["-p", config.prompt ?? "", "--output-format", "json"];
+    if (config.systemPrompt)
+      args.push("--system-prompt", config.systemPrompt);
+    if (config.model)
+      args.push("--model", config.model);
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+    delete env.HTTPS_PROXY;
+    if (config.runId)
+      env.RULEMETRIC_RUN_ID = config.runId;
+    return new Promise((resolve) => {
+      const proc = spawn2("claude", args, {
+        cwd: config.projectPath,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = config.timeout ? setTimeout(() => {
+        proc.kill("SIGTERM");
+      }, config.timeout) : null;
+      proc.on("close", (code) => {
+        if (timer)
+          clearTimeout(timer);
+        let output = stdout;
+        try {
+          const parsed = JSON.parse(stdout);
+          output = parsed.result ?? parsed.content ?? stdout;
+        } catch {
+        }
+        resolve({
+          sessionId,
+          pid: proc.pid,
+          exitCode: code,
+          output,
+          error: code !== 0 ? stderr : void 0
+        });
+      });
+      proc.on("error", (err) => {
+        if (timer)
+          clearTimeout(timer);
+        resolve({ sessionId, error: `Failed to spawn claude: ${err.message}` });
+      });
+    });
+  }
+  async launchInteractive(config, sessionId) {
+    const tmuxAvailableCheck = this.options.tmuxAvailable ?? isTmuxAvailable;
+    if (await tmuxAvailableCheck().catch(() => false)) {
+      return this.launchInteractiveTmux(config, sessionId);
+    }
+    return this.launchInteractiveTerminal(config, sessionId, "tmux_not_found");
+  }
+  async launchInteractiveTmux(config, sessionId) {
+    const run = this.options.runTmux ?? runTmux;
+    const target = sanitizeTmuxName(`claude-${config.resumeSessionId ?? sessionId}`);
+    const launchResult = await run(buildTmuxLaunchArgs({
+      sessionName: target,
+      projectPath: config.projectPath,
+      resumeSessionId: config.resumeSessionId,
+      model: config.model,
+      // Task 3.1: inject the run id into the spawned session's env so its
+      // session-start hook forwards it to POST /api/sessions (stamps run_id).
+      runId: config.runId
+    }));
+    if (launchResult.code !== 0) {
+      return this.launchInteractiveTerminal(config, sessionId, "tmux_launch_failed", `tmux new-session exited ${launchResult.code}: ${launchResult.stderr.trim() || "no stderr"}`);
+    }
+    const attachResult = await this.openTerminalAttach(target, sessionId);
+    if (config.prompt) {
+      const sendResult = await run(buildTmuxSendKeysArgs(target, config.prompt));
+      if (sendResult.code !== 0) {
+        return {
+          sessionId,
+          liveSendAvailable: false,
+          fallbackReason: "tmux_launch_failed",
+          error: `tmux send-keys exited ${sendResult.code}: ${sendResult.stderr.trim() || "no stderr"}`
+        };
+      }
+      const enterResult = await run(buildTmuxSendKeysArgs(target, "Enter", { literal: false }));
+      if (enterResult.code !== 0) {
+        return {
+          sessionId,
+          liveSendAvailable: false,
+          fallbackReason: "tmux_launch_failed",
+          error: `tmux send Enter exited ${enterResult.code}: ${enterResult.stderr.trim() || "no stderr"}`
+        };
+      }
+    }
+    return {
+      sessionId,
+      pid: attachResult.pid,
+      liveSendAvailable: true,
+      ...attachResult.error ? { error: attachResult.error } : {},
+      terminalTarget: {
+        kind: "tmux",
+        target,
+        attachCommand: buildTmuxAttachCommand(target),
+        live: true
+      }
+    };
+  }
+  async openTerminalAttach(target, sessionId) {
+    const scriptPath = join5(tmpdir(), `rulemetric-attach-${sessionId}.command`);
+    const scriptBody = `#!/bin/zsh
+rm -- "$0"
+${buildTmuxAttachCommand(target)}
+`;
+    await writeFile(scriptPath, scriptBody, { mode: 493 });
+    return new Promise((resolve) => {
+      const proc = spawn2("open", ["-a", "Terminal", scriptPath], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stderr = "";
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve({ pid: proc.pid });
+        } else {
+          resolve({
+            pid: proc.pid,
+            error: `open attach exited ${code}: ${stderr.trim() || "no stderr"}`
+          });
+        }
+      });
+      proc.on("error", (err) => {
+        resolve({ error: `Failed to spawn open attach: ${err.message}` });
+      });
+    });
+  }
+  async launchInteractiveTerminal(config, sessionId, fallbackReason, fallbackDetail) {
+    const parts = ["claude"];
+    if (config.resumeSessionId) {
+      parts.push("--resume", config.resumeSessionId);
+    } else if (config.prompt) {
+      parts.push("-p", JSON.stringify(config.prompt));
+    }
+    if (config.model)
+      parts.push("--model", config.model);
+    const cmd = parts.join(" ");
+    const scriptPath = join5(tmpdir(), `rulemetric-launch-${sessionId}.command`);
+    const runIdExport = config.runId ? `export RULEMETRIC_RUN_ID=${shellSingleQuote(config.runId)}
+` : "";
+    const scriptBody = `#!/bin/zsh
+rm -- "$0"
+cd ${JSON.stringify(config.projectPath)} || exit
+` + runIdExport + `${cmd}
+`;
+    await writeFile(scriptPath, scriptBody, { mode: 493 });
+    return new Promise((resolve) => {
+      const proc = spawn2("open", ["-a", "Terminal", scriptPath], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stderr = "";
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve({
+            sessionId,
+            pid: proc.pid,
+            liveSendAvailable: false,
+            fallbackReason,
+            ...fallbackDetail ? { error: fallbackDetail } : {}
+          });
+        } else {
+          const tail = stderr.trim() || "no stderr";
+          resolve({
+            sessionId,
+            pid: proc.pid,
+            liveSendAvailable: false,
+            fallbackReason,
+            error: fallbackDetail ? `${fallbackDetail}; open exited ${code}: ${tail}` : `open exited ${code}: ${tail}`
+          });
+        }
+      });
+      proc.on("error", (err) => {
+        resolve({
+          sessionId,
+          liveSendAvailable: false,
+          fallbackReason,
+          error: `Failed to spawn open: ${err.message}`
+        });
+      });
+    });
+  }
+};
+
+// ../../packages/session/dist/launchers/codex.js
+import { spawn as spawn3 } from "node:child_process";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var CodexLauncher = class {
+  tool = "codex";
+  capabilities = { headless: true, interactive: true, remoteSpawn: true };
+  async launch(config) {
+    const sessionId = randomUUID2();
+    if (config.mode === "headless") {
+      return this.launchHeadless(config, sessionId);
+    }
+    return this.launchInteractive(config, sessionId);
+  }
+  launchHeadless(config, sessionId) {
+    const args = ["-q", config.prompt ?? ""];
+    if (config.model)
+      args.push("--model", config.model);
+    return new Promise((resolve) => {
+      const proc = spawn3("codex", args, {
+        cwd: config.projectPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = config.timeout ? setTimeout(() => {
+        proc.kill("SIGTERM");
+      }, config.timeout) : null;
+      proc.on("close", (code) => {
+        if (timer)
+          clearTimeout(timer);
+        resolve({ sessionId, pid: proc.pid, exitCode: code, output: stdout, error: code !== 0 ? stderr : void 0 });
+      });
+      proc.on("error", (err) => {
+        if (timer)
+          clearTimeout(timer);
+        resolve({ sessionId, error: `Failed to spawn codex: ${err.message}` });
+      });
+    });
+  }
+  launchInteractive(config, sessionId) {
+    const parts = ["codex"];
+    if (config.prompt)
+      parts.push(JSON.stringify(config.prompt));
+    const script = `cd ${JSON.stringify(config.projectPath)} && ${parts.join(" ")}`;
+    const proc = spawn3("osascript", ["-e", `tell application "Terminal" to do script ${JSON.stringify(script)}`], {
+      stdio: "ignore",
+      detached: true
+    });
+    proc.unref();
+    return Promise.resolve({ sessionId, pid: proc.pid });
+  }
+};
+
+// ../../packages/session/dist/launchers/aider.js
+import { spawn as spawn4 } from "node:child_process";
+import { randomUUID as randomUUID3 } from "node:crypto";
+var AiderLauncher = class {
+  tool = "aider";
+  capabilities = { headless: true, interactive: true, remoteSpawn: true };
+  async launch(config) {
+    const sessionId = randomUUID3();
+    if (config.mode === "headless") {
+      return this.launchHeadless(config, sessionId);
+    }
+    return this.launchInteractive(config, sessionId);
+  }
+  launchHeadless(config, sessionId) {
+    const args = ["--message", config.prompt ?? "", "--yes"];
+    if (config.model)
+      args.push("--model", config.model);
+    return new Promise((resolve) => {
+      const proc = spawn4("aider", args, {
+        cwd: config.projectPath,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = config.timeout ? setTimeout(() => {
+        proc.kill("SIGTERM");
+      }, config.timeout) : null;
+      proc.on("close", (code) => {
+        if (timer)
+          clearTimeout(timer);
+        resolve({ sessionId, pid: proc.pid, exitCode: code, output: stdout, error: code !== 0 ? stderr : void 0 });
+      });
+      proc.on("error", (err) => {
+        if (timer)
+          clearTimeout(timer);
+        resolve({ sessionId, error: `Failed to spawn aider: ${err.message}` });
+      });
+    });
+  }
+  launchInteractive(config, sessionId) {
+    const parts = ["aider"];
+    if (config.model)
+      parts.push("--model", config.model);
+    const script = `cd ${JSON.stringify(config.projectPath)} && ${parts.join(" ")}`;
+    const proc = spawn4("osascript", ["-e", `tell application "Terminal" to do script ${JSON.stringify(script)}`], {
+      stdio: "ignore",
+      detached: true
+    });
+    proc.unref();
+    return Promise.resolve({ sessionId, pid: proc.pid });
+  }
+};
+
+// ../../packages/session/dist/launchers/generic.js
+import { spawn as spawn5 } from "node:child_process";
+import { randomUUID as randomUUID4 } from "node:crypto";
+var GenericLauncher = class {
+  tool;
+  constructor(tool) {
+    this.tool = tool;
+  }
+  capabilities = { headless: false, interactive: true, remoteSpawn: false };
+  async launch(config) {
+    const sessionId = randomUUID4();
+    if (config.mode === "headless") {
+      return { sessionId, error: `${this.tool} does not support headless mode` };
+    }
+    const script = `cd ${JSON.stringify(config.projectPath)} && echo "Session ${sessionId} \u2014 tool: ${this.tool}" && exec $SHELL`;
+    const proc = spawn5("osascript", ["-e", `tell application "Terminal" to do script ${JSON.stringify(script)}`], {
+      stdio: "ignore",
+      detached: true
+    });
+    proc.unref();
+    return { sessionId, pid: proc.pid };
+  }
+};
+
+// ../../packages/session/dist/launchers/index.js
+var launchers = {
+  claude_code: () => new ClaudeCodeLauncher(),
+  codex: () => new CodexLauncher(),
+  aider: () => new AiderLauncher()
+};
+function getLauncher(tool) {
+  const factory = launchers[tool];
+  return factory ? factory() : new GenericLauncher(tool);
+}
+function getAvailableLaunchers() {
+  return Object.entries(launchers).map(([tool, factory]) => ({
+    tool,
+    capabilities: factory().capabilities
+  }));
+}
+
+// ../../packages/session/dist/launchers/worktree-path.js
+import path from "node:path";
+function sanitizeBranch(branch) {
+  return branch.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "") || "worktree";
+}
+function worktreePathFor(options) {
+  return path.resolve(options.basePath ?? path.join(options.repoRoot, "..", ".rulemetric-worktrees", sanitizeBranch(options.branch)));
+}
+
+export {
+  SESSION_TOOLS,
+  SESSION_EVENT_TYPES,
+  ClaudeCodeAdapter,
+  CursorAdapter,
+  VSCodeCopilotAdapter,
+  CopilotAgentAdapter,
+  RuleMetricMcpAdapter,
+  getAdapter,
+  detectTool,
+  buildAnalysisPrompt,
+  parseAnalysisResponse,
+  getAllProviders,
+  discoverAllSessions,
+  getProvider,
+  sanitizeTmuxName,
+  buildTmuxLaunchArgs,
+  buildTmuxSendKeysArgs,
+  buildTmuxHasSessionArgs,
+  buildTmuxAttachCommand,
+  getLauncher,
+  getAvailableLaunchers,
+  sanitizeBranch,
+  worktreePathFor
+};
+//# sourceMappingURL=chunk-B5KNTGMJ.js.map