@agentsky/sky 2.10.0 → 2.12.0

package/dist/trace-library-474QJTAZ.js

@@ -0,0 +1,710 @@
+import {
+  ApiError
+} from "./chunk-7LUCHBX6.js";
+import {
+  USER_AGENT,
+  apiBase,
+  apiToken
+} from "./chunk-RF5JICNX.js";
+import {
+  redactTraceText
+} from "./chunk-XXDQKVPS.js";
+import "./chunk-MLKGABMK.js";
+
+// src/trace-library.ts
+import { createHash } from "crypto";
+import { createReadStream, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { createInterface } from "readline";
+import { homedir, hostname } from "os";
+import { basename, dirname, join, sep } from "path";
+import { createGunzip } from "zlib";
+var MESSAGE_MAX_BYTES = 8 * 1024;
+var TOOL_MAX_BYTES = 2 * 1024;
+var MESSAGES_MAX = 2e4;
+var BODY_MAX_BYTES = 7 * 1024 * 1024;
+var CHECK_BATCH = 200;
+var UPLOAD_CONCURRENCY = 4;
+var FULL_SWEEP_MS = 7 * 24 * 60 * 60 * 1e3;
+var RETRIES = 3;
+var RATE_LIMIT_RETRIES = 30;
+var HARNESS_PREAMBLES = ["<environment_context>", "<user_instructions>", "<permissions instructions>", "# AGENTS.md instructions", "<INSTRUCTIONS>", "<external_codex_apps_open_page>"];
+var titleOf = (text) => /^\s*</.test(text) ? void 0 : text.trim().slice(0, 120) || void 0;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var backoffMs = (attempt) => Math.min(3e4, 1e3 * 2 ** attempt);
+function skyDir() {
+  return process.env.SKY_CONFIG_DIR ?? join(homedir(), ".config", "sky");
+}
+function syncConfigPath() {
+  return join(skyDir(), "trace-sync.json");
+}
+function statePath() {
+  return join(skyDir(), "trace-sync-state.json");
+}
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+}
+function loadSyncConfig() {
+  return readJson(syncConfigPath(), { enabled: false, rules: [] });
+}
+function saveSyncConfig(config) {
+  writeJson(syncConfigPath(), config);
+}
+function claudeRoot() {
+  return join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects");
+}
+function codexRoot() {
+  return process.env.CODEX_HOME ?? join(homedir(), ".codex");
+}
+function sourceFolders() {
+  return [claudeRoot(), join(codexRoot(), "sessions"), join(codexRoot(), "archived_sessions")];
+}
+function signatureOf(files) {
+  const parts = [];
+  for (const file of files) {
+    try {
+      const stat = statSync(file);
+      parts.push(`${file}:${stat.size}:${Math.floor(stat.mtimeMs)}`);
+    } catch {
+      return null;
+    }
+  }
+  return parts.join("|");
+}
+function claudeSessions() {
+  const root = claudeRoot();
+  const found = [];
+  let projects;
+  try {
+    projects = readdirSync(root);
+  } catch {
+    return found;
+  }
+  for (const project of projects) {
+    const dir = join(root, project);
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".jsonl")) continue;
+      const sessionId = entry.slice(0, -".jsonl".length);
+      const files = [join(dir, entry)];
+      const subagents = join(dir, sessionId, "subagents");
+      try {
+        files.push(...readdirSync(subagents).filter((name) => name.endsWith(".jsonl")).sort().map((name) => join(subagents, name)));
+      } catch {
+      }
+      const signature = signatureOf(files);
+      if (signature) found.push({ harness: "claude_code", sessionId, files, signature });
+    }
+  }
+  return found;
+}
+async function* readLines(file) {
+  const raw = createReadStream(file);
+  const input = file.endsWith(".gz") ? raw.pipe(createGunzip()) : raw;
+  const reader = createInterface({ input, crlfDelay: Infinity });
+  try {
+    for await (const line of reader) yield line;
+  } finally {
+    reader.close();
+    raw.destroy();
+  }
+}
+async function firstLine(file) {
+  for await (const line of readLines(file)) return line.length > 1024 * 1024 ? "" : line;
+  return "";
+}
+function codexIdCachePath() {
+  return join(skyDir(), "trace-sync-codex-ids.json");
+}
+async function codexSessions() {
+  const byId = /* @__PURE__ */ new Map();
+  const cached = readJson(codexIdCachePath(), {});
+  const seen = {};
+  const walk = async (dir) => {
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+        continue;
+      }
+      if (!entry.name.startsWith("rollout-") || !/\.jsonl(\.gz)?$/.test(entry.name)) continue;
+      const signature = signatureOf([full]);
+      if (!signature) continue;
+      let id = cached[full]?.signature === signature ? cached[full].id : void 0;
+      if (!id) {
+        try {
+          const meta = JSON.parse(await firstLine(full));
+          if (meta?.type === "session_meta" && typeof meta.payload?.id === "string") id = meta.payload.id;
+        } catch {
+          continue;
+        }
+      }
+      if (!id) continue;
+      seen[full] = { signature, id };
+      const mtime = statSync(full).mtimeMs;
+      const known = byId.get(id);
+      if (!known || mtime > known.mtime) byId.set(id, { harness: "codex", sessionId: id, files: [full], signature, mtime });
+    }
+  };
+  await walk(join(codexRoot(), "sessions"));
+  await walk(join(codexRoot(), "archived_sessions"));
+  try {
+    writeJson(codexIdCachePath(), seen);
+  } catch {
+  }
+  return [...byId.values()].map(({ mtime: _mtime, ...session }) => session);
+}
+function claudeSessionAt(path) {
+  const root = claudeRoot();
+  if (!path.startsWith(`${root}${sep}`) || !path.endsWith(".jsonl") || basename(dirname(dirname(path))) !== basename(root)) return null;
+  const sessionId = basename(path, ".jsonl");
+  const files = [path];
+  const subagents = join(dirname(path), sessionId, "subagents");
+  try {
+    files.push(...readdirSync(subagents).filter((name) => name.endsWith(".jsonl")).sort().map((name) => join(subagents, name)));
+  } catch {
+  }
+  const signature = signatureOf(files);
+  return signature ? { harness: "claude_code", sessionId, files, signature } : null;
+}
+async function discoverSessions() {
+  return [...claudeSessions(), ...await codexSessions()];
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function str(value) {
+  return typeof value === "string" && value.length ? value : void 0;
+}
+function toolResultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((part) => str(asRecord(part)?.text) ?? "").filter(Boolean).join("\n");
+  return "";
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "";
+  }
+}
+var Collector = class {
+  messages = [];
+  partial = false;
+  bytes = 0;
+  push(role, text, at) {
+    const trimmed = text.replace(/\u0000/g, "").trim();
+    if (!trimmed) return;
+    if (this.messages.length >= MESSAGES_MAX) {
+      this.partial = true;
+      return;
+    }
+    const safe = redactTraceText(trimmed, role === "tool" ? TOOL_MAX_BYTES : MESSAGE_MAX_BYTES);
+    if (safe.truncated) this.partial = true;
+    this.bytes += Buffer.byteLength(safe.text) + 80;
+    this.messages.push({ role, text: safe.text, ...at ? { at } : {} });
+  }
+};
+function isoOrUndefined(value) {
+  const text = str(value);
+  if (!text) return void 0;
+  const time = Date.parse(text);
+  return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
+}
+async function parseClaudeSession(session) {
+  const out = { harness: "claude_code", sessionId: session.sessionId, userTurns: 0, toolCalls: 0, partial: false, messages: [] };
+  const collector = new Collector();
+  for (const [index, file] of session.files.entries()) {
+    for await (const line of readLines(file)) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = asRecord(JSON.parse(line));
+      } catch {
+        out.partial = true;
+        continue;
+      }
+      if (!record) continue;
+      const at = isoOrUndefined(record.timestamp);
+      if (index === 0) {
+        out.cwd ??= str(record.cwd);
+        out.gitBranch ??= str(record.gitBranch);
+        out.harnessVersion ??= str(record.version);
+        if (at) {
+          out.startedAt ??= at;
+          out.endedAt = at;
+        }
+      }
+      const message = asRecord(record.message);
+      if (!message || record.isMeta === true) continue;
+      if (record.type === "user") {
+        const content = message.content;
+        if (typeof content === "string") {
+          collector.push("user", content, at);
+          if (index === 0) out.userTurns += 1;
+          if (index === 0) out.title ??= titleOf(content);
+          continue;
+        }
+        if (!Array.isArray(content)) continue;
+        let typed = false;
+        for (const part of content.map(asRecord)) {
+          if (part?.type === "text" && str(part.text)) {
+            collector.push("user", part.text, at);
+            typed = true;
+            if (index === 0) out.title ??= titleOf(part.text);
+          } else if (part?.type === "tool_result") {
+            collector.push("tool", toolResultText(part.content), at);
+          }
+        }
+        if (typed && index === 0) out.userTurns += 1;
+      } else if (record.type === "assistant") {
+        if (index === 0) out.model ??= str(message.model);
+        const content = Array.isArray(message.content) ? message.content.map(asRecord) : [];
+        for (const part of content) {
+          if (part?.type === "text") collector.push("assistant", str(part.text) ?? "", at);
+          else if (part?.type === "tool_use") {
+            out.toolCalls += 1;
+            collector.push("tool", `${str(part.name) ?? "tool"} ${stringify(part.input)}`, at);
+          }
+        }
+      }
+    }
+  }
+  return finish(out, collector);
+}
+async function parseCodexSession(session) {
+  const out = { harness: "codex", sessionId: session.sessionId, userTurns: 0, toolCalls: 0, partial: false, messages: [] };
+  const collector = new Collector();
+  for await (const line of readLines(session.files[0])) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      record = asRecord(JSON.parse(line));
+    } catch {
+      out.partial = true;
+      continue;
+    }
+    const payload = asRecord(record?.payload);
+    if (!record || !payload) continue;
+    const at = isoOrUndefined(record.timestamp);
+    if (at) {
+      out.startedAt ??= at;
+      out.endedAt = at;
+    }
+    if (record.type === "session_meta") {
+      out.cwd ??= str(payload.cwd);
+      out.harnessVersion ??= str(payload.cli_version);
+      const git = asRecord(payload.git);
+      out.gitBranch ??= str(git?.branch);
+      out.gitCommit ??= str(git?.commit_hash);
+    } else if (record.type === "turn_context") {
+      out.model ??= str(payload.model);
+      out.cwd ??= str(payload.cwd);
+    } else if (record.type === "response_item") {
+      if (payload.type === "message") {
+        const role = payload.role === "user" ? "user" : payload.role === "assistant" ? "assistant" : null;
+        if (!role) continue;
+        const text = (Array.isArray(payload.content) ? payload.content : []).map((part) => str(asRecord(part)?.text) ?? "").filter(Boolean).join("\n");
+        if (role === "user" && HARNESS_PREAMBLES.some((prefix) => text.trimStart().startsWith(prefix))) continue;
+        collector.push(role, text, at);
+        if (role === "user" && text.trim()) {
+          out.userTurns += 1;
+          out.title ??= titleOf(text);
+        }
+      } else if (payload.type === "function_call" || payload.type === "custom_tool_call" || payload.type === "local_shell_call") {
+        out.toolCalls += 1;
+        collector.push("tool", `${str(payload.name) ?? payload.type} ${stringify(payload.arguments ?? payload.input ?? payload.action)}`, at);
+      } else if (payload.type === "function_call_output" || payload.type === "custom_tool_call_output") {
+        const output = asRecord(payload.output);
+        collector.push("tool", str(output?.content) ?? stringify(payload.output), at);
+      }
+    }
+  }
+  return finish(out, collector);
+}
+function finish(out, collector) {
+  let messages = collector.messages;
+  let partial = out.partial || collector.partial;
+  let bytes = collector.bytes;
+  if (bytes > BODY_MAX_BYTES) {
+    messages = messages.map((message) => message.role === "tool" && message.text.length > 256 ? { ...message, text: `${message.text.slice(0, 256)}\u2026` } : message);
+    bytes = messages.reduce((sum, message) => sum + Buffer.byteLength(message.text) + 80, 0);
+    partial = true;
+  }
+  while (bytes > BODY_MAX_BYTES && messages.length) {
+    const dropped = messages.splice(Math.floor(messages.length / 2), Math.max(1, Math.floor(messages.length / 10)));
+    bytes -= dropped.reduce((sum, message) => sum + Buffer.byteLength(message.text) + 80, 0);
+  }
+  return { ...out, title: out.title ? redactTraceText(out.title, 300).text : void 0, partial, messages };
+}
+function isTrivial(session) {
+  if (!session.messages.length) return true;
+  const chars = session.messages.reduce((sum, message) => sum + message.text.length, 0);
+  return session.toolCalls === 0 && session.messages.length <= 2 && chars < 200;
+}
+function sessionDigest(session) {
+  const hash = createHash("sha256");
+  hash.update(`${session.cwd ?? ""}${session.model ?? ""}`);
+  for (const message of session.messages) hash.update(`${message.role}\0${message.text}
`);
+  return hash.digest("hex");
+}
+function projectOf(cwd) {
+  const parts = cwd.split(sep).filter(Boolean);
+  for (const marker of [".worktrees", "worktrees"]) {
+    const at = parts.lastIndexOf(marker);
+    if (at > 0) {
+      const owner = parts[at - 1] === ".claude" ? at - 2 : at - 1;
+      if (owner >= 0) return parts[owner];
+    }
+  }
+  let dir = cwd;
+  while (dir && dir !== dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) return basename(dir);
+    dir = dirname(dir);
+  }
+  return parts.at(-1);
+}
+function workspaceFile(cwd) {
+  let dir = cwd;
+  while (dir && dir !== dirname(dir)) {
+    const file = join(dir, ".agentsky.json");
+    if (existsSync(file)) {
+      const workspace = str(readJson(file, {}).workspace);
+      if (workspace) return workspace;
+    }
+    if (existsSync(join(dir, ".git"))) return void 0;
+    dir = dirname(dir);
+  }
+  return void 0;
+}
+function gitConfigPath(root) {
+  const dotGit = join(root, ".git");
+  try {
+    if (statSync(dotGit).isDirectory()) return join(dotGit, "config");
+    const pointer = readFileSync(dotGit, "utf8").match(/^gitdir:\s*(.+)$/m)?.[1]?.trim();
+    if (!pointer) return void 0;
+    const gitdir = pointer.startsWith("/") ? pointer : join(root, pointer);
+    const common = existsSync(join(gitdir, "commondir")) ? readFileSync(join(gitdir, "commondir"), "utf8").trim() : ".";
+    return join(common.startsWith("/") ? common : join(gitdir, common), "config");
+  } catch {
+    return void 0;
+  }
+}
+function repoRemote(cwd) {
+  let dir = cwd;
+  while (dir && dir !== dirname(dir)) {
+    if (existsSync(join(dir, ".git"))) {
+      const config = gitConfigPath(dir);
+      if (!config) return void 0;
+      try {
+        const text = readFileSync(config, "utf8");
+        return text.match(/\[remote "origin"\][^[]*?url\s*=\s*(\S+)/)?.[1];
+      } catch {
+        return void 0;
+      }
+    }
+    dir = dirname(dir);
+  }
+  return void 0;
+}
+function routeSession(cwd, config) {
+  if (cwd) {
+    const pinned = workspaceFile(cwd);
+    if (pinned) return pinned;
+    const lower = `${cwd}
+${repoRemote(cwd) ?? ""}`.toLowerCase();
+    const rule = config.rules.find((candidate) => lower.includes(candidate.match.toLowerCase()));
+    if (rule) return rule.workspace;
+  }
+  return config.fallback ?? null;
+}
+function homeLabel(path) {
+  if (!path) return void 0;
+  const home = homedir();
+  return path === home || path.startsWith(`${home}${sep}`) ? `~${path.slice(home.length)}` : path;
+}
+async function libraryRequest(method, path, workspace, body, timeoutMs = 12e4) {
+  const token = apiToken();
+  if (!token) throw new ApiError(401, "not_logged_in", "not logged in \u2014 run `sky auth login`");
+  const payload = body ? JSON.stringify(body) : void 0;
+  let res;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      res = await fetch(`${apiBase()}${path}`, {
+        method,
+        headers: { "user-agent": USER_AGENT, authorization: `Bearer ${token}`, "x-universe": workspace, ...payload ? { "content-type": "application/json" } : {} },
+        body: payload,
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+    } catch (error) {
+      if (attempt >= RETRIES) throw error;
+      await sleep(backoffMs(attempt));
+      continue;
+    }
+    if (res.status === 429 && attempt < RATE_LIMIT_RETRIES) {
+      const wait = Number(res.headers.get("retry-after"));
+      await sleep(Number.isFinite(wait) && wait > 0 ? Math.min(wait, 65) * 1e3 : backoffMs(attempt));
+      continue;
+    }
+    if (res.status >= 500 && res.status !== 503 && attempt < RETRIES) {
+      await sleep(backoffMs(attempt));
+      continue;
+    }
+    break;
+  }
+  if (!res.ok) {
+    let code = "http_error";
+    let message = `${res.status} ${res.statusText}`;
+    try {
+      const parsed = await res.json();
+      code = parsed.error?.code ?? code;
+      message = parsed.error?.message ?? message;
+    } catch {
+    }
+    throw new ApiError(res.status, code, message);
+  }
+  return await res.json();
+}
+function uploadBody(session, sha256, device) {
+  const cwd = homeLabel(session.cwd);
+  return {
+    sha256,
+    ...session.title ? { title: session.title } : {},
+    ...cwd ? { cwd: cwd.slice(0, 1024) } : {},
+    ...session.cwd && projectOf(session.cwd) ? { project: projectOf(session.cwd).slice(0, 200) } : {},
+    ...session.gitBranch ? { git_branch: session.gitBranch.slice(0, 300) } : {},
+    ...session.gitCommit ? { git_commit: session.gitCommit.slice(0, 80) } : {},
+    ...session.model ? { model: session.model.slice(0, 200) } : {},
+    ...session.harnessVersion ? { harness_version: session.harnessVersion.slice(0, 80) } : {},
+    device: device.slice(0, 200),
+    ...session.startedAt ? { started_at: session.startedAt } : {},
+    ...session.endedAt ? { ended_at: session.endedAt } : {},
+    user_turns: session.userTurns,
+    tool_calls: session.toolCalls,
+    partial: session.partial,
+    messages: session.messages
+  };
+}
+function lockPath() {
+  return join(skyDir(), "trace-sync.lock");
+}
+function takeLock() {
+  const path = lockPath();
+  mkdirSync(skyDir(), { recursive: true });
+  try {
+    mkdirSync(path);
+  } catch {
+    const pid = Number(readJson(join(path, "pid.json"), {}).pid);
+    let alive = false;
+    try {
+      if (pid) {
+        process.kill(pid, 0);
+        alive = true;
+      }
+    } catch {
+      alive = false;
+    }
+    if (alive) return false;
+    rmSync(path, { recursive: true, force: true });
+    try {
+      mkdirSync(path);
+    } catch {
+      return false;
+    }
+  }
+  writeJson(join(path, "pid.json"), { pid: process.pid });
+  return true;
+}
+function releaseLock() {
+  rmSync(lockPath(), { recursive: true, force: true });
+}
+async function pool(items, size, fn) {
+  let next = 0;
+  await Promise.all(Array.from({ length: Math.min(size, items.length) }, async () => {
+    while (next < items.length) await fn(items[next++]);
+  }));
+}
+async function syncTraces(options = {}) {
+  const config = loadSyncConfig();
+  if (!config.enabled) throw new Error("trace sync is off on this machine \u2014 turn it on with `sky trace sync --enable`");
+  if (!options.dryRun && !takeLock()) return null;
+  try {
+    return await runSync(config, options);
+  } finally {
+    if (!options.dryRun) releaseLock();
+  }
+}
+async function runSync(config, options) {
+  const state = readJson(statePath(), { sessions: {} });
+  const full = options.full || !state.lastFullAt || Date.now() - Date.parse(state.lastFullAt) > FULL_SWEEP_MS;
+  const device = config.device ?? hostname();
+  const report = { scanned: 0, changed: 0, uploaded: 0, unchanged: 0, local: 0, owned: 0, empty: 0, failed: 0, byWorkspace: {}, errors: [] };
+  const direct = options.only?.length ? options.only.map(claudeSessionAt) : [];
+  let sessions = direct.length && direct.every(Boolean) ? direct : await discoverSessions();
+  if (options.only?.length) {
+    const wanted = new Set(options.only);
+    sessions = sessions.filter((s) => wanted.has(s.sessionId) || s.files.some((file) => wanted.has(file)));
+  }
+  report.scanned = sessions.length;
+  const key = (s) => `${s.harness}:${s.sessionId}`;
+  let pending = sessions.filter((s) => full || state.sessions[key(s)]?.signature !== s.signature);
+  if (options.limit) pending = pending.slice(0, options.limit);
+  report.changed = pending.length;
+  const record = (s, value) => {
+    state.sessions[key(s)] = { signature: s.signature, at: (/* @__PURE__ */ new Date()).toISOString(), ...value };
+  };
+  const ready = /* @__PURE__ */ new Map();
+  for (const local of pending) {
+    let parsed;
+    try {
+      parsed = local.harness === "claude_code" ? await parseClaudeSession(local) : await parseCodexSession(local);
+    } catch (error) {
+      report.failed += 1;
+      report.errors.push(`${key(local)}: unreadable (${error.message})`);
+      continue;
+    }
+    if (isTrivial(parsed)) {
+      report.empty += 1;
+      record(local, { workspace: null, status: "empty" });
+      continue;
+    }
+    const workspace = routeSession(parsed.cwd, config);
+    if (!workspace) {
+      report.local += 1;
+      record(local, { workspace: null, status: "local" });
+      continue;
+    }
+    const sha256 = sessionDigest(parsed);
+    const previous = state.sessions[key(local)];
+    if (!full && previous?.sha256 === sha256 && previous.workspace === workspace && previous.status === "stored") {
+      report.unchanged += 1;
+      record(local, { workspace, sha256, status: "stored" });
+      continue;
+    }
+    ready.set(workspace, [...ready.get(workspace) ?? [], { local, parsed, sha256 }]);
+  }
+  for (const [workspace, items] of ready) {
+    for (let start = 0; start < items.length; start += CHECK_BATCH) {
+      const batch = items.slice(start, start + CHECK_BATCH);
+      let statuses;
+      try {
+        statuses = (await libraryRequest("POST", "/trace-library/check", workspace, {
+          sessions: batch.map((item) => ({ harness: item.parsed.harness, session_id: item.parsed.sessionId, sha256: item.sha256 }))
+        })).sessions;
+      } catch (error) {
+        report.failed += batch.length;
+        report.errors.push(`${workspace}: check failed (${error.message})`);
+        if (error instanceof ApiError && (error.status === 401 || error.status === 403 || error.status === 503)) break;
+        continue;
+      }
+      const toSend = batch.filter((item, index) => {
+        const status = statuses[index]?.status;
+        if (status === "unchanged") {
+          report.unchanged += 1;
+          record(item.local, { workspace, sha256: item.sha256, status: "stored" });
+          return false;
+        }
+        if (status === "owned") {
+          report.owned += 1;
+          record(item.local, { workspace, sha256: item.sha256, status: "owned" });
+          return false;
+        }
+        return true;
+      });
+      if (options.dryRun) {
+        report.uploaded += toSend.length;
+        report.byWorkspace[workspace] = (report.byWorkspace[workspace] ?? 0) + toSend.length;
+        continue;
+      }
+      await pool(toSend, UPLOAD_CONCURRENCY, async (item) => {
+        try {
+          await libraryRequest("PUT", `/trace-library/${item.parsed.harness}/${encodeURIComponent(item.parsed.sessionId)}`, workspace, uploadBody(item.parsed, item.sha256, device));
+          report.uploaded += 1;
+          report.byWorkspace[workspace] = (report.byWorkspace[workspace] ?? 0) + 1;
+          record(item.local, { workspace, sha256: item.sha256, status: "stored" });
+        } catch (error) {
+          report.failed += 1;
+          report.errors.push(`${key(item.local)} \u2192 ${workspace}: ${error.message}`);
+        }
+      });
+      if (!options.dryRun) writeJson(statePath(), state);
+      options.onProgress?.(`${workspace}: ${Math.min(start + CHECK_BATCH, items.length)}/${items.length} checked, ${report.uploaded} uploaded so far`);
+    }
+  }
+  if (!options.dryRun) {
+    if (full && !options.only?.length && !options.limit && report.failed === 0) state.lastFullAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeJson(statePath(), state);
+  }
+  return report;
+}
+function hookSessionRef(payload) {
+  try {
+    const value = asRecord(JSON.parse(payload));
+    return str(value?.transcript_path) ?? str(value?.session_id) ?? str(value?.["thread-id"]) ?? str(value?.thread_id);
+  } catch {
+    return void 0;
+  }
+}
+var LAUNCHD_LABEL = "dev.agentsky.trace-sync";
+function installLaunchd(command, logPath) {
+  if (process.platform !== "darwin") throw new Error("the schedule installer covers macOS; on Linux add `*/15 * * * * sky trace sync --quiet` to your crontab");
+  const plist = join(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+  const escape = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  writeFileSync(plist, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${command.map((part) => `    <string>${escape(part)}</string>`).join("\n")}
+  </array>
+  <key>StartInterval</key><integer>900</integer>
+  <key>RunAtLoad</key><true/>
+  <key>ProcessType</key><string>Background</string>
+  <key>StandardOutPath</key><string>${escape(logPath)}</string>
+  <key>StandardErrorPath</key><string>${escape(logPath)}</string>
+</dict>
+</plist>
+`);
+  return plist;
+}
+export {
+  LAUNCHD_LABEL,
+  discoverSessions,
+  hookSessionRef,
+  installLaunchd,
+  isTrivial,
+  libraryRequest,
+  loadSyncConfig,
+  parseClaudeSession,
+  parseCodexSession,
+  projectOf,
+  repoRemote,
+  routeSession,
+  saveSyncConfig,
+  sessionDigest,
+  sourceFolders,
+  syncConfigPath,
+  syncTraces
+};