@agentsky/sky 2.20.2 → 2.21.0

package/dist/{chunk-HB7SPKQ5.js → chunk-6JMFB3CV.js}

@@ -38,7 +38,7 @@ function currentUniverse() {
 }
 
 // src/version.ts
-var CLI_VERSION = "2.20.2";
+var CLI_VERSION = "2.21.0";
 var USER_AGENT = `sky-cli/${CLI_VERSION} (${process.platform}; node/${process.versions.node})`;
 
 export {

package/dist/{chunk-WTFBVTMI.js → chunk-ZZ6UF7QA.js}

@@ -3,7 +3,7 @@ import {
   apiBase,
   apiToken,
   currentUniverse
-} from "./chunk-HB7SPKQ5.js";
+} from "./chunk-6JMFB3CV.js";
 
 // src/api.ts
 import { createWriteStream, writeFileSync } from "fs";

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   resolveSessionRef,
   streamEvents,
   uploadFile
-} from "./chunk-WTFBVTMI.js";
+} from "./chunk-ZZ6UF7QA.js";
 import {
   CLI_VERSION,
   USER_AGENT,
@@ -20,7 +20,7 @@ import {
   currentUniverse,
   loadConfig,
   saveConfig
-} from "./chunk-HB7SPKQ5.js";
+} from "./chunk-6JMFB3CV.js";
 import {
   AGENT_TYPES,
   MODEL_SUBSCRIPTION_PLAN_PHRASE,
@@ -7093,7 +7093,7 @@ harness.command("connect").description("run an ACP agent (the command after --)
 }));
 var traceCmd = program.command("trace").description("correlate this machine's agent work with the cloud sessions it starts (metadata only unless you choose content)");
 traceCmd.command("start").description("start a trace: a grant for this machine, a root span, and the spool the hooks write to").option("--name <name>", "a name for the task").option("--source <source>", "how this machine reports itself", "claude-code").option("--hooks [settings]", "also install the Claude Code hooks (default: ./.claude/settings.local.json)").option("--capture <scopes>", "also send content, redacted on this machine first: any of prompts,tool_output,files").option("--file <path>", "a file the files scope may send (repeatable)", collect).option("--dir <path>", "a folder whose files the files scope may send when a file tool touches them (repeatable)", collect).action(run(async (opts) => {
-  const { readState, writeState, record, installClaudeHooks, parseContentScopes, chosenPaths, fileEvent } = await import("./trace-HTWXINXI.js");
+  const { readState, writeState, record, installClaudeHooks, parseContentScopes, chosenPaths, fileEvent } = await import("./trace-NMBMU4GS.js");
   if (readState()) throw new Error("a trace is already running here \u2014 `sky trace stop` it first");
   const scopes = parseContentScopes(opts.capture);
   const chosen = chosenPaths(opts.file ?? [], opts.dir ?? []);
@@ -7128,7 +7128,7 @@ traceCmd.command("start").description("start a trace: a grant for this machine,
 }));
 traceCmd.command("hook").description("record one Claude Code hook event read from stdin (run by the installed hooks; never fails, prints nothing)").action(async () => {
   try {
-    const { readState, record, flush, grantSender, eventsForClaudeHook, contentForClaudeHook, clearState } = await import("./trace-HTWXINXI.js");
+    const { readState, record, flush, grantSender, eventsForClaudeHook, contentForClaudeHook, clearState } = await import("./trace-NMBMU4GS.js");
     const chunks = [];
     for await (const chunk of process.stdin) chunks.push(chunk);
     const input = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
@@ -7141,14 +7141,14 @@ traceCmd.command("hook").description("record one Claude Code hook event read fro
   }
 });
 traceCmd.command("flush").description("send what the spool holds, retrying with backoff").action(run(async () => {
-  const { readState, flush, grantSender } = await import("./trace-HTWXINXI.js");
+  const { readState, flush, grantSender } = await import("./trace-NMBMU4GS.js");
   const state = readState();
   if (!state) throw new Error("no trace is running here");
   const outcome = await flush(grantSender(state), { attempts: 4 });
   console.log(`sent ${outcome.sent}, refused ${outcome.refused}, given up ${outcome.expired}, still pending ${outcome.pending}${outcome.stopped ? ` (stopped: ${outcome.stopped})` : ""}`);
 }));
 traceCmd.command("status").description("the running trace and its spool").action(run(async () => {
-  const { readState, spoolStatus } = await import("./trace-HTWXINXI.js");
+  const { readState, spoolStatus } = await import("./trace-NMBMU4GS.js");
   const state = readState();
   if (!state) {
     console.log("No trace is running here.");
@@ -7158,7 +7158,7 @@ traceCmd.command("status").description("the running trace and its spool").action
   console.log(`${state.trace_id} as ${state.source}: ${spool.pending} pending, ${spool.dropped_full} dropped (spool full), ${spool.dropped_expired} given up, ${spool.refused} refused`);
 }));
 traceCmd.command("show [id]").description("the trace bundle: spans, the sessions they reach, cost counted once per session").option("--json", "print the bundle as JSON").action(run(async (id, opts) => {
-  const { readState } = await import("./trace-HTWXINXI.js");
+  const { readState } = await import("./trace-NMBMU4GS.js");
   const ref = id ?? readState()?.trace_id;
   if (!ref) throw new Error("name a trace, or start one here");
   const bundle = await api("GET", `/traces/${ref}`);
@@ -7185,7 +7185,7 @@ traceCmd.command("show [id]").description("the trace bundle: spans, the sessions
   for (const gap of bundle.gaps) console.log(`  gap: ${gap.span_id} ${gap.reason}`);
 }));
 traceCmd.command("stop").description("end the root span, send what is left, and revoke this machine's grant").action(run(async () => {
-  const { readState, record, flush, grantSender, clearState } = await import("./trace-HTWXINXI.js");
+  const { readState, record, flush, grantSender, clearState } = await import("./trace-NMBMU4GS.js");
   const state = readState();
   if (!state) throw new Error("no trace is running here");
   if (state.root_span) record(() => [{ span_id: state.root_span, kind: "end", outcome: "completed" }]);
@@ -7194,8 +7194,8 @@ traceCmd.command("stop").description("end the root span, send what is left, and
   clearState();
   console.log(`Stopped ${state.trace_id}${outcome.pending ? ` (${outcome.pending} events could not be sent)` : ""}`);
 }));
-traceCmd.command("sync [payload]").description("upload this machine's Claude Code and Codex sessions to the matching workspace's trace library, redacted here first").option("--enable", "turn sync on for this machine").option("--disable", "turn sync off; nothing more is uploaded").option("--route <match=workspace>", "send sessions whose folder path contains <match> to <workspace> (repeatable; replaces the saved rules)", collect).option("--default <workspace>", "where a session no rule matches goes").option("--keep-local", "keep sessions no rule matches on this machine (the default)").option("--session <ref>", "only this session: its id or transcript path (repeatable)", collect).option("--full", "re-read every session, not only files that changed").option("--limit <n>", "at most this many changed sessions this run", (v) => Number.parseInt(v, 10)).option("--dry-run", "show what would be uploaded without uploading").option("--hook", "run from a Claude Code SessionEnd hook or Codex notify: upload that session in the background and return at once").option("--install-schedule", "also sweep every 15 minutes (macOS launchd)").option("--status", "what sync has done on this machine").option("--quiet", "print only failures").action(async (payload, opts) => {
-  const lib = await import("./trace-library-QR54Q4Z3.js");
+traceCmd.command("sync [payload]").description("upload this machine's agent sessions (Claude Code, Codex, Cursor, Gemini CLI and every other agent `--agents` lists) to the matching workspace's trace library, redacted here first").option("--enable", "turn sync on for this machine").option("--disable", "turn sync off; nothing more is uploaded").option("--route <match=workspace>", "send sessions whose folder path contains <match> to <workspace> (repeatable; replaces the saved rules)", collect).option("--default <workspace>", "where a session no rule matches goes").option("--keep-local", "keep sessions no rule matches on this machine (the default)").option("--session <ref>", "only this session: its id or transcript path (repeatable)", collect).option("--import <export>", "add a downloaded cloud export (claude.ai, ChatGPT, Gemini, Grok, DeepSeek \u2026: its .zip, folder or file) so sync uploads it (repeatable)", collect).option("--agents", "list the agents sync reads and which are on this machine").option("--full", "re-read every session, not only files that changed").option("--limit <n>", "at most this many changed sessions this run", (v) => Number.parseInt(v, 10)).option("--dry-run", "show what would be uploaded without uploading").option("--hook", "run from a Claude Code SessionEnd hook or Codex notify: upload that session in the background and return at once").option("--install-schedule", "also sweep every 15 minutes (macOS launchd)").option("--status", "what sync has done on this machine").option("--quiet", "print only failures").action(async (payload, opts) => {
+  const lib = await import("./trace-library-OWYB75AR.js");
   if (opts.hook) {
     try {
       let raw = payload ?? "";
@@ -7236,12 +7236,23 @@ traceCmd.command("sync [payload]").description("upload this machine's Claude Cod
       };
       lib.saveSyncConfig(next);
       console.log(`Trace sync is ${next.enabled ? "on" : "off"} on this machine. It reads only:`);
-      for (const folder of lib.sourceFolders()) console.log(`  ${folder}`);
+      for (const folder of await lib.sourceFolders()) console.log(`  ${folder}`);
       console.log("and sends each session, redacted here first, to:");
       for (const rule of next.rules) console.log(`  folder path contains "${rule.match}" \u2192 ${rule.workspace}`);
       console.log(`  anything else \u2192 ${next.fallback ?? "stays on this machine"}`);
       console.log(`A repository's .agentsky.json "workspace" wins over these rules.`);
     }
+    if (opts.agents) {
+      for (const agent2 of await lib.supportedAgents()) {
+        const how = agent2.kind === "export" ? "cloud export: sky trace sync --import <file>" : agent2.found ? "found on this machine" : "not on this machine";
+        console.log(`  ${agent2.name.padEnd(46)} ${how}`);
+      }
+      return;
+    }
+    for (const input of opts.import ?? []) {
+      const imported = await lib.importExport(input);
+      console.log(`Added ${imported.sessions} ${imported.agent} session${imported.sessions === 1 ? "" : "s"} from ${input}.`);
+    }
     if (opts.installSchedule) {
       const { join: join17 } = await import("path");
       const { homedir: homedir8 } = await import("os");
@@ -7293,7 +7304,7 @@ traceCmd.command("sync [payload]").description("upload this machine's Claude Cod
   })();
 });
 traceCmd.command("search <query...>").description("search every session in a workspace's trace library (literal substring)").option("--workspace <slug>", "the workspace to search (default: the current one)").option("--limit <n>", "hits per page", (v) => Number.parseInt(v, 10), 20).option("--cursor <cursor>", "the next page of an earlier search").option("--json", "print the page as JSON").action(run(async (words, opts) => {
-  const { libraryRequest } = await import("./trace-library-QR54Q4Z3.js");
+  const { libraryRequest } = await import("./trace-library-OWYB75AR.js");
   const workspace2 = opts.workspace ?? currentUniverse();
   if (!workspace2) throw new Error("name a workspace with --workspace");
   const params = new URLSearchParams({ q: words.join(" "), scope: "traces", limit: String(opts.limit), ...opts.cursor ? { cursor: opts.cursor } : {} });
@@ -7310,7 +7321,7 @@ traceCmd.command("search <query...>").description("search every session in a wor
   if (page.nextCursor) console.log(`More: sky trace search ${JSON.stringify(words.join(" "))} --workspace ${workspace2} --cursor ${page.nextCursor}`);
 }));
 traceCmd.command("library").description("list the sessions in a workspace's trace library, most recently updated first").option("--workspace <slug>", "the workspace (default: the current one)").option("--limit <n>", "how many", (v) => Number.parseInt(v, 10), 20).option("--json", "print the page as JSON").action(run(async (opts) => {
-  const { libraryRequest } = await import("./trace-library-QR54Q4Z3.js");
+  const { libraryRequest } = await import("./trace-library-OWYB75AR.js");
   const workspace2 = opts.workspace ?? currentUniverse();
   if (!workspace2) throw new Error("name a workspace with --workspace");
   const page = await libraryRequest("GET", `/trace-library?limit=${opts.limit}`, workspace2);

package/dist/{trace-HTWXINXI.js → trace-NMBMU4GS.js}

@@ -1,7 +1,7 @@
 import {
   USER_AGENT,
   configPath
-} from "./chunk-HB7SPKQ5.js";
+} from "./chunk-6JMFB3CV.js";
 import {
   TRACE_CONTENT_SCOPES,
   redactTraceText

package/dist/{trace-library-QR54Q4Z3.js → trace-library-OWYB75AR.js}

@@ -1,11 +1,11 @@
 import {
   ApiError
-} from "./chunk-WTFBVTMI.js";
+} from "./chunk-ZZ6UF7QA.js";
 import {
   USER_AGENT,
   apiBase,
   apiToken
-} from "./chunk-HB7SPKQ5.js";
+} from "./chunk-6JMFB3CV.js";
 import {
   SessionSourceCollector,
   publicRemote,
@@ -19,6 +19,7 @@ import { createReadStream, existsSync, mkdirSync, readdirSync, readFileSync, rmS
 import { createInterface } from "readline";
 import { homedir, hostname } from "os";
 import { basename, dirname, join, sep } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
 import { createGunzip } from "zlib";
 var MESSAGE_MAX_BYTES = 8 * 1024;
 var TOOL_MAX_BYTES = 2 * 1024;
@@ -66,8 +67,34 @@ function claudeRoot() {
 function codexRoot() {
   return process.env.CODEX_HOME ?? join(homedir(), ".codex");
 }
-function sourceFolders() {
-  return [claudeRoot(), join(codexRoot(), "sessions"), join(codexRoot(), "archived_sessions")];
+var SKY_PARSED = /* @__PURE__ */ new Set(["claude-code", "codex"]);
+var COLLECTOR_HARNESS = { "claude-code": "claude_code", codex: "codex" };
+var collectorModules;
+async function traceCollector() {
+  const dir = join(dirname(fileURLToPath(import.meta.url)), "..", "vendor", "trace-collect");
+  collectorModules ??= Promise.all([
+    import(pathToFileURL(join(dir, "collect.mjs")).href),
+    import(pathToFileURL(join(dir, "sinks", "agentsky.mjs")).href)
+  ]).then(([collector, sink]) => ({ collector, sink }));
+  return collectorModules;
+}
+function collectorHarness(harness) {
+  return COLLECTOR_HARNESS[harness] ?? harness.replace(/[^a-z0-9_-]/g, "_").slice(0, 40);
+}
+async function sourceFolders() {
+  const { collector } = await traceCollector();
+  const others = (await collector.describeSources()).filter((source) => !SKY_PARSED.has(source.id)).flatMap((source) => source.found);
+  return [claudeRoot(), join(codexRoot(), "sessions"), join(codexRoot(), "archived_sessions"), ...others, collector.STORE];
+}
+async function supportedAgents() {
+  const { collector } = await traceCollector();
+  return (await collector.describeSources()).map(({ id, name, kind, found }) => ({ id, name, kind, found: found.length > 0 }));
+}
+async function importExport(input) {
+  const { collector } = await traceCollector();
+  const result = await collector.importFile(input);
+  if (result.error) throw new Error(result.error);
+  return { agent: result.name ?? result.id ?? "export", sessions: result.total ?? 0 };
 }
 function signatureOf(files) {
   const parts = [];
@@ -188,8 +215,28 @@ function claudeSessionAt(path) {
   const signature = signatureOf(files);
   return signature ? { harness: "claude_code", sessionId, files, signature } : null;
 }
-async function discoverSessions() {
-  return [...claudeSessions(), ...await codexSessions()];
+async function collectorSessions() {
+  const { collector } = await traceCollector();
+  await collector.collect();
+  const harness = (await collector.loadSources()).map((source) => source.id).filter((id) => !SKY_PARSED.has(id));
+  const found = /* @__PURE__ */ new Map();
+  for await (const { file, trace, id } of collector.sessions({ harness, children: true })) {
+    const signature = signatureOf([file]);
+    if (!signature) continue;
+    const session = { harness: collectorHarness(trace.harness), sessionId: String(id).slice(0, 200), files: [file], signature, trace };
+    found.set(`${session.harness}:${session.sessionId}`, session);
+  }
+  return [...found.values()];
+}
+async function discoverSessions(onCollectorError) {
+  let others = [];
+  try {
+    others = await collectorSessions();
+  } catch (error) {
+    if (!onCollectorError) throw error;
+    onCollectorError(error);
+  }
+  return [...claudeSessions(), ...await codexSessions(), ...others];
 }
 function asRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -233,6 +280,11 @@ function isoOrUndefined(value) {
   const time = Date.parse(text);
   return Number.isFinite(time) ? new Date(time).toISOString() : void 0;
 }
+async function collectorBody(trace, device, scrubber) {
+  const { collector, sink } = await traceCollector();
+  const scrubbed = (scrubber ?? collector.scrubberFor()).scrub(trace);
+  return sink.toLibrary({ ...scrubbed, cwd: trace.cwd, stats: trace.stats }, device);
+}
 async function parseClaudeSession(session) {
   const out = { harness: "claude_code", sessionId: session.sessionId, userTurns: 0, toolCalls: 0, partial: false, messages: [] };
   const collector = new Collector();
@@ -580,7 +632,11 @@ async function runSync(config, options) {
   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();
+  const collectorFailed = (error) => {
+    report.failed += 1;
+    report.errors.push(`other agents: unreadable (${error.message})`);
+  };
+  let sessions = direct.length && direct.every(Boolean) ? direct : await discoverSessions(collectorFailed);
   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)));
@@ -594,7 +650,33 @@ async function runSync(config, options) {
     state.sessions[key(s)] = { signature: s.signature, at: (/* @__PURE__ */ new Date()).toISOString(), ...value };
   };
   const ready = /* @__PURE__ */ new Map();
+  let scrubber;
   for (const local of pending) {
+    if (local.trace) {
+      const workspace2 = routeSession(local.trace.cwd, config);
+      if (!workspace2) {
+        report.local += 1;
+        record(local, { workspace: null, status: "local" });
+        continue;
+      }
+      let body;
+      try {
+        scrubber ??= (await traceCollector()).collector.scrubberFor();
+        body = await collectorBody(local.trace, device, scrubber);
+      } catch (error) {
+        report.failed += 1;
+        report.errors.push(`${key(local)}: unreadable (${error.message})`);
+        continue;
+      }
+      const previous2 = state.sessions[key(local)];
+      if (!full && previous2?.sha256 === body.sha256 && previous2.workspace === workspace2 && previous2.status === "stored") {
+        report.unchanged += 1;
+        record(local, { workspace: workspace2, sha256: body.sha256, status: "stored" });
+        continue;
+      }
+      ready.set(workspace2, [...ready.get(workspace2) ?? [], { local, sha256: body.sha256, body: () => body }]);
+      continue;
+    }
     let parsed;
     try {
       parsed = local.harness === "claude_code" ? await parseClaudeSession(local) : await parseCodexSession(local);
@@ -621,7 +703,7 @@ async function runSync(config, options) {
       record(local, { workspace, sha256, status: "stored" });
       continue;
     }
-    ready.set(workspace, [...ready.get(workspace) ?? [], { local, parsed, sha256 }]);
+    ready.set(workspace, [...ready.get(workspace) ?? [], { local, sha256, body: () => uploadBody(parsed, sha256, device) }]);
   }
   for (const [workspace, items] of ready) {
     for (let start = 0; start < items.length; start += CHECK_BATCH) {
@@ -629,7 +711,7 @@ async function runSync(config, options) {
       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: batch.map((item) => ({ harness: item.local.harness, session_id: item.local.sessionId, sha256: item.sha256 }))
         })).sessions;
       } catch (error) {
         report.failed += batch.length;
@@ -658,7 +740,7 @@ async function runSync(config, options) {
       }
       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));
+          await libraryRequest("PUT", `/trace-library/${item.local.harness}/${encodeURIComponent(item.local.sessionId)}`, workspace, item.body());
           report.uploaded += 1;
           report.byWorkspace[workspace] = (report.byWorkspace[workspace] ?? 0) + 1;
           record(item.local, { workspace, sha256: item.sha256, status: "stored" });
@@ -711,8 +793,11 @@ ${command.map((part) => `    <string>${escape(part)}</string>`).join("\n")}
 }
 export {
   LAUNCHD_LABEL,
+  collectorBody,
+  collectorHarness,
   discoverSessions,
   hookSessionRef,
+  importExport,
   installLaunchd,
   isTrivial,
   libraryRequest,
@@ -725,6 +810,7 @@ export {
   saveSyncConfig,
   sessionDigest,
   sourceFolders,
+  supportedAgents,
   syncConfigPath,
   syncTraces
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsky/sky",
-  "version": "2.20.2",
+  "version": "2.21.0",
   "description": "sky \u2014 the AgentSky developer CLI: launch and talk to long-lived agents from your terminal.",
   "license": "MIT",
   "type": "module",
@@ -8,7 +8,8 @@
     "sky": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "vendor"
   ],
   "engines": {
     "node": ">=20"

package/vendor/trace-collect/SOURCE.json

@@ -0,0 +1,6 @@
+{
+  "repository": "xiaoyinqu/agentgold",
+  "path": "skill/trace-market/scripts/lib",
+  "commit": "bf0c85cdb0a119d8c91b33b9cf07fad78cc830be",
+  "dirty": false
+}

package/vendor/trace-collect/collect.mjs

@@ -0,0 +1,75 @@
+// The trace collector as a library: every agent in, one format out, any destination.
+//
+//   sources (lib/sources/*.mjs)  →  collect / import  →  trace/v1 sessions  →  sinks (lib/sinks/*.mjs)
+//
+// Nothing here knows about AgentGold or AgentSky; those are sinks. Any product that wants every agent's sessions
+// imports this module (zero dependencies, Node 22) instead of writing its own readers.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadSources, collectLocal, importExport, describeSources } from "./sources/index.mjs";
+import { normalizeAny } from "./normalize.mjs";
+import { createScrubber } from "./scrub.mjs";
+
+export { loadSources, describeSources };
+
+const HOME = os.homedir();
+/** Where converted sessions live. Shared with the AgentGold CLI so one conversion serves every destination. */
+export const STORE = path.join(process.env.TRACE_MARKET_HOME || path.join(HOME, ".trace-market"), "sources");
+
+export const collect = (opts = {}) => collectLocal(STORE, opts);
+export const importFile = (input, opts = {}) => importExport(path.resolve(input), STORE, opts);
+
+/** Every session on this computer, normalized: native agent folders read in place plus everything converted into STORE. */
+export async function* sessions({ harness = null, since = 0, minBytes = 2000, children = false } = {}) {
+  // With a harness filter, only open the folders those agents write to.
+  const natives = (await loadSources()).filter((s) => s.kind === "native" && (!harness || harness.includes(s.id)));
+  const converted = harness ? harness.map((h) => path.join(STORE, h)) : [STORE];
+  const roots = natives.flatMap((s) => s.roots(HOME)).filter((d) => fs.existsSync(d));
+  const files = [];
+  const walk = (d) => { let ents; try { ents = fs.readdirSync(d, { withFileTypes: true }); } catch { return; } for (const e of ents) { const p = path.join(d, e.name); if (e.isDirectory()) { if (e.name !== "subagents") walk(p); } else if (/\.jsonl?$/.test(e.name) && !e.name.startsWith(".")) files.push(p); } };
+  for (const r of [...roots, ...converted]) walk(r);
+  for (const f of files) {
+    let st; try { st = fs.statSync(f); } catch { continue; }
+    if (st.size < minBytes || (since && st.mtimeMs < since)) continue;
+    let t; try { t = normalizeAny(fs.readFileSync(f, "utf8"), f); } catch { continue; }
+    if (harness && !harness.includes(t.harness)) continue;
+    if (!t.stats.user_turns && !(children && t.parent_session_id)) continue;
+    if (t.parent_session_id && !children) continue; // children travel with their parent unless a sink wants them on their own
+    yield { file: f, trace: t, id: t.native_session_id || t.session_id };
+  }
+}
+
+/** One scrubber per run, configured from the AgentGold config when present so both destinations redact the same names. */
+export function scrubberFor(extra = {}) {
+  let redact = {};
+  try { redact = JSON.parse(fs.readFileSync(path.join(path.dirname(STORE), "config.json"), "utf8")).redact ?? {}; } catch {}
+  const names = [...new Set([...(redact.names ?? []), os.userInfo().username, ...(extra.names ?? [])])].filter((s) => s && s.length >= 3);
+  return createScrubber({ ...redact, names, terms: [...(redact.terms ?? []), ...(extra.terms ?? [])] });
+}
+
+const SINKS = path.join(path.dirname(fileURLToPath(import.meta.url)), "sinks");
+export async function loadSinks() {
+  const out = [];
+  for (const f of fs.readdirSync(SINKS).filter((f) => f.endsWith(".mjs") && !f.startsWith("_")).sort()) {
+    const m = (await import(pathToFileURL(path.join(SINKS, f)).href)).default;
+    if (m?.id && typeof m.push === "function") out.push(m);
+  }
+  return out;
+}
+
+/** Send sessions to one destination. A sink gets raw sessions plus `scrub`; it must scrub before anything leaves the computer. */
+export async function push(sinkId, opts = {}) {
+  const sink = (await loadSinks()).find((s) => s.id === sinkId);
+  if (!sink) throw new Error(`unknown destination ${sinkId}; available: ${(await loadSinks()).map((s) => s.id).join(", ")}`);
+  const ready = await sink.ready?.(opts);
+  if (ready && !ready.ok) return { sink: sink.id, error: ready.why };
+  const sc = scrubberFor(opts.redact);
+  const harness = opts.harness ?? sink.defaultHarness?.(opts) ?? null;
+  const skip = new Set(sink.skipHarness?.(opts) ?? []);
+  const list = [];
+  for await (const s of sessions({ harness, since: opts.since || 0, children: !!sink.children })) if (!skip.has(s.trace.harness)) list.push(s);
+  return { sink: sink.id, ...(await sink.push(list, { ...opts, scrub: (v) => sc.scrub(v), report: sc.report })) };
+}

package/vendor/trace-collect/identity.d.ts

@@ -0,0 +1,8 @@
+export const IDENTITY_VERSION: number;
+export type SourceIdentity = { version: number; kind: 'session' | 'file'; key: string; token?: string };
+export function sourceIdentity(harness: string, sessionId: string, source?: string): SourceIdentity;
+export function nativeIdentity(harness: string, token: string): string;
+export function legacyStableIdentity(harness: string, id: string): string;
+export function fileIdentity(harness: string, token: string): string;
+export function legacyHashes(seeds: Array<{harness: string; seed: string; native?: boolean}>, count: number): Generator<string>;
+export function matchingHashes(c: any, known: Set<string>): string[];

package/vendor/trace-collect/identity.mjs

@@ -0,0 +1,23 @@
+// Stable opaque session keys. Legacy count hashes are compatibility lookups, never new identities.
+import { createHash } from 'node:crypto';
+export const IDENTITY_VERSION = 3;
+const hash = (s) => createHash('sha256').update(s).digest('hex').slice(0, 32);
+export function sourceIdentity(harness, sessionId, source = '') {
+  if (sessionId) { const token = hash(`native-session:${harness}:${sessionId}`); return { version: IDENTITY_VERSION, kind: 'session', token, key: nativeIdentity(harness, token) }; }
+  const token = hash(source);
+  return { version: IDENTITY_VERSION, kind: 'file', token, key: fileIdentity(harness, token) };
+}
+export const nativeIdentity = (harness, token) => hash(`session/v3:${harness}:${token}`);
+export const legacyStableIdentity = (harness, id) => hash(`session/v2:${harness}:${id}`);
+export const fileIdentity = (harness, token) => hash(`file/v2:${harness}:${token}`);
+export function* legacyHashes(seeds, count) {
+  for (const { harness, seed, native } of seeds) {
+    if (native) yield legacyStableIdentity(harness, seed);
+    for (let n = 0; n <= count; n++) yield hash(`${harness}:${seed}:${n}`);
+  }
+}
+export function matchingHashes(c, known) {
+  const found = new Set(known.has(c.hash) ? [c.hash] : []);
+  if (known.size) for (const h of legacyHashes(c.legacy?.seeds ?? [], c.legacy?.count ?? 0)) if (known.has(h)) found.add(h);
+  return [...found];
+}

package/vendor/trace-collect/muse.mjs

@@ -0,0 +1,87 @@
+// Muse (Meta) keeps conversations in the cloud; its "Download your agent data" export is a zip whose
+// "Conversation with Muse AI_<date>.txt" is one long transcript of "[YYYY-MM-DD HH:MM:SS] You: …" /
+// "[…] Muse AI: …" lines (continuation lines belong to the line above). This turns it into trace/v1
+// sessions, split wherever the conversation pauses, so the normal scan → scrub → draft flow can take them.
+
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { FORMAT } from "./normalize.mjs";
+
+const LINE = /^\[(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})\] (You|Muse AI|[^:\]]{1,40}): ?(.*)$/;
+const WIDGET = /^\[\[hatch_widget:[^\]]*\]\]$/;
+/** Topics that are about the person's private life rather than work: such sessions are never uploaded. Broad on purpose:
+ *  a Muse chat is a personal assistant, so a false positive only keeps a session at home. */
+const SENSITIVE = /\b(health|medical|doctor|clinic|hospital|diagnos|symptom|physical exam|blood test|therapy|therapist|medication|prescription|pregnan|fertility|mental health|depress|anxiety|relationship|dating|boyfriend|girlfriend|husband|wife|divorce|father|mother|dad|mom|parents?|family|baby|child(ren)?|kids?|salary|paystub|bank account|bank|loan|mortgage|invest\w*|robinhood|interest rate|ssn|passport|\d+ \w+ (rd|road|st|street|ave|avenue|dr|drive|ln|lane|ct|blvd))\b|体检|查体|医生|医院|看病|吃药|健康|父亲|母亲|爸|妈|家人|孩子|儿子|女儿|恋爱|约会|感情|男朋友|女朋友|老公|老婆|结婚|离婚|工资|存款|理财|利率|贷款|股票|摔/i;
+
+/** The transcript text from an export zip, a folder it was unpacked into, or the .txt itself. */
+export function readMuseTranscript(input) {
+  const st = fs.statSync(input);
+  if (st.isDirectory()) {
+    const f = fs.readdirSync(input).find((n) => /^Conversation with Muse.*\.txt$/i.test(n));
+    if (!f) throw new Error(`no "Conversation with Muse …txt" in ${input}`);
+    return fs.readFileSync(path.join(input, f), "utf8");
+  }
+  if (input.endsWith(".zip")) {
+    const list = execFileSync("unzip", ["-Z1", input], { encoding: "utf8" }).split("\n");
+    const f = list.find((n) => /(^|\/)Conversation with Muse.*\.txt$/i.test(n));
+    if (!f) throw new Error(`no "Conversation with Muse …txt" in ${input}`);
+    return execFileSync("unzip", ["-p", input, f], { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  }
+  return fs.readFileSync(input, "utf8");
+}
+
+/** Parse the transcript into messages with timestamps. Widget placeholders are dropped. */
+export function parseMuseTranscript(raw) {
+  const out = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const m = LINE.exec(line);
+    if (m) {
+      const [, d, t, who, rest] = m;
+      out.push({ at: `${d}T${t}Z`, role: who === "You" ? "user" : "assistant", text: rest });
+    } else if (out.length && !WIDGET.test(line.trim())) {
+      out[out.length - 1].text += `\n${line}`;
+    }
+  }
+  for (const m of out) m.text = m.text.split("\n").filter((l) => !WIDGET.test(l.trim())).join("\n").trim();
+  return out.filter((m) => m.text);
+}
+
+/** Split into sessions wherever nothing was said for `gapMinutes`; each becomes one trace/v1 object. */
+export function museSessions(raw, { gapMinutes = 120 } = {}) {
+  const msgs = parseMuseTranscript(raw);
+  const groups = [];
+  for (const m of msgs) {
+    const last = groups.at(-1)?.at(-1);
+    if (!last || Date.parse(m.at) - Date.parse(last.at) > gapMinutes * 60_000) groups.push([m]);
+    else groups.at(-1).push(m);
+  }
+  return groups
+    .filter((g) => g.some((m) => m.role === "user"))
+    .map((g) => {
+      const firstUser = g.find((m) => m.role === "user");
+      const id = createHash("sha256").update(`muse:${g[0].at}:${firstUser.text.slice(0, 200)}`).digest("hex").slice(0, 16);
+      const all = g.map((m) => m.text).join("\n");
+      return {
+        format: FORMAT, harness: "muse", model: "muse", session_id: `muse-${id}`, title: firstUser.text.split("\n")[0].slice(0, 120),
+        started_at: g[0].at, ended_at: g.at(-1).at, cwd: "", source: "muse-export",
+        sensitive: SENSITIVE.test(all),
+        messages: g.map((m) => ({ role: m.role, text: m.text, at: m.at })),
+      };
+    });
+}
+
+/** Write each session as <dir>/muse-<id>.json (idempotent: same conversation, same file). */
+export function writeMuseSessions(sessions, dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let written = 0;
+  for (const s of sessions) {
+    const p = path.join(dir, `${s.session_id}.json`);
+    const body = JSON.stringify(s);
+    if (fs.existsSync(p) && fs.readFileSync(p, "utf8") === body) continue;
+    fs.writeFileSync(p, body, { mode: 0o600 });
+    written++;
+  }
+  return written;
+}

package/vendor/trace-collect/normalize.d.ts

@@ -0,0 +1,6 @@
+export const FORMAT: string;
+export function normalizeAny(raw: string, filePath?: string): any;
+export function makePreview(t: any, max?: number): string;
+export function parseJsonl(raw: string): any[];
+export function detectHarness(rows: any[], filePath?: string): string;
+export function makeSamples(t: any, max?: number): Array<{ label: string; text: string }>;