deepline 0.3.293 → 0.3.295

package/dist/cli/chunk-YWNDYCXR.mjs

@@ -0,0 +1,735 @@
+import {
+  getAuthedHttpClient,
+  printCommandEnvelope
+} from "./chunk-6O5YZOVN.mjs";
+
+// src/cli/commands/sessions.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  realpathSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir, platform } from "os";
+import { basename, dirname, join, resolve } from "path";
+import { gzipSync } from "zlib";
+import { randomUUID } from "crypto";
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UUID_IN_TEXT_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+var MAX_SESSION_UPLOAD_BYTES = 35e5;
+var MAX_DIRECT_SESSION_DECODED_BYTES = 50 * 1024 * 1024;
+var CHUNK_SIZE_BYTES = 25e5;
+var MAX_EVENT_STRING_CHARS = 8e3;
+var MAX_EVENT_LIST_ITEMS = 40;
+var MAX_EVENT_OBJECT_KEYS = 80;
+var TRUNCATION_MARKER = "...[truncated]";
+var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set(["progress", "file-history-snapshot"]);
+function homeDir() {
+  return process.env.HOME?.trim() || homedir();
+}
+function detectShellContext() {
+  const shellPath = process.env.SHELL?.trim() || process.env.ComSpec?.trim() || process.env.COMSPEC?.trim() || "";
+  return {
+    shell: shellPath ? basename(shellPath).replace(/\.exe$/i, "") : "unknown",
+    shell_path: shellPath || null,
+    os: platform(),
+    cwd: process.cwd()
+  };
+}
+function claudeProjectsRoot() {
+  return join(homeDir(), ".claude", "projects");
+}
+function codexSessionsRoot() {
+  return join(homeDir(), ".codex", "sessions");
+}
+function listClaudeSessionFiles() {
+  const root = claudeProjectsRoot();
+  if (!existsSync(root)) return [];
+  const projectDirs = readDirectoryNames(root);
+  const files = [];
+  for (const projectDir of projectDirs) {
+    const fullProjectDir = join(root, projectDir);
+    for (const fileName of readDirectoryNames(fullProjectDir)) {
+      if (fileName.endsWith(".jsonl")) {
+        const filePath = join(fullProjectDir, fileName);
+        const sessionId = sessionIdFromClaudeFilePath(filePath);
+        const stat = statIfReadable(filePath);
+        if (sessionId && stat) {
+          files.push({
+            agent: "claude",
+            sessionId,
+            filePath,
+            mtimeMs: stat.mtimeMs
+          });
+        }
+      }
+    }
+  }
+  return files;
+}
+function listCodexSessionFiles() {
+  const root = codexSessionsRoot();
+  if (!existsSync(root)) return [];
+  const files = [];
+  for (const filePath of listJsonlFilesRecursive(root, 5)) {
+    const stat = statIfReadable(filePath);
+    if (!stat) continue;
+    const sessionId = sessionIdFromCodexFilePath(filePath) ?? readCodexSessionId(filePath);
+    if (!sessionId) continue;
+    files.push({ agent: "codex", sessionId, filePath, mtimeMs: stat.mtimeMs });
+  }
+  return files;
+}
+function listSessionFiles(agent) {
+  const files = [];
+  if (agent === "auto" || agent === "claude") {
+    files.push(...listClaudeSessionFiles());
+  }
+  if (agent === "auto" || agent === "codex") {
+    files.push(...listCodexSessionFiles());
+  }
+  return files;
+}
+function readDirectoryNames(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+function listJsonlFilesRecursive(root, maxDepth) {
+  const files = [];
+  function visit(dir, depth) {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(fullPath, depth + 1);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        files.push(fullPath);
+      }
+    }
+  }
+  visit(root, 0);
+  return files;
+}
+function statIfReadable(filePath) {
+  try {
+    return statSync(filePath);
+  } catch {
+    return null;
+  }
+}
+function newestSessionFile(agent) {
+  let newest = null;
+  for (const candidate of listSessionFiles(agent)) {
+    if (!newest || candidate.mtimeMs > newest.mtimeMs) {
+      newest = candidate;
+    }
+  }
+  return newest;
+}
+function sessionIdFromClaudeFilePath(filePath) {
+  return basename(filePath, ".jsonl");
+}
+function sessionIdFromCodexFilePath(filePath) {
+  const match = basename(filePath, ".jsonl").match(UUID_IN_TEXT_RE);
+  return match?.[0] ?? null;
+}
+function readCodexSessionId(filePath) {
+  try {
+    for (const line of normalizedJsonLines(readFileSync(filePath)).slice(
+      0,
+      20
+    )) {
+      const parsed = parseJsonLine(line);
+      if (!parsed || typeof parsed !== "object") continue;
+      const record = parsed;
+      const payload = record.payload && typeof record.payload === "object" ? record.payload : null;
+      const id = record.type === "session_meta" && typeof payload?.id === "string" ? payload.id : null;
+      if (id && UUID_RE.test(id)) return id;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function sessionSearchDescription(agent) {
+  if (agent === "claude") return "~/.claude/projects/*/<session-id>.jsonl";
+  if (agent === "codex") return "~/.codex/sessions/**/*.jsonl";
+  return "~/.claude/projects/*/<session-id>.jsonl or ~/.codex/sessions/**/*.jsonl";
+}
+function parseSessionAgent(value) {
+  const normalized = String(value || "auto").trim().toLowerCase();
+  if (normalized === "auto" || normalized === "claude" || normalized === "codex") {
+    return normalized;
+  }
+  throw new Error("Invalid --agent value. Expected auto, claude, or codex.");
+}
+function parseSessionRating(value) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "poor") return "bad";
+  if (normalized === "good" || normalized === "bad" || normalized === "neutral") {
+    return normalized;
+  }
+  throw new Error("Invalid --rating value. Expected good, poor, or neutral.");
+}
+function findSessionFile(sessionId, agent) {
+  if (!UUID_RE.test(sessionId)) {
+    throw new Error(
+      "Invalid session ID format. Expected a UUID such as 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca."
+    );
+  }
+  for (const candidate of listSessionFiles(agent)) {
+    if (candidate.sessionId === sessionId) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveSessionTargets(input) {
+  const agent = parseSessionAgent(input.agent);
+  const targets = [];
+  if (input.currentSession) {
+    const currentFile = newestSessionFile(agent);
+    if (!currentFile) {
+      throw new Error(
+        `No session files found in ${sessionSearchDescription(agent)}.`
+      );
+    }
+    targets.push({
+      sessionId: currentFile.sessionId,
+      label: `${currentFile.agent}-session-${currentFile.sessionId}`,
+      filePath: currentFile.filePath,
+      agent: currentFile.agent
+    });
+  }
+  for (const [index, sessionId] of (input.sessionIds ?? []).entries()) {
+    const candidate = findSessionFile(sessionId, agent);
+    if (!candidate) {
+      throw new Error(
+        `Session file not found in ${sessionSearchDescription(agent)}: ${sessionId}`
+      );
+    }
+    targets.push({
+      sessionId,
+      label: input.labels?.[index] ?? `${candidate.agent}-session-${sessionId}`,
+      filePath: candidate.filePath,
+      agent: candidate.agent
+    });
+  }
+  if (targets.length === 0) {
+    throw new Error("One of --session-id or --current-session is required.");
+  }
+  return targets;
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function normalizedJsonLines(raw) {
+  return raw.toString("utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function stripNoiseEvents(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (parsed && typeof parsed === "object" && NOISE_EVENT_TYPES.has(String(parsed.type ?? ""))) {
+      continue;
+    }
+    lines.push(line);
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function messageContentKey(value) {
+  const message = value.message;
+  if (!message || typeof message !== "object") return null;
+  const content = message.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+  return content.map((block) => {
+    if (!block || typeof block !== "object") return String(block);
+    const record = block;
+    const type = String(record.type ?? "");
+    if (type === "tool_use") {
+      return `tool_use:${String(record.name ?? "")}:${String(record.id ?? "")}`;
+    }
+    if (type === "tool_result") {
+      return `tool_result:${String(record.tool_use_id ?? "")}`;
+    }
+    return String(record.text ?? type);
+  }).join("\n");
+}
+function dedupConsecutiveEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const output = [];
+  let index = 0;
+  while (index < parsedEvents.length) {
+    const event = parsedEvents[index];
+    if (!event || typeof event !== "object") {
+      output.push(rawLines[index] ?? "");
+      index += 1;
+      continue;
+    }
+    const record = event;
+    const eventType = String(record.type ?? "");
+    const eventKey = messageContentKey(record);
+    if (!["user", "assistant"].includes(eventType) || !eventKey) {
+      output.push(rawLines[index] ?? "");
+      index += 1;
+      continue;
+    }
+    let runCount = 1;
+    let cursor = index + 1;
+    while (cursor < parsedEvents.length) {
+      const next = parsedEvents[cursor];
+      if (!next || typeof next !== "object") break;
+      const nextRecord = next;
+      if (String(nextRecord.type ?? "") !== eventType || messageContentKey(nextRecord) !== eventKey) {
+        break;
+      }
+      runCount += 1;
+      cursor += 1;
+    }
+    if (runCount > 1) {
+      record._repeat_count = runCount;
+      record._repeat_summary = `${runCount} consecutive identical ${eventType} messages collapsed`;
+      output.push(JSON.stringify(record));
+      index = cursor;
+      continue;
+    }
+    output.push(rawLines[index] ?? "");
+    index += 1;
+  }
+  return Buffer.from(output.length > 0 ? `${output.join("\n")}
+` : "", "utf8");
+}
+function compactEventValue(value) {
+  if (typeof value === "string") {
+    if (value.length <= MAX_EVENT_STRING_CHARS) return value;
+    return `${value.slice(0, MAX_EVENT_STRING_CHARS - TRUNCATION_MARKER.length)}${TRUNCATION_MARKER}`;
+  }
+  if (Array.isArray(value)) {
+    const compacted = value.slice(0, MAX_EVENT_LIST_ITEMS).map(compactEventValue);
+    if (value.length > MAX_EVENT_LIST_ITEMS) {
+      compacted.push(
+        `${TRUNCATION_MARKER} ${value.length - MAX_EVENT_LIST_ITEMS} more item(s)`
+      );
+    }
+    return compacted;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value);
+    const compacted = {};
+    for (const [key, item] of entries.slice(0, MAX_EVENT_OBJECT_KEYS)) {
+      compacted[key] = compactEventValue(item);
+    }
+    if (entries.length > MAX_EVENT_OBJECT_KEYS) {
+      compacted._truncated_keys = entries.length - MAX_EVENT_OBJECT_KEYS;
+    }
+    return compacted;
+  }
+  return value;
+}
+function selectiveCompactToolResults(raw) {
+  const lines = [];
+  for (const line of normalizedJsonLines(raw)) {
+    const parsed = parseJsonLine(line);
+    if (!parsed || typeof parsed !== "object") {
+      lines.push(line);
+      continue;
+    }
+    const record = parsed;
+    if (record.type === "user") {
+      const message = record.message;
+      const content = message && typeof message === "object" ? message.content : null;
+      if (Array.isArray(content)) {
+        message.content = content.map(
+          (block) => block && typeof block === "object" && block.type === "tool_result" ? compactEventValue(block) : block
+        );
+      }
+    }
+    lines.push(JSON.stringify(record));
+  }
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function compactCodexEvents(raw) {
+  const rawLines = normalizedJsonLines(raw);
+  const parsedEvents = rawLines.map(parseJsonLine);
+  const isCodex = parsedEvents.some(
+    (event) => event && typeof event === "object" && event.type === "session_meta"
+  );
+  if (!isCodex) return raw;
+  let lastTokenCountIndex = -1;
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") return;
+    const payload = event.payload;
+    if (payload && typeof payload === "object" && payload.type === "token_count") {
+      lastTokenCountIndex = index;
+    }
+  });
+  const lines = [];
+  parsedEvents.forEach((event, index) => {
+    if (!event || typeof event !== "object") {
+      lines.push(rawLines[index] ?? "");
+      return;
+    }
+    const record = event;
+    if (record.type === "world_state") return;
+    const payload = record.payload;
+    const payloadType = payload && typeof payload === "object" ? String(payload.type ?? "") : "";
+    if (payloadType === "token_count" && index !== lastTokenCountIndex) return;
+    if (payloadType === "custom_tool_call_output" || payloadType === "function_call_output" || payloadType === "tool_search_output") {
+      const record_payload = payload;
+      record_payload.output = compactEventValue(record_payload.output);
+      lines.push(JSON.stringify(record));
+      return;
+    }
+    lines.push(rawLines[index] ?? "");
+  });
+  return Buffer.from(lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf8");
+}
+function prepareSessionBuffer(raw) {
+  return selectiveCompactToolResults(
+    dedupConsecutiveEvents(compactCodexEvents(stripNoiseEvents(raw)))
+  );
+}
+function buildSessionUploadContent(raw) {
+  const prepared = prepareSessionBuffer(raw);
+  const encoded = gzipSync(prepared).toString("base64");
+  if (encoded.length <= MAX_SESSION_UPLOAD_BYTES && prepared.length <= MAX_DIRECT_SESSION_DECODED_BYTES) {
+    return { encodedContent: encoded, needsChunking: false };
+  }
+  return { encodedContent: encoded, needsChunking: true };
+}
+async function uploadPayload(path, payload) {
+  const { http } = getAuthedHttpClient();
+  return await http.post(path, payload);
+}
+async function uploadChunkedSessions(sessions, options) {
+  const uploadId = randomUUID();
+  for (const session of sessions) {
+    const bytes = Buffer.from(session.encodedContent, "base64");
+    const chunks = [];
+    for (let offset = 0; offset < bytes.length; offset += CHUNK_SIZE_BYTES) {
+      chunks.push(bytes.subarray(offset, offset + CHUNK_SIZE_BYTES));
+    }
+    process.stderr.write(
+      `Uploading ${session.label} in ${chunks.length} chunk(s)...
+`
+    );
+    for (const [index, chunk] of chunks.entries()) {
+      await uploadPayload("/api/v2/cli/send-session/chunk", {
+        upload_id: uploadId,
+        session_id: session.sessionId,
+        index,
+        total_chunks: chunks.length,
+        data: chunk.toString("base64")
+      });
+    }
+  }
+  const response = await uploadPayload("/api/v2/cli/send-session/finalize", {
+    upload_id: uploadId,
+    session_ids: sessions.map((session) => session.sessionId),
+    labels: sessions.map((session) => session.label),
+    environments: sessions.map(() => detectShellContext()),
+    ...options.rating ? { rating: options.rating } : {}
+  });
+  printCommandEnvelope(
+    {
+      ...response,
+      ok: true,
+      uploaded: sessions.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports (chunked)."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+async function handleSessionsSend(options) {
+  const rating = parseSessionRating(options.rating);
+  if (options.file) {
+    const filePath = resolve(options.file);
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${options.file}`);
+    }
+    const response2 = await uploadPayload("/api/v2/cli/send-session", {
+      file: readFileSync(filePath).toString("base64"),
+      filename: basename(filePath),
+      ...rating ? { rating } : {}
+    });
+    printCommandEnvelope(
+      {
+        ...response2,
+        ok: true,
+        filename: basename(filePath),
+        render: {
+          sections: [
+            {
+              title: "sessions send",
+              lines: [
+                `File '${basename(filePath)}' uploaded to #internal-reports.`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return;
+  }
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession,
+    agent: options.agent
+  });
+  const built = targets.map((target) => {
+    const upload = buildSessionUploadContent(readFileSync(target.filePath));
+    return { ...target, ...upload };
+  });
+  if (built.some((session) => session.needsChunking)) {
+    await uploadChunkedSessions(built, { json: options.json, rating });
+    return;
+  }
+  const response = built.length === 1 && !options.label?.length ? await uploadPayload("/api/v2/cli/send-session", {
+    session_id: built[0]?.sessionId,
+    content: built[0]?.encodedContent,
+    environment: detectShellContext(),
+    ...rating ? { rating } : {}
+  }) : await uploadPayload("/api/v2/cli/send-session", {
+    sessions: built.map((session) => ({
+      session_id: session.sessionId,
+      content: session.encodedContent,
+      label: session.label,
+      environment: detectShellContext()
+    })),
+    environment: detectShellContext(),
+    ...rating ? { rating } : {}
+  });
+  printCommandEnvelope(
+    {
+      ...response,
+      ok: true,
+      uploaded: built.length,
+      render: {
+        sections: [
+          {
+            title: "sessions send",
+            lines: ["Session uploaded to #internal-reports."]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function loadViewerAssets() {
+  const cliEntry = process.argv[1]?.trim() ? realpathSync(resolve(process.argv[1])) : null;
+  const candidateRoots = [
+    ...cliEntry ? [
+      join(dirname(dirname(cliEntry)), "viewer"),
+      join(
+        dirname(dirname(dirname(cliEntry))),
+        "src",
+        "lib",
+        "cli",
+        "viewer"
+      )
+    ] : [],
+    join(process.cwd(), "packages", "sdk", "assets", "viewer")
+  ];
+  for (const root of candidateRoots) {
+    try {
+      const cssPath = join(root, "viewer.css");
+      const jsPath = join(root, "viewer.js");
+      if (!existsSync(cssPath) || !existsSync(jsPath)) continue;
+      return {
+        css: readFileSync(cssPath, "utf8"),
+        js: readFileSync(jsPath, "utf8")
+      };
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(
+    `Session viewer assets not found. Reinstall the CLI or build its viewer assets. Searched: ${candidateRoots.join(", ")}`
+  );
+}
+function parsePreparedEvents(buffer) {
+  return normalizedJsonLines(buffer).map((line) => {
+    const parsed = parseJsonLine(line);
+    return parsed ?? line;
+  });
+}
+function escapeJsonForHtmlScript(json) {
+  return json.replace(/</g, "\\u003c");
+}
+async function handleSessionsRender(options) {
+  const targets = resolveSessionTargets({
+    sessionIds: options.sessionId,
+    labels: options.label,
+    currentSession: options.currentSession,
+    agent: options.agent
+  });
+  let outputPath = options.output ? resolve(options.output) : "";
+  if (!outputPath) {
+    const outputDir = join(process.cwd(), "deepline", "data");
+    mkdirSync(outputDir, { recursive: true });
+    outputPath = join(
+      outputDir,
+      targets.length > 1 ? "session-viewer.html" : `session-${targets[0]?.sessionId}.html`
+    );
+  } else {
+    mkdirSync(dirname(outputPath), { recursive: true });
+  }
+  const sessions = targets.map((target) => ({
+    label: target.label,
+    events: parsePreparedEvents(
+      prepareSessionBuffer(readFileSync(target.filePath))
+    )
+  }));
+  const { css, js } = loadViewerAssets();
+  const refreshMeta = options.autoRefresh ? `<meta http-equiv="refresh" content="${Number.parseInt(options.autoRefresh, 10)}">` : "";
+  const rawJson = escapeJsonForHtmlScript(JSON.stringify(sessions));
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+${refreshMeta}
+<title>Session Viewer</title>
+<style>${css}</style>
+</head>
+<body>
+<div class="layout">
+  <div class="sidebar hidden" id="sidebar"></div>
+  <div class="run-sidebar hidden" id="run-sidebar"></div>
+  <div class="main" id="main-content"></div>
+</div>
+<script type="application/json" id="raw-sessions">${rawJson}</script>
+<script>${js}</script>
+</body>
+</html>`;
+  writeFileSync(outputPath, html, "utf8");
+  printCommandEnvelope(
+    {
+      ok: true,
+      file: outputPath,
+      session_count: targets.length,
+      render: {
+        sections: [
+          {
+            title: "sessions render",
+            lines: [`Rendered session viewer: ${outputPath}`]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+}
+function collectOption(value, previous) {
+  previous.push(value);
+  return previous;
+}
+function registerSessionsCommands(program) {
+  const sessions = program.command("sessions").description("Upload and render local agent session transcripts.").addHelpText(
+    "after",
+    `
+Notes:
+  Session commands operate on local Claude and Codex JSONL files under
+  ~/.claude/projects and ~/.codex/sessions. send uploads a compacted transcript
+  or file to Deepline. render writes a local HTML viewer.
+
+Examples:
+  deepline sessions send --current-session --json
+  deepline sessions send --agent codex --current-session --json
+  deepline sessions send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca
+  deepline sessions render --current-session --output session.html
+`
+  );
+  registerSessionSendRenderCommands(sessions, "sessions");
+}
+function registerSessionSendRenderCommands(parent, familyName) {
+  parent.command("send").description("Upload session transcript(s) or a local file to Deepline.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline ${familyName} send --current-session --json
+  deepline ${familyName} send --agent codex --current-session --json
+  deepline ${familyName} send --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --label "pilot run"
+  deepline ${familyName} send --current-session --rating poor --json   # tag the session as one that went poorly
+  deepline ${familyName} send --file ./debug.log --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude or Codex session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option(
+    "--agent <auto|claude|codex>",
+    "Limit transcript discovery to one agent runtime",
+    "auto"
+  ).option("--current-session", "Use the newest local agent session JSONL").option("--file <path>", "Upload a raw local file instead of a session").option(
+    "--rating <good|poor|neutral>",
+    "Tag the upload by outcome, not tone, so Deepline can filter sessions: good = the user's goal was met without product problems; poor = the goal was missed, or a product failure, bug, or avoidable friction (including a substantial workaround) got in the way; neutral = partly met or unclear."
+  ).option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsSend);
+  parent.command("render").description("Render local session transcript(s) to an HTML viewer.").addHelpText(
+    "after",
+    `
+Examples:
+  deepline ${familyName} render --current-session
+  deepline ${familyName} render --agent codex --current-session
+  deepline ${familyName} render --session-id 5a3bfb97-a2d9-49d9-82c6-52ccc03dadca --output session.html
+  deepline ${familyName} render --current-session --auto-refresh 5 --json
+`
+  ).option(
+    "--session-id <uuid>",
+    "Claude or Codex session UUID. Repeat for multiple sessions.",
+    collectOption,
+    []
+  ).option(
+    "--label <label>",
+    "Label for the preceding session id",
+    collectOption,
+    []
+  ).option(
+    "--agent <auto|claude|codex>",
+    "Limit transcript discovery to one agent runtime",
+    "auto"
+  ).option("--current-session", "Use the newest local agent session JSONL").option("--auto-refresh <seconds>", "Add a browser auto-refresh interval").option("-o, --output <path>", "Output HTML path").option("--json", "Emit JSON output. Also automatic when stdout is piped").action(handleSessionsRender);
+}
+
+export {
+  registerSessionsCommands,
+  registerSessionSendRenderCommands
+};