@yhong91/vibetime 0.1.25 → 0.1.27

package/bin/vibetime.mjs

@@ -157,11 +157,736 @@ var init_fs = __esm({
   }
 });
 
+// ../../node_modules/.pnpm/fzstd@0.1.1/node_modules/fzstd/esm/index.mjs
+var esm_exports = {};
+__export(esm_exports, {
+  Decompress: () => Decompress,
+  ZstdErrorCode: () => ZstdErrorCode,
+  decompress: () => decompress
+});
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+var ab, u8, u16, i16, i32, slc, fill, cpw, ZstdErrorCode, ec, err, rb, b4, rzfh, msb, rfse, rhu, dllt, dmlt, doct, b2bl, llb, llbl, mlb, mlbl, dhu, dhu4, rzb, cct, Decompress;
+var init_esm = __esm({
+  "../../node_modules/.pnpm/fzstd@0.1.1/node_modules/fzstd/esm/index.mjs"() {
+    ab = ArrayBuffer;
+    u8 = Uint8Array;
+    u16 = Uint16Array;
+    i16 = Int16Array;
+    i32 = Int32Array;
+    slc = function(v, s, e) {
+      if (u8.prototype.slice)
+        return u8.prototype.slice.call(v, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      var n = new u8(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    fill = function(v, n, s, e) {
+      if (u8.prototype.fill)
+        return u8.prototype.fill.call(v, n, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      for (; s < e; ++s)
+        v[s] = n;
+      return v;
+    };
+    cpw = function(v, t, s, e) {
+      if (u8.prototype.copyWithin)
+        return u8.prototype.copyWithin.call(v, t, s, e);
+      if (s == null || s < 0)
+        s = 0;
+      if (e == null || e > v.length)
+        e = v.length;
+      while (s < e) {
+        v[t++] = v[s++];
+      }
+    };
+    ZstdErrorCode = {
+      InvalidData: 0,
+      WindowSizeTooLarge: 1,
+      InvalidBlockType: 2,
+      FSEAccuracyTooHigh: 3,
+      DistanceTooFarBack: 4,
+      UnexpectedEOF: 5
+    };
+    ec = [
+      "invalid zstd data",
+      "window size too large (>2046MB)",
+      "invalid block type",
+      "FSE accuracy too high",
+      "match distance too far back",
+      "unexpected EOF"
+    ];
+    err = function(ind, msg, nt) {
+      var e = new Error(msg || ec[ind]);
+      e.code = ind;
+      if (Error.captureStackTrace)
+        Error.captureStackTrace(e, err);
+      if (!nt)
+        throw e;
+      return e;
+    };
+    rb = function(d, b, n) {
+      var i = 0, o = 0;
+      for (; i < n; ++i)
+        o |= d[b++] << (i << 3);
+      return o;
+    };
+    b4 = function(d, b) {
+      return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+    };
+    rzfh = function(dat, w) {
+      var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+      if (n3 == 3126568 && dat[3] == 253) {
+        var flg = dat[4];
+        var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+        if (flg & 8)
+          err(0);
+        var bt = 6 - ss;
+        var db = df == 3 ? 4 : df;
+        var di = rb(dat, bt, db);
+        bt += db;
+        var fsb = fcf ? 1 << fcf : ss;
+        var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+        var ws = fss;
+        if (!ss) {
+          var wb = 1 << 10 + (dat[5] >> 3);
+          ws = wb + (wb >> 3) * (dat[5] & 7);
+        }
+        if (ws > 2145386496)
+          err(1);
+        var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+        buf[0] = 1, buf[4] = 4, buf[8] = 8;
+        return {
+          b: bt + fsb,
+          y: 0,
+          l: 0,
+          d: di,
+          w: w && w != 1 ? w : buf.subarray(12),
+          e: ws,
+          o: new i32(buf.buffer, 0, 3),
+          u: fss,
+          c: cc,
+          m: Math.min(131072, ws)
+        };
+      } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+        return b4(dat, 4) + 8;
+      }
+      err(0);
+    };
+    msb = function(val) {
+      var bits = 0;
+      for (; 1 << bits <= val; ++bits)
+        ;
+      return bits - 1;
+    };
+    rfse = function(dat, bt, mal) {
+      var tpos = (bt << 3) + 4;
+      var al = (dat[bt] & 15) + 5;
+      if (al > mal)
+        err(3);
+      var sz = 1 << al;
+      var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+      var buf = new ab(512 + (sz << 2));
+      var freq = new i16(buf, 0, 256);
+      var dstate = new u16(buf, 0, 256);
+      var nstate = new u16(buf, 512, sz);
+      var bb1 = 512 + (sz << 1);
+      var syms = new u8(buf, bb1, sz);
+      var nbits = new u8(buf, bb1 + sz);
+      while (sym < 255 && probs > 0) {
+        var bits = msb(probs + 1);
+        var cbt = tpos >> 3;
+        var msk = (1 << bits + 1) - 1;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+        var msk1fb = (1 << bits) - 1;
+        var msv = msk - probs - 1;
+        var sval = val & msk1fb;
+        if (sval < msv)
+          tpos += bits, val = sval;
+        else {
+          tpos += bits + 1;
+          if (val > msk1fb)
+            val -= msv;
+        }
+        freq[++sym] = --val;
+        if (val == -1) {
+          probs += val;
+          syms[--ht] = sym;
+        } else
+          probs -= val;
+        if (!val) {
+          do {
+            var rbt = tpos >> 3;
+            re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+            tpos += 2;
+            sym += re;
+          } while (re == 3);
+        }
+      }
+      if (sym > 255 || probs)
+        err(0);
+      var sympos = 0;
+      var sstep = (sz >> 1) + (sz >> 3) + 3;
+      var smask = sz - 1;
+      for (var s = 0; s <= sym; ++s) {
+        var sf = freq[s];
+        if (sf < 1) {
+          dstate[s] = -sf;
+          continue;
+        }
+        for (i = 0; i < sf; ++i) {
+          syms[sympos] = s;
+          do {
+            sympos = sympos + sstep & smask;
+          } while (sympos >= ht);
+        }
+      }
+      if (sympos)
+        err(0);
+      for (i = 0; i < sz; ++i) {
+        var ns = dstate[syms[i]]++;
+        var nb = nbits[i] = al - msb(ns);
+        nstate[i] = (ns << nb) - sz;
+      }
+      return [tpos + 7 >> 3, {
+        b: al,
+        s: syms,
+        n: nbits,
+        t: nstate
+      }];
+    };
+    rhu = function(dat, bt) {
+      var i = 0, wc = -1;
+      var buf = new u8(292), hb = dat[bt];
+      var hw = buf.subarray(0, 256);
+      var rc = buf.subarray(256, 268);
+      var ri = new u16(buf.buffer, 268);
+      if (hb < 128) {
+        var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+        bt += hb;
+        var epos = ebt << 3;
+        var lb = dat[bt];
+        if (!lb)
+          err(0);
+        var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+        var fpos = (++bt << 3) - 8 + msb(lb);
+        for (; ; ) {
+          fpos -= btr1;
+          if (fpos < epos)
+            break;
+          var cbt = fpos >> 3;
+          st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+          hw[++wc] = fdt.s[st1];
+          fpos -= btr2;
+          if (fpos < epos)
+            break;
+          cbt = fpos >> 3;
+          st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+          hw[++wc] = fdt.s[st2];
+          btr1 = fdt.n[st1];
+          st1 = fdt.t[st1];
+          btr2 = fdt.n[st2];
+          st2 = fdt.t[st2];
+        }
+        if (++wc > 255)
+          err(0);
+      } else {
+        wc = hb - 127;
+        for (; i < wc; i += 2) {
+          var byte = dat[++bt];
+          hw[i] = byte >> 4;
+          hw[i + 1] = byte & 15;
+        }
+        ++bt;
+      }
+      var wes = 0;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        if (wt > 11)
+          err(0);
+        wes += wt && 1 << wt - 1;
+      }
+      var mb = msb(wes) + 1;
+      var ts = 1 << mb;
+      var rem = ts - wes;
+      if (rem & rem - 1)
+        err(0);
+      hw[wc++] = msb(rem) + 1;
+      for (i = 0; i < wc; ++i) {
+        var wt = hw[i];
+        ++rc[hw[i] = wt && mb + 1 - wt];
+      }
+      var hbuf = new u8(ts << 1);
+      var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+      ri[mb] = 0;
+      for (i = mb; i > 0; --i) {
+        var pv = ri[i];
+        fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+      }
+      if (ri[0] != ts)
+        err(0);
+      for (i = 0; i < wc; ++i) {
+        var bits = hw[i];
+        if (bits) {
+          var code = ri[bits];
+          fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+        }
+      }
+      return [bt, {
+        n: nb,
+        b: mb,
+        s: syms
+      }];
+    };
+    dllt = rfse(/* @__PURE__ */ new u8([
+      81,
+      16,
+      99,
+      140,
+      49,
+      198,
+      24,
+      99,
+      12,
+      33,
+      196,
+      24,
+      99,
+      102,
+      102,
+      134,
+      70,
+      146,
+      4
+    ]), 0, 6)[1];
+    dmlt = rfse(/* @__PURE__ */ new u8([
+      33,
+      20,
+      196,
+      24,
+      99,
+      140,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      132,
+      16,
+      66,
+      8,
+      33,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      68,
+      36,
+      9
+    ]), 0, 6)[1];
+    doct = rfse(/* @__PURE__ */ new u8([
+      32,
+      132,
+      16,
+      66,
+      102,
+      70,
+      68,
+      68,
+      68,
+      68,
+      36,
+      73,
+      2
+    ]), 0, 5)[1];
+    b2bl = function(b, s) {
+      var len = b.length, bl = new i32(len);
+      for (var i = 0; i < len; ++i) {
+        bl[i] = s;
+        s += 1 << b[i];
+      }
+      return bl;
+    };
+    llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      134678020,
+      202050057,
+      269422093
+    ])).buffer, 0, 36);
+    llbl = /* @__PURE__ */ b2bl(llb, 0);
+    mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      16843009,
+      50528770,
+      117769220,
+      185207048,
+      252579084,
+      16
+    ])).buffer, 0, 53);
+    mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+    dhu = function(dat, out, hu) {
+      var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+      if (!lb)
+        err(0);
+      var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+      for (; pos > eb && i < ss; ) {
+        var cbt = pos >> 3;
+        var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+        st = (st << btr | val) & msk;
+        out[++i] = hu.s[st];
+        pos -= btr = hu.n[st];
+      }
+      if (pos != eb || i + 1 != ss)
+        err(0);
+    };
+    dhu4 = function(dat, out, hu) {
+      var bt = 6;
+      var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+      dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+      dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+      dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+      dhu(dat.subarray(bt), out.subarray(sz3), hu);
+    };
+    rzb = function(dat, st, out) {
+      var _a;
+      var bt = st.b;
+      var b0 = dat[bt], btype = b0 >> 1 & 3;
+      st.l = b0 & 1;
+      var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+      var ebt = (bt += 3) + sz;
+      if (btype == 1) {
+        if (bt >= dat.length)
+          return;
+        st.b = bt + 1;
+        if (out) {
+          fill(out, dat[bt], st.y, st.y += sz);
+          return out;
+        }
+        return fill(new u8(sz), dat[bt]);
+      }
+      if (ebt > dat.length)
+        return;
+      if (btype == 0) {
+        st.b = ebt;
+        if (out) {
+          out.set(dat.subarray(bt, ebt), st.y);
+          st.y += sz;
+          return out;
+        }
+        return slc(dat, bt, ebt);
+      }
+      if (btype == 2) {
+        var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+        var lss = b3 >> 4, lcs = 0, s4 = 0;
+        if (lbt < 2) {
+          if (sf & 1)
+            lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+          else
+            lss = b3 >> 3;
+        } else {
+          s4 = sf;
+          if (sf < 2)
+            lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+          else if (sf == 2)
+            lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+          else
+            lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+        }
+        ++bt;
+        var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+        var spl = buf.length - lss;
+        if (lbt == 0)
+          buf.set(dat.subarray(bt, bt += lss), spl);
+        else if (lbt == 1)
+          fill(buf, dat[bt++], spl);
+        else {
+          var hu = st.h;
+          if (lbt == 2) {
+            var hud = rhu(dat, bt);
+            lcs += bt - (bt = hud[0]);
+            st.h = hu = hud[1];
+          } else if (!hu)
+            err(0);
+          (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+        }
+        var ns = dat[bt++];
+        if (ns) {
+          if (ns == 255)
+            ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+          else if (ns > 127)
+            ns = ns - 128 << 8 | dat[bt++];
+          var scm = dat[bt++];
+          if (scm & 3)
+            err(0);
+          var dts = [dmlt, doct, dllt];
+          for (var i = 2; i > -1; --i) {
+            var md = scm >> (i << 1) + 2 & 3;
+            if (md == 1) {
+              var rbuf = new u8([0, 0, dat[bt++]]);
+              dts[i] = {
+                s: rbuf.subarray(2, 3),
+                n: rbuf.subarray(0, 1),
+                t: new u16(rbuf.buffer, 0, 1),
+                b: 0
+              };
+            } else if (md == 2) {
+              _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+            } else if (md == 3) {
+              if (!st.t)
+                err(0);
+              dts[i] = st.t[i];
+            }
+          }
+          var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+          var lb = dat[ebt - 1];
+          if (!lb)
+            err(0);
+          var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+          var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+          cbt = (spos -= oct.b) >> 3;
+          var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+          cbt = (spos -= mlt.b) >> 3;
+          var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+          for (++ns; --ns; ) {
+            var llc = llt.s[lst];
+            var lbtr = llt.n[lst];
+            var mlc = mlt.s[mst];
+            var mbtr = mlt.n[mst];
+            var ofc = oct.s[ost];
+            var obtr = oct.n[ost];
+            cbt = (spos -= ofc) >> 3;
+            var ofp = 1 << ofc;
+            var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+            cbt = (spos -= mlb[mlc]) >> 3;
+            var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+            cbt = (spos -= llb[llc]) >> 3;
+            var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+            cbt = (spos -= lbtr) >> 3;
+            lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+            cbt = (spos -= mbtr) >> 3;
+            mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+            cbt = (spos -= obtr) >> 3;
+            ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+            if (off > 3) {
+              st.o[2] = st.o[1];
+              st.o[1] = st.o[0];
+              st.o[0] = off -= 3;
+            } else {
+              var idx = off - (ll != 0);
+              if (idx) {
+                off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+                if (idx > 1)
+                  st.o[2] = st.o[1];
+                st.o[1] = st.o[0];
+                st.o[0] = off;
+              } else
+                off = st.o[0];
+            }
+            for (var i = 0; i < ll; ++i) {
+              buf[oubt + i] = buf[spl + i];
+            }
+            oubt += ll, spl += ll;
+            var stin = oubt - off;
+            if (stin < 0) {
+              var len = -stin;
+              var bs = st.e + stin;
+              if (len > ml)
+                len = ml;
+              for (var i = 0; i < len; ++i) {
+                buf[oubt + i] = st.w[bs + i];
+              }
+              oubt += len, ml -= len, stin = 0;
+            }
+            for (var i = 0; i < ml; ++i) {
+              buf[oubt + i] = buf[stin + i];
+            }
+            oubt += ml;
+          }
+          if (oubt != spl) {
+            while (spl < buf.length) {
+              buf[oubt++] = buf[spl++];
+            }
+          } else
+            oubt = buf.length;
+          if (out)
+            st.y += oubt;
+          else
+            buf = slc(buf, 0, oubt);
+        } else if (out) {
+          st.y += lss;
+          if (spl) {
+            for (var i = 0; i < lss; ++i) {
+              buf[i] = buf[spl + i];
+            }
+          }
+        } else if (spl)
+          buf = slc(buf, spl);
+        st.b = ebt;
+        return buf;
+      }
+      err(2);
+    };
+    cct = function(bufs, ol) {
+      if (bufs.length == 1)
+        return bufs[0];
+      var buf = new u8(ol);
+      for (var i = 0, b = 0; i < bufs.length; ++i) {
+        var chk = bufs[i];
+        buf.set(chk, b);
+        b += chk.length;
+      }
+      return buf;
+    };
+    Decompress = /* @__PURE__ */ (function() {
+      function Decompress2(ondata) {
+        this.ondata = ondata;
+        this.c = [];
+        this.l = 0;
+        this.z = 0;
+      }
+      Decompress2.prototype.push = function(chunk, final) {
+        if (typeof this.s == "number") {
+          var sub = Math.min(chunk.length, this.s);
+          chunk = chunk.subarray(sub);
+          this.s -= sub;
+        }
+        var sl = chunk.length;
+        var ncs = sl + this.l;
+        if (!this.s) {
+          if (final) {
+            if (!ncs) {
+              this.ondata(new u8(0), true);
+              return;
+            }
+            if (ncs < 5)
+              err(5);
+          } else if (ncs < 18) {
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          }
+          if (this.l) {
+            this.c.push(chunk);
+            chunk = cct(this.c, ncs);
+            this.c = [];
+            this.l = 0;
+          }
+          if (typeof (this.s = rzfh(chunk)) == "number")
+            return this.push(chunk, final);
+        }
+        if (typeof this.s != "number") {
+          if (ncs < (this.z || 3)) {
+            if (final)
+              err(5);
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          }
+          if (this.l) {
+            this.c.push(chunk);
+            chunk = cct(this.c, ncs);
+            this.c = [];
+            this.l = 0;
+          }
+          if (!this.z && ncs < (this.z = chunk[this.s.b] & 2 ? 4 : 3 + (chunk[this.s.b] >> 3 | chunk[this.s.b + 1] << 5 | chunk[this.s.b + 2] << 13))) {
+            if (final)
+              err(5);
+            this.c.push(chunk);
+            this.l = ncs;
+            return;
+          } else
+            this.z = 0;
+          for (; ; ) {
+            var blk = rzb(chunk, this.s);
+            if (!blk) {
+              if (final)
+                err(5);
+              var adc = chunk.subarray(this.s.b);
+              this.s.b = 0;
+              this.c.push(adc), this.l += adc.length;
+              return;
+            } else {
+              this.ondata(blk, false);
+              cpw(this.s.w, 0, blk.length);
+              this.s.w.set(blk, this.s.w.length - blk.length);
+            }
+            if (this.s.l) {
+              var rest = chunk.subarray(this.s.b);
+              this.s = this.s.c * 4;
+              this.push(rest, final);
+              return;
+            }
+          }
+        } else if (final)
+          err(5);
+      };
+      return Decompress2;
+    })();
+  }
+});
+
 // src/cli.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import { mkdir as mkdir5, open, rm, stat as stat12, writeFile as writeFile4 } from "node:fs/promises";
-import os9 from "node:os";
-import path21 from "node:path";
+import { mkdir as mkdir5, open, rm, stat as stat13, writeFile as writeFile4 } from "node:fs/promises";
+import os10 from "node:os";
+import path23 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -191,13 +916,15 @@ var TELEMETRY_EVENT_TYPES = [
   "model.usage",
   "permission.requested",
   "permission.resolved",
+  "permission.granted",
+  "permission.denied",
   "context.compacted",
   "test.completed",
   "git.changed",
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -1201,7 +1928,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.25" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.27" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1226,6 +1953,12 @@ function objectField(object, key) {
   }
   return object[key];
 }
+function arrayField(object, key) {
+  if (!isPlainObject(object) || !Array.isArray(object[key])) {
+    return [];
+  }
+  return object[key];
+}
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -2905,7 +3638,7 @@ function fileActivitiesFromClaudeToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromClaudeToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField(input, "edits")) {
+  for (const edit of arrayField2(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -2949,17 +3682,17 @@ function fileMetricsFromClaudeToolInput(tool, input) {
   }
   return {};
 }
-function arrayField(object, key) {
+function arrayField2(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function claudeToolUseItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function claudeToolResultItems(message) {
-  return arrayField(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField2(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isClaudeToolResultMessage(message) {
   return claudeToolResultItems(message).length > 0;
@@ -4029,8 +4762,8 @@ async function codebuddyBackfillFiles(sourceRoot, home, env) {
           }
           const filePath = path9.join(traceDir, entry);
           try {
-            const stat13 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
-            files.push({ path: filePath, modifiedAt: stat13.mtime.toISOString() });
+            const stat14 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
+            files.push({ path: filePath, modifiedAt: stat14.mtime.toISOString() });
           } catch {
           }
         }
@@ -4615,7 +5348,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   for (const key of ["file_path", "path", "notebook_path"]) {
     addResolvedPathActivity(changes, stringField(args, key), operation, ts, cwd, workdir);
   }
-  for (const file of arrayField2(args, "files")) {
+  for (const file of arrayField3(args, "files")) {
     if (typeof file === "string") {
       addResolvedPathActivity(changes, file, operation, ts, cwd, workdir);
     }
@@ -4628,7 +5361,7 @@ function fileActivitiesFromFunctionCall(payload, payloadType, ts, cwd) {
   }
   return [...changes.values()];
 }
-function arrayField2(object, key) {
+function arrayField3(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
@@ -5058,95 +5791,583 @@ function createCopilotAdapter() {
   };
 }
 
-// src/adapters/opencode.ts
-import os6 from "node:os";
+// src/adapters/grok-build.ts
+import { readdir as readdir6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
 import path13 from "node:path";
-async function parseOpenCodeSessionFile(dbPath, options) {
-  const { DatabaseSync } = await import("node:sqlite");
-  if (!dbPath.endsWith(".db")) {
+init_fs();
+var SOURCE_ID = "grok-build";
+var AGENT_NAME = "grok-build";
+var HOOK_COMMAND = `vibetime hook --agent ${SOURCE_ID}`;
+function grokHome(home, env) {
+  const override = env?.GROK_HOME;
+  if (override && override.trim()) {
+    return path13.resolve(override);
+  }
+  return path13.join(home, ".grok");
+}
+function grokHooksPath(home, env) {
+  return path13.join(grokHome(home, env), "hooks", "vibetime.json");
+}
+function grokSessionsDir(home, env) {
+  return path13.join(grokHome(home, env), "sessions");
+}
+async function grokBackfillFiles(sourceRoot, home, env) {
+  const root = sourceRoot || grokSessionsDir(home, env);
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = path13.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== "summary.json") {
+        continue;
+      }
+      try {
+        const info = await stat7(entryPath);
+        files.push({ path: entryPath, modifiedAt: info.mtime.toISOString() });
+      } catch {
+      }
+    }
+  }
+  await walk(root);
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function parseGrokSessionFile(filePath, options) {
+  const sessionDir = resolveSessionDir(filePath);
+  if (!sessionDir) {
     return [];
   }
-  const db = new DatabaseSync(dbPath, { readOnly: true });
+  const summaryPath = path13.join(sessionDir, "summary.json");
+  const eventsPath = path13.join(sessionDir, "events.jsonl");
+  const signalsPath = path13.join(sessionDir, "signals.json");
+  const updatesPath = path13.join(sessionDir, "updates.jsonl");
+  const summary = await readJsonIfExists(summaryPath);
+  if (!isPlainObject(summary)) {
+    return [];
+  }
+  const info = objectField(summary, "info");
+  const sessionId = stringField(info, "id") || path13.basename(sessionDir);
+  const cwd = stringField(info, "cwd");
+  const project = cwd ? path13.basename(cwd) : void 0;
+  const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+  const model = stringField(summary, "current_model_id");
+  const createdAt = timestampFrom(summary.created_at) || timestampFrom(summary.createdAt);
+  const updatedAt = timestampFrom(summary.updated_at) || timestampFrom(summary.last_active_at) || timestampFrom(summary.updatedAt) || createdAt;
+  if (!createdAt) {
+    return [];
+  }
+  const sourcePathHash = `sha256:${createStableHash(summaryPath)}`;
+  const toolInputs = await loadToolInputsFromUpdates(updatesPath);
   const events = [];
+  const push = (event, lineNumber2, topType, payloadType) => {
+    const validated = validateCanonicalEvent(event);
+    if (!validated.valid) {
+      return;
+    }
+    events.push(withBackfillRefs(event, {
+      filePath: summaryPath,
+      sourcePathHash,
+      lineNumber: lineNumber2,
+      topType: topType || "session",
+      payloadType: payloadType || event.type,
+      options
+    }));
+  };
+  const base = (partial) => ({
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: SOURCE_ID,
+    agent: AGENT_NAME,
+    workspaceId,
+    project,
+    cwd,
+    model,
+    sessionId,
+    ...partial
+  });
+  push(base({
+    ts: createdAt,
+    type: "session.started",
+    confidence: "exact",
+    refs: stringRefs({ sourceId: `${sessionId}:started` })
+  }), 0, "summary", "session.started");
+  let currentTurnId;
+  let currentTurnStartedAt;
+  let lineNumber = 0;
+  const pendingTools = /* @__PURE__ */ new Map();
+  let eventsText = "";
   try {
-    const sessionCols = new Set(
-      db.prepare("PRAGMA table_info(session)").all().map((row) => row.name)
-    );
-    const hasDirectory = sessionCols.has("directory");
-    const hasPath = sessionCols.has("path");
-    const hasArchived = sessionCols.has("time_archived");
-    const selectCols = ["id", "title", "time_created"];
-    if (hasDirectory) {
-      selectCols.push("directory");
+    eventsText = await readFile8(eventsPath, "utf8");
+  } catch {
+  }
+  const lines = eventsText.split("\n").filter(Boolean);
+  for (const [index, line] of lines.entries()) {
+    lineNumber = index + 1;
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
     }
-    if (hasPath) {
-      selectCols.push("path");
+    const type = stringField(raw, "type");
+    const ts = timestampFrom(raw.ts) || timestampFrom(raw.timestamp);
+    if (!type || !ts) {
+      continue;
     }
-    if (hasArchived) {
-      selectCols.push("time_archived");
+    if (type === "turn_started") {
+      const turnNumber = numberField(raw, "turn_number");
+      currentTurnId = turnNumber !== void 0 ? `turn_${turnNumber}` : `turn_${createStableHash([sessionId, lineNumber]).slice(0, 24)}`;
+      currentTurnStartedAt = ts;
+      const turnModel = stringField(raw, "model_id") || model;
+      push(base({
+        ts,
+        type: "turn.started",
+        turnId: currentTurnId,
+        model: turnModel,
+        confidence: "exact",
+        refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:started` })
+      }), lineNumber, type, "turn.started");
+      continue;
     }
-    const sessions = db.prepare(
-      `SELECT ${selectCols.join(", ")} FROM session WHERE time_created IS NOT NULL ORDER BY time_created`
-    ).all();
-    for (const session of sessions) {
-      const sessionId = session.id;
-      const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path13.basename(cwd) : void 0;
-      const sessionTs = msToIso(session.time_created);
-      events.push(baseOpenCodeEvent({
-        ts: sessionTs,
-        type: "session.started",
-        sessionId,
-        cwd,
-        project,
-        operation: "session start"
-      }));
-      const messages = db.prepare(
-        "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created"
-      ).all(sessionId);
-      let currentTurnId;
-      let currentProvider;
-      let turnTs;
-      let reasoningEffort;
-      const modelSwitchedEvents = db.prepare(
-        "SELECT data FROM event WHERE aggregate_id = ? AND type = 'session.next.model.switched.1' ORDER BY seq"
-      ).all(sessionId);
-      for (const evt of modelSwitchedEvents) {
-        try {
-          const evtData = JSON.parse(evt.data);
-          const variant = isPlainObject(evtData) ? stringField(evtData.model || evtData, "variant") : void 0;
-          if (variant && variant !== "default") {
-            reasoningEffort = variant;
-          }
-        } catch {
+    if (type === "turn_ended") {
+      const turnId = currentTurnId;
+      const outcome = stringField(raw, "outcome");
+      const success = outcome !== "error" && outcome !== "failed" && outcome !== "cancelled";
+      const durationMs = durationMsBetween(currentTurnStartedAt, ts);
+      push(base({
+        ts,
+        type: success ? "turn.completed" : "turn.failed",
+        turnId,
+        success,
+        confidence: "exact",
+        metrics: durationMs !== void 0 ? { durationMs } : void 0,
+        refs: stringRefs({
+          sourceId: `${sessionId}:${turnId || "turn"}:ended`,
+          outcome
+        })
+      }), lineNumber, type, "turn.ended");
+      currentTurnId = void 0;
+      currentTurnStartedAt = void 0;
+      continue;
+    }
+    if (type === "tool_started" || type === "mcp_tool_call_started") {
+      const toolName = type === "mcp_tool_call_started" ? mcpToolName(raw) : stringField(raw, "tool_name") || "unknown";
+      const toolId = stringField(raw, "call_id") || `${sessionId}:tool:${lineNumber}:${toolName}`;
+      pendingTools.set(toolId, {
+        id: toolId,
+        name: toolName,
+        startedAt: ts,
+        lineNumber,
+        turnId: currentTurnId
+      });
+      const knownInput = toolInputs.get(toolId);
+      const fileActivities = fileActivitiesFromTool(
+        toolName,
+        knownInput?.input || {},
+        ts,
+        cwd
+      );
+      push(base({
+        ts,
+        type: "tool.started",
+        turnId: currentTurnId,
+        tool: toolName,
+        operation: `${toolName} started`,
+        confidence: "exact",
+        fileActivities: fileActivities.length > 0 ? fileActivities : void 0,
+        refs: stringRefs({ sourceId: `${toolId}:started` })
+      }), lineNumber, type, "tool.started");
+      if (isShellTool(toolName)) {
+        const command = stringField(knownInput?.input || {}, "command");
+        if (command) {
+          push(base({
+            ts,
+            type: "command.started",
+            turnId: currentTurnId,
+            tool: toolName,
+            operation: "command started",
+            confidence: "derived",
+            refs: stringRefs({
+              sourceId: `${toolId}:command:started`,
+              commandHash: `sha256:${createStableHash(command)}`
+            })
+          }), lineNumber, type, "command.started");
         }
       }
-      for (const msg of messages) {
-        let info;
-        try {
-          info = JSON.parse(msg.data);
-        } catch {
-          continue;
-        }
-        if (!isPlainObject(info)) {
-          continue;
-        }
-        const role = stringField(info, "role");
-        const timeObj = objectField(info, "time");
-        const timeCreated = numberField(timeObj, "created");
-        if (!role || !timeCreated) {
-          continue;
-        }
-        if (role === "user") {
-          currentTurnId = `turn_${createStableHash([sessionId, msg.id]).slice(0, 24)}`;
-          turnTs = msToIso(timeCreated);
-          const userAgent = stringField(info, "agent") || "opencode";
-          const modelObj = objectField(info, "model");
-          const model = modelObj ? stringField(modelObj, "modelID") : void 0;
-          currentProvider = modelObj ? stringField(modelObj, "providerID") : void 0;
-          events.push(baseOpenCodeEvent({
-            ts: turnTs,
-            type: "turn.started",
+      continue;
+    }
+    if (type === "tool_completed" || type === "mcp_tool_call_completed") {
+      const toolName = type === "mcp_tool_call_completed" ? mcpToolName(raw) : stringField(raw, "tool_name") || "unknown";
+      const toolId = stringField(raw, "call_id") || findPendingToolId(pendingTools, toolName) || `${sessionId}:tool:${lineNumber}:${toolName}`;
+      const pending = pendingTools.get(toolId);
+      const durationMs = numberField(raw, "duration_ms") ?? durationMsBetween(pending?.startedAt, ts);
+      const outcome = stringField(raw, "outcome");
+      const success = raw.success !== false && outcome !== "error" && outcome !== "failed" && !raw.is_timeout;
+      push(base({
+        ts,
+        type: success ? "tool.completed" : "tool.failed",
+        turnId: pending?.turnId || currentTurnId,
+        tool: pending?.name || toolName,
+        operation: `${pending?.name || toolName} completed`,
+        success,
+        confidence: "exact",
+        metrics: {
+          toolCalls: 1,
+          toolDurationMs: durationMs,
+          durationMs
+        },
+        refs: stringRefs({ sourceId: `${toolId}:completed` })
+      }), lineNumber, type, "tool.completed");
+      if (isShellTool(pending?.name || toolName)) {
+        push(base({
+          ts,
+          type: success ? "command.completed" : "command.failed",
+          turnId: pending?.turnId || currentTurnId,
+          tool: pending?.name || toolName,
+          operation: "command completed",
+          success,
+          confidence: "derived",
+          metrics: {
+            commandCalls: 1,
+            commandDurationMs: durationMs,
+            durationMs
+          },
+          refs: stringRefs({ sourceId: `${toolId}:command:completed` })
+        }), lineNumber, type, "command.completed");
+      }
+      pendingTools.delete(toolId);
+      continue;
+    }
+    if (type === "permission_resolved") {
+      const toolName = stringField(raw, "tool_name");
+      const decision = stringField(raw, "decision") || stringField(raw, "outcome");
+      const allowed = decision !== "deny" && decision !== "denied" && decision !== "reject";
+      push(base({
+        ts,
+        type: allowed ? "permission.granted" : "permission.denied",
+        turnId: currentTurnId,
+        tool: toolName,
+        success: allowed,
+        confidence: "partial",
+        refs: stringRefs({
+          sourceId: `${sessionId}:permission:${lineNumber}`,
+          decision
+        })
+      }), lineNumber, type, "permission");
+    }
+  }
+  const signals = await readJsonIfExists(signalsPath);
+  if (isPlainObject(signals) && updatedAt) {
+    const metrics = metricsFromSignals(signals);
+    if (metrics) {
+      push(base({
+        ts: updatedAt,
+        type: "model.usage",
+        model: stringField(signals, "primaryModelId") || model,
+        confidence: "partial",
+        metrics,
+        refs: stringRefs({ sourceId: `${sessionId}:usage:signals` })
+      }), lineNumber + 1, "signals", "model.usage");
+    }
+  }
+  if (updatedAt) {
+    push(base({
+      ts: updatedAt,
+      type: "session.ended",
+      confidence: "derived",
+      refs: stringRefs({ sourceId: `${sessionId}:ended` })
+    }), lineNumber + 2, "summary", "session.ended");
+  }
+  return events;
+}
+function resolveSessionDir(filePath) {
+  const base = path13.basename(filePath);
+  if (base === "summary.json" || base === "events.jsonl" || base === "signals.json") {
+    return path13.dirname(filePath);
+  }
+  if (base.match(/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i)) {
+    return filePath;
+  }
+  return void 0;
+}
+function mcpToolName(raw) {
+  const server = stringField(raw, "server_name");
+  const tool = stringField(raw, "tool_name");
+  if (server && tool) {
+    return `${server}__${tool}`;
+  }
+  return tool || server || "mcp_tool";
+}
+function findPendingToolId(pending, toolName) {
+  for (const [id, item] of pending) {
+    if (item.name === toolName) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function isShellTool(name) {
+  if (!name) {
+    return false;
+  }
+  const lower = name.toLowerCase();
+  return lower === "run_terminal_command" || lower === "bash" || lower === "shell" || lower.endsWith("__run_terminal_command");
+}
+function fileActivitiesFromTool(toolName, input, ts, cwd) {
+  const lower = toolName.toLowerCase();
+  if (isShellTool(toolName)) {
+    const command = stringField(input, "command");
+    if (command) {
+      return fileActivitiesFromShellCommand(command, ts, cwd, cwd);
+    }
+    return [];
+  }
+  if (lower === "read_file" || lower.endsWith("__read_file")) {
+    const target = stringField(input, "target_file") || stringField(input, "path");
+    if (!target) {
+      return [];
+    }
+    return [{
+      ts,
+      path: displayPath(target, cwd),
+      operation: "read",
+      confidence: "exact"
+    }];
+  }
+  if (lower === "search_replace" || lower === "write" || lower.endsWith("__search_replace") || lower.endsWith("__write")) {
+    const target = stringField(input, "file_path") || stringField(input, "target_file") || stringField(input, "path");
+    if (!target) {
+      return [];
+    }
+    return [{
+      ts,
+      path: displayPath(target, cwd),
+      operation: "edit",
+      confidence: "exact"
+    }];
+  }
+  return [];
+}
+function displayPath(filePath, cwd) {
+  if (!cwd || !path13.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const relative = path13.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path13.isAbsolute(relative) ? relative : filePath;
+}
+async function loadToolInputsFromUpdates(updatesPath) {
+  const map = /* @__PURE__ */ new Map();
+  let text = "";
+  try {
+    text = await readFile8(updatesPath, "utf8");
+  } catch {
+    return map;
+  }
+  for (const line of text.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
+    }
+    const params = objectField(raw, "params");
+    const update = objectField(params, "update");
+    const sessionUpdate = stringField(update, "sessionUpdate");
+    if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") {
+      continue;
+    }
+    const toolCallId = stringField(update, "toolCallId");
+    if (!toolCallId) {
+      continue;
+    }
+    const meta = objectField(update, "_meta");
+    const toolMeta = objectField(meta, "x.ai/tool");
+    const name = stringField(toolMeta, "name") || stringField(update, "title") || "unknown";
+    const rawInput = objectField(update, "rawInput");
+    const nestedInput = objectField(toolMeta, "input");
+    const input = Object.keys(rawInput).length > 0 ? rawInput : nestedInput;
+    if (!map.has(toolCallId) || Object.keys(input).length > 0) {
+      map.set(toolCallId, { name, input });
+    }
+  }
+  return map;
+}
+function metricsFromSignals(signals) {
+  const contextTokens = numberField(signals, "contextTokensUsed");
+  const toolCallCount = numberField(signals, "toolCallCount");
+  const turnCount = numberField(signals, "turnCount");
+  const durationSec = numberField(signals, "sessionDurationSeconds");
+  const linesAdded = numberField(signals, "agentLinesAdded");
+  const linesRemoved = numberField(signals, "agentLinesRemoved");
+  if (contextTokens === void 0 && toolCallCount === void 0 && turnCount === void 0 && durationSec === void 0) {
+    return void 0;
+  }
+  const metrics = {};
+  if (contextTokens !== void 0 && contextTokens > 0) {
+    metrics.tokensTotal = contextTokens;
+    metrics.tokensInput = contextTokens;
+  }
+  if (toolCallCount !== void 0) {
+    metrics.toolCalls = toolCallCount;
+  }
+  if (turnCount !== void 0) {
+    metrics.modelCalls = turnCount;
+  }
+  if (durationSec !== void 0) {
+    metrics.durationMs = Math.round(durationSec * 1e3);
+  }
+  if (linesAdded !== void 0) {
+    metrics.linesAdded = linesAdded;
+  }
+  if (linesRemoved !== void 0) {
+    metrics.linesRemoved = linesRemoved;
+  }
+  return metrics;
+}
+var grokHandler = (msg) => hookHandler(SOURCE_ID, msg);
+function hookConfig5() {
+  const anyTool = [{ matcher: ".*", hooks: [grokHandler("Reporting tool activity")] }];
+  return {
+    hooks: {
+      SessionStart: [{ hooks: [grokHandler("Reporting session start")] }],
+      SessionEnd: [{ hooks: [grokHandler("Reporting session end")] }],
+      UserPromptSubmit: [{ hooks: [grokHandler("Reporting prompt activity")] }],
+      PreToolUse: anyTool,
+      PostToolUse: anyTool,
+      PostToolUseFailure: anyTool,
+      PermissionDenied: anyTool,
+      SubagentStart: [{ hooks: [grokHandler("Reporting subagent start")] }],
+      SubagentStop: [{ hooks: [grokHandler("Reporting subagent completion")] }],
+      Stop: [{ hooks: [grokHandler("Reporting turn completion")] }],
+      StopFailure: [{ hooks: [grokHandler("Reporting turn failure")] }],
+      PostCompact: [{ hooks: [grokHandler("Reporting context compaction")] }]
+    }
+  };
+}
+function createGrokBuildAdapter() {
+  return {
+    id: SOURCE_ID,
+    label: "Grok Build",
+    agentName: AGENT_NAME,
+    kind: "agent",
+    detectPath(home, env) {
+      return grokHome(home, env);
+    },
+    installedPath(home, env) {
+      return grokHooksPath(home, env);
+    },
+    async isInstalled(home, env) {
+      return isHooksJsonInstalled(grokHooksPath(home, env), HOOK_COMMAND);
+    },
+    installEntries(home, env) {
+      return [{
+        kind: "hooks-json",
+        path: grokHooksPath(home, env),
+        content: hookConfig5()
+      }];
+    },
+    sourcePaths(home, env) {
+      return [grokSessionsDir(home, env)];
+    },
+    parseSessionFile: parseGrokSessionFile
+  };
+}
+
+// src/adapters/opencode.ts
+import os6 from "node:os";
+import path14 from "node:path";
+async function parseOpenCodeSessionFile(dbPath, options) {
+  const { DatabaseSync } = await import("node:sqlite");
+  if (!dbPath.endsWith(".db")) {
+    return [];
+  }
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  const events = [];
+  try {
+    const sessionCols = new Set(
+      db.prepare("PRAGMA table_info(session)").all().map((row) => row.name)
+    );
+    const hasDirectory = sessionCols.has("directory");
+    const hasPath = sessionCols.has("path");
+    const hasArchived = sessionCols.has("time_archived");
+    const selectCols = ["id", "title", "time_created"];
+    if (hasDirectory) {
+      selectCols.push("directory");
+    }
+    if (hasPath) {
+      selectCols.push("path");
+    }
+    if (hasArchived) {
+      selectCols.push("time_archived");
+    }
+    const sessions = db.prepare(
+      `SELECT ${selectCols.join(", ")} FROM session WHERE time_created IS NOT NULL ORDER BY time_created`
+    ).all();
+    for (const session of sessions) {
+      const sessionId = session.id;
+      const cwd = session.directory || session.path || void 0;
+      const project = cwd ? path14.basename(cwd) : void 0;
+      const sessionTs = msToIso(session.time_created);
+      events.push(baseOpenCodeEvent({
+        ts: sessionTs,
+        type: "session.started",
+        sessionId,
+        cwd,
+        project,
+        operation: "session start"
+      }));
+      const messages = db.prepare(
+        "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created"
+      ).all(sessionId);
+      let currentTurnId;
+      let currentProvider;
+      let turnTs;
+      let reasoningEffort;
+      const modelSwitchedEvents = db.prepare(
+        "SELECT data FROM event WHERE aggregate_id = ? AND type = 'session.next.model.switched.1' ORDER BY seq"
+      ).all(sessionId);
+      for (const evt of modelSwitchedEvents) {
+        try {
+          const evtData = JSON.parse(evt.data);
+          const variant = isPlainObject(evtData) ? stringField(evtData.model || evtData, "variant") : void 0;
+          if (variant && variant !== "default") {
+            reasoningEffort = variant;
+          }
+        } catch {
+        }
+      }
+      for (const msg of messages) {
+        let info;
+        try {
+          info = JSON.parse(msg.data);
+        } catch {
+          continue;
+        }
+        if (!isPlainObject(info)) {
+          continue;
+        }
+        const role = stringField(info, "role");
+        const timeObj = objectField(info, "time");
+        const timeCreated = numberField(timeObj, "created");
+        if (!role || !timeCreated) {
+          continue;
+        }
+        if (role === "user") {
+          currentTurnId = `turn_${createStableHash([sessionId, msg.id]).slice(0, 24)}`;
+          turnTs = msToIso(timeCreated);
+          const userAgent = stringField(info, "agent") || "opencode";
+          const modelObj = objectField(info, "model");
+          const model = modelObj ? stringField(modelObj, "modelID") : void 0;
+          currentProvider = modelObj ? stringField(modelObj, "providerID") : void 0;
+          events.push(baseOpenCodeEvent({
+            ts: turnTs,
+            type: "turn.started",
             sessionId,
             turnId: currentTurnId,
             cwd,
@@ -5199,7 +6420,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const provider = currentProvider;
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path13.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path14.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -5447,33 +6668,33 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path13.resolve(override);
+    return path14.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path13.join(path13.resolve(xdgConfig), "opencode");
+    return path14.join(path14.resolve(xdgConfig), "opencode");
   }
-  return path13.join(home, ".config", "opencode");
+  return path14.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  const primary = xdgData && xdgData.trim() ? path13.join(path13.resolve(xdgData), "opencode", "opencode.db") : path13.join(home, ".local", "share", "opencode", "opencode.db");
-  return [primary, path13.join(home, ".opencode", "opencode.db")];
+  const primary = xdgData && xdgData.trim() ? path14.join(path14.resolve(xdgData), "opencode", "opencode.db") : path14.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path14.join(home, ".opencode", "opencode.db")];
 }
 async function opencodeBackfillFiles(sourceRoot, home = os6.homedir(), env) {
-  const { stat: stat13 } = await import("node:fs/promises");
+  const { stat: stat14 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat13(sourceRoot).catch(() => null);
+    const info = await stat14(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of opencodeDataCandidates(home, env)) {
-    const info = await stat13(candidatePath).catch(() => null);
+    const info = await stat14(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -5548,12 +6769,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path13.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path14.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path13.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path13.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path14.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path14.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -5561,7 +6782,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path13.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path14.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -5573,10 +6794,10 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import path15 from "node:path";
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile8(filePath, "utf8");
+  const text = await readFile9(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -5607,7 +6828,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path14.basename(cwd) : project;
+      project = cwd ? path15.basename(cwd) : project;
       continue;
     }
     if (entryType === "model_change") {
@@ -6016,16 +7237,16 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
-  return path14.join(home, ".pi", "agent");
+  return path15.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
-  return path14.join(piAgentDir(home, env), "sessions");
+  return path15.join(piAgentDir(home, env), "sessions");
 }
 function createPiAdapter() {
   return {
@@ -6037,12 +7258,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path14.join(piAgentDir(home, env), "extensions", "vibetime.ts");
+      return path15.join(piAgentDir(home, env), "extensions", "vibetime.ts");
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path14.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
+        return await pathExists2(path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
       } catch {
         return false;
       }
@@ -6050,7 +7271,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path14.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
+        path: path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -6062,11 +7283,11 @@ function createPiAdapter() {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir6, readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
 import os7 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function parseQoderCnPaths(filePath) {
-  const parts = filePath.split(path15.sep);
+  const parts = filePath.split(path16.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -6075,20 +7296,20 @@ function parseQoderCnPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path15.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path15.basename(filename, ".jsonl");
+    sessionId = path16.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path15.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderCnModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path15.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile9(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path16.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile10(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -6105,15 +7326,15 @@ async function loadQoderCnModelNames(configDir2) {
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
-  const segmentsPath = path15.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path16.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir6(segmentsPath);
+    const files = await readdir7(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile9(path15.join(segmentsPath, file), "utf8");
+      const content = await readFile10(path16.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -6146,7 +7367,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderCnSessionFile(filePath, options) {
-  const text = await readFile9(filePath, "utf8");
+  const text = await readFile10(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderCnPaths(filePath);
   const projectContext = await qoderCnProjectContextFromLines(filePath, lines, options, configDir2);
@@ -6181,7 +7402,7 @@ async function parseQoderCnSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path15.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path16.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -6482,7 +7703,7 @@ function fileActivitiesFromQoderCnToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromQoderCnToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField3(input, "edits")) {
+  for (const edit of arrayField4(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -6526,17 +7747,17 @@ function fileMetricsFromQoderCnToolInput(tool, input) {
   }
   return {};
 }
-function arrayField3(object, key) {
+function arrayField4(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function qoderCnToolUseItems(message) {
-  return arrayField3(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function qoderCnToolResultItems(message) {
-  return arrayField3(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isQoderCnToolResultMessage(message) {
   return qoderCnToolResultItems(message).length > 0;
@@ -6610,28 +7831,28 @@ function isNoisePrompt(text) {
 }
 async function qoderCnProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderCnPaths(filePath);
-  const isSubagent = filePath.includes(`${path15.sep}subagents${path15.sep}`);
+  const isSubagent = filePath.includes(`${path16.sep}subagents${path16.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path15.isAbsolute(cwd)) {
+    if (cwd && path16.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path15.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path16.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path15.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path16.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile9(parentSessionPath, "utf8");
+        const parentText = await readFile10(parentSessionPath, "utf8");
         const parentCwds = [];
         for (const line of parentText.split("\n").filter(Boolean)) {
           const raw = parseJsonLine(line);
           const cwd = raw ? stringField(raw, "cwd") : void 0;
-          if (cwd && path15.isAbsolute(cwd)) {
+          if (cwd && path16.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -6643,7 +7864,7 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
     }
   }
   const root = await gitRootFromCwds2(cwds) || qoderCnProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path15.basename(cwds[0]) : root ? path15.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path16.basename(cwds[0]) : root ? path16.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -6652,15 +7873,15 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
 async function gitRootFromCwds2(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path15.resolve(cwd);
+    let current = path16.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat7(path15.join(current, ".git"));
+        await stat8(path16.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path15.dirname(current);
+      const parent = path16.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6671,12 +7892,12 @@ async function gitRootFromCwds2(cwds) {
 }
 function qoderCnProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path15.resolve(cwd);
+    let current = path16.resolve(cwd);
     while (true) {
       if (encodeQoderCnProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path15.dirname(current);
+      const parent = path16.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6686,14 +7907,14 @@ function qoderCnProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderCnProjectPath(value) {
-  return path15.resolve(value).split(path15.sep).join("-").replace(/_/g, "-");
+  return path16.resolve(value).split(path16.sep).join("-").replace(/_/g, "-");
 }
 async function qoderCnProjectFromFilePath(filePath, options) {
-  const projectDir = path15.basename(path15.dirname(filePath));
-  const home = options ? path15.resolve(stringOption(options.home) || os7.homedir()) : os7.homedir();
+  const projectDir = path16.basename(path16.dirname(filePath));
+  const home = options ? path16.resolve(stringOption(options.home) || os7.homedir()) : os7.homedir();
   const resolved = await resolveQoderCnProjectPath(projectDir, home);
   if (resolved) {
-    return path15.basename(resolved);
+    return path16.basename(resolved);
   }
   const homePrefix = `${encodeQoderCnProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
@@ -6713,12 +7934,12 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   while (projectDir.startsWith(`${currentEncoded}-`)) {
     let matchedChild;
     try {
-      const entries = await readdir6(current, { withFileTypes: true });
+      const entries = await readdir7(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path15.join(current, entry.name);
+        const candidate = path16.join(current, entry.name);
         const encoded = encodeQoderCnProjectPath(candidate);
         if (encoded === projectDir) {
           return candidate;
@@ -6740,7 +7961,7 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   return void 0;
 }
 var qoderCnHandler = (msg) => hookHandler("qoder-cn", msg);
-function hookConfig5() {
+function hookConfig6() {
   const anyTool = [{ matcher: ".*", hooks: [qoderCnHandler("Reporting tool activity")] }];
   return {
     hooks: {
@@ -6763,9 +7984,9 @@ function hookConfig5() {
 function qoderCnConfigDir(home, env) {
   const override = env?.QODER_CN_CONFIG_DIR;
   if (override && override.trim()) {
-    return path15.resolve(override);
+    return path16.resolve(override);
   }
-  return path15.join(home, ".qoder-cn");
+  return path16.join(home, ".qoder-cn");
 }
 function createQoderCnAdapter() {
   return {
@@ -6777,27 +7998,27 @@ function createQoderCnAdapter() {
       return qoderCnConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path15.join(qoderCnConfigDir(home, env), "settings.json");
+      return path16.join(qoderCnConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path15.join(qoderCnConfigDir(home, env), "settings.json"),
+        path16.join(qoderCnConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder-cn"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path15.join(qoderCnConfigDir(home, env), "settings.json"),
-        content: hookConfig5()
+        path: path16.join(qoderCnConfigDir(home, env), "settings.json"),
+        content: hookConfig6()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderCnConfigDir(home, env);
       return [
-        path15.join(base, "projects"),
-        path15.join(base, ".qoder.json"),
-        path15.join(home, ".qoder.json")
+        path16.join(base, "projects"),
+        path16.join(base, ".qoder.json"),
+        path16.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderCnSessionFile
@@ -6805,11 +8026,11 @@ function createQoderCnAdapter() {
 }
 
 // src/adapters/qoder.ts
-import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir8, readFile as readFile11, stat as stat9 } from "node:fs/promises";
 import os8 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 function parseQoderPaths(filePath) {
-  const parts = filePath.split(path16.sep);
+  const parts = filePath.split(path17.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -6818,20 +8039,20 @@ function parseQoderPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path16.basename(filename, ".jsonl");
+    sessionId = path17.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path16.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile10(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path17.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile11(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -6848,15 +8069,15 @@ async function loadQoderModelNames(configDir2) {
 }
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
-  const segmentsPath = path16.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path17.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir7(segmentsPath);
+    const files = await readdir8(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile10(path16.join(segmentsPath, file), "utf8");
+      const content = await readFile11(path17.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -6889,7 +8110,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderSessionFile(filePath, options) {
-  const text = await readFile10(filePath, "utf8");
+  const text = await readFile11(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderPaths(filePath);
   const projectContext = await qoderProjectContextFromLines(filePath, lines, options, configDir2);
@@ -6924,7 +8145,7 @@ async function parseQoderSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path16.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path17.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -7225,7 +8446,7 @@ function fileActivitiesFromQoderToolUse(tool, input, ts, cwd) {
     const metrics = fileMetricsFromQoderToolInput(tool, input);
     addResolvedPathActivity(changes, filePath, operation, ts, cwd, workdir, metrics);
   }
-  for (const edit of arrayField4(input, "edits")) {
+  for (const edit of arrayField5(input, "edits")) {
     if (!isPlainObject(edit)) {
       continue;
     }
@@ -7269,17 +8490,17 @@ function fileMetricsFromQoderToolInput(tool, input) {
   }
   return {};
 }
-function arrayField4(object, key) {
+function arrayField5(object, key) {
   if (!isPlainObject(object) || !Array.isArray(object[key])) {
     return [];
   }
   return object[key];
 }
 function qoderToolUseItems(message) {
-  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
+  return arrayField5(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_use");
 }
 function qoderToolResultItems(message) {
-  return arrayField4(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
+  return arrayField5(message, "content").filter((item) => isPlainObject(item) && item.type === "tool_result");
 }
 function isQoderToolResultMessage(message) {
   return qoderToolResultItems(message).length > 0;
@@ -7319,28 +8540,28 @@ function qoderExtractText(value) {
 }
 async function qoderProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderPaths(filePath);
-  const isSubagent = filePath.includes(`${path16.sep}subagents${path16.sep}`);
+  const isSubagent = filePath.includes(`${path17.sep}subagents${path17.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path16.isAbsolute(cwd)) {
+    if (cwd && path17.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path16.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path17.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path16.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path17.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile10(parentSessionPath, "utf8");
+        const parentText = await readFile11(parentSessionPath, "utf8");
         const parentCwds = [];
         for (const line of parentText.split("\n").filter(Boolean)) {
           const raw = parseJsonLine(line);
           const cwd = raw ? stringField(raw, "cwd") : void 0;
-          if (cwd && path16.isAbsolute(cwd)) {
+          if (cwd && path17.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -7352,7 +8573,7 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     }
   }
   const root = await gitRootFromCwds3(cwds) || qoderProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path16.basename(cwds[0]) : root ? path16.basename(root) : await qoderProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path17.basename(cwds[0]) : root ? path17.basename(root) : await qoderProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -7361,15 +8582,15 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path16.resolve(cwd);
+    let current = path17.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat8(path16.join(current, ".git"));
+        await stat9(path17.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path16.dirname(current);
+      const parent = path17.dirname(current);
       if (parent === current) {
         break;
       }
@@ -7380,12 +8601,12 @@ async function gitRootFromCwds3(cwds) {
 }
 function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path16.resolve(cwd);
+    let current = path17.resolve(cwd);
     while (true) {
       if (encodeQoderProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path16.dirname(current);
+      const parent = path17.dirname(current);
       if (parent === current) {
         break;
       }
@@ -7395,10 +8616,10 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderProjectPath(value) {
-  return path16.resolve(value).split(path16.sep).join("-").replace(/_/g, "-");
+  return path17.resolve(value).split(path17.sep).join("-").replace(/_/g, "-");
 }
 function rawQoderProjectPath(value) {
-  return path16.resolve(value).split(path16.sep).join("-");
+  return path17.resolve(value).split(path17.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
@@ -7414,11 +8635,11 @@ function qoderEncodedProjectSuffix(projectDir, home) {
   return void 0;
 }
 async function qoderProjectFromFilePath(filePath, options) {
-  const projectDir = path16.basename(path16.dirname(filePath));
-  const home = options ? path16.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
+  const projectDir = path17.basename(path17.dirname(filePath));
+  const home = options ? path17.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
   const resolved = await resolveQoderProjectPath(projectDir, home);
   if (resolved) {
-    return path16.basename(resolved);
+    return path17.basename(resolved);
   }
   const suffix = qoderEncodedProjectSuffix(projectDir, home);
   if (suffix) {
@@ -7439,12 +8660,12 @@ async function resolveQoderProjectPath(projectDir, home) {
   while (currentEncodedVariants.some((prefix) => projectDir.startsWith(`${prefix}-`))) {
     let matchedChild;
     try {
-      const entries = await readdir7(current, { withFileTypes: true });
+      const entries = await readdir8(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path16.join(current, entry.name);
+        const candidate = path17.join(current, entry.name);
         const candidateVariants = qoderEncodedVariants(candidate);
         if (candidateVariants.includes(projectDir)) {
           return candidate;
@@ -7466,7 +8687,7 @@ async function resolveQoderProjectPath(projectDir, home) {
   return void 0;
 }
 var qoderHandler = (msg) => hookHandler("qoder", msg);
-function hookConfig6() {
+function hookConfig7() {
   const anyTool = [{ matcher: ".*", hooks: [qoderHandler("Reporting tool activity")] }];
   return {
     hooks: {
@@ -7489,9 +8710,9 @@ function hookConfig6() {
 function qoderConfigDir(home, env) {
   const override = env?.QODER_CONFIG_DIR;
   if (override && override.trim()) {
-    return path16.resolve(override);
+    return path17.resolve(override);
   }
-  return path16.join(home, ".qoder");
+  return path17.join(home, ".qoder");
 }
 function createQoderAdapter() {
   return {
@@ -7503,27 +8724,27 @@ function createQoderAdapter() {
       return qoderConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path16.join(qoderConfigDir(home, env), "settings.json");
+      return path17.join(qoderConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path16.join(qoderConfigDir(home, env), "settings.json"),
+        path17.join(qoderConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path16.join(qoderConfigDir(home, env), "settings.json"),
-        content: hookConfig6()
+        path: path17.join(qoderConfigDir(home, env), "settings.json"),
+        content: hookConfig7()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderConfigDir(home, env);
       return [
-        path16.join(base, "projects"),
-        path16.join(base, ".qoder.json"),
-        path16.join(home, ".qoder.json")
+        path17.join(base, "projects"),
+        path17.join(base, ".qoder.json"),
+        path17.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderSessionFile
@@ -7558,21 +8779,21 @@ function normalizeId(id) {
 }
 
 // src/adapters/workbuddy.ts
-import { readFile as readFile11, readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import path17 from "node:path";
+import { readFile as readFile12, readdir as readdir9, stat as stat10 } from "node:fs/promises";
+import path18 from "node:path";
 init_fs();
 function workbuddyProjectsDir(home, env) {
   const override = env?.WORKBUDDY_PROJECTS_DIR || env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path17.resolve(override, override.endsWith("projects") ? "" : "projects");
+    return path18.resolve(override, override.endsWith("projects") ? "" : "projects");
   }
-  return path17.join(home, ".workbuddy", "projects");
+  return path18.join(home, ".workbuddy", "projects");
 }
 function projectFromCwd(cwd, fallback) {
   if (!cwd) {
     return fallback;
   }
-  return path17.basename(cwd) || fallback;
+  return path18.basename(cwd) || fallback;
 }
 function sourceHash(filePath) {
   return `sha256:${createStableHash(filePath)}`;
@@ -7654,7 +8875,7 @@ function contentLength(value) {
   return 0;
 }
 async function readWorkbuddyLines(filePath) {
-  const text = await readFile11(filePath, "utf8");
+  const text = await readFile12(filePath, "utf8");
   return text.split(/\r?\n/).map((line, index) => {
     if (!line.trim()) {
       return void 0;
@@ -7674,8 +8895,8 @@ async function parseWorkbuddySessionFile(filePath, options) {
   }
   const events = [];
   const first = lines[0].record;
-  const sessionId = stringField(first, "sessionId") || path17.basename(filePath, ".jsonl");
-  const fallbackProject = path17.basename(path17.dirname(filePath));
+  const sessionId = stringField(first, "sessionId") || path18.basename(filePath, ".jsonl");
+  const fallbackProject = path18.basename(path18.dirname(filePath));
   const cwd = lines.map((line) => stringField(line.record, "cwd")).find(Boolean);
   const project = projectFromCwd(cwd, fallbackProject);
   const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
@@ -7844,17 +9065,17 @@ async function workbuddyBackfillFiles(sourceRoot, home, env) {
   const base = sourceRoot || workbuddyProjectsDir(home, env);
   const files = [];
   try {
-    const projects = await readdir8(base, { withFileTypes: true });
+    const projects = await readdir9(base, { withFileTypes: true });
     for (const project of projects) {
       if (!project.isDirectory()) {
         continue;
       }
-      const projectDir = path17.join(base, project.name);
-      const entries = await readdir8(projectDir, { withFileTypes: true });
+      const projectDir = path18.join(base, project.name);
+      const entries = await readdir9(projectDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-          const filePath = path17.join(projectDir, entry.name);
-          const info = await stat9(filePath);
+          const filePath = path18.join(projectDir, entry.name);
+          const info = await stat10(filePath);
           files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
         }
       }
@@ -7891,26 +9112,26 @@ function createWorkbuddyAdapter() {
 
 // src/adapters/zcode.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile12, stat as stat10 } from "node:fs/promises";
-import path18 from "node:path";
+import { readFile as readFile13, stat as stat11 } from "node:fs/promises";
+import path19 from "node:path";
 import { promisify as promisify2 } from "node:util";
 init_fs();
 var execFileAsync = promisify2(execFile);
 function zcodeCliDir(home, env) {
   const override = env?.ZCODE_CLI_DIR || env?.ZCODE_HOME;
   if (override && override.trim()) {
-    return path18.resolve(override, override.endsWith("cli") ? "" : "cli");
+    return path19.resolve(override, override.endsWith("cli") ? "" : "cli");
   }
-  return path18.join(home, ".zcode", "cli");
+  return path19.join(home, ".zcode", "cli");
 }
 function zcodeDbPath(home, env) {
-  return path18.join(zcodeCliDir(home, env), "db", "db.sqlite");
+  return path19.join(zcodeCliDir(home, env), "db", "db.sqlite");
 }
 var providerNameCache = null;
 async function loadProviderNames(configPath2) {
   let fileMtime = 0;
   try {
-    const info = await stat10(configPath2);
+    const info = await stat11(configPath2);
     fileMtime = info.mtimeMs;
   } catch {
     return /* @__PURE__ */ new Map();
@@ -7920,7 +9141,7 @@ async function loadProviderNames(configPath2) {
   }
   const map = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile12(configPath2, "utf-8");
+    const raw = await readFile13(configPath2, "utf-8");
     const config = JSON.parse(raw);
     const providers = config?.provider;
     if (isPlainObject(providers)) {
@@ -7938,7 +9159,7 @@ function sourceHash2(filePath) {
   return `sha256:${createStableHash(filePath)}`;
 }
 function projectFromDirectory(directory) {
-  return directory ? path18.basename(directory) || "zcode" : "zcode";
+  return directory ? path19.basename(directory) || "zcode" : "zcode";
 }
 function isoFromMs(value) {
   return timestampFrom(typeof value === "number" ? value : Number(value));
@@ -8094,16 +9315,16 @@ async function parseZCodeDb(filePath, options) {
   if (rows.length === 0) {
     return [];
   }
-  let candidate = path18.resolve(filePath);
+  let candidate = path19.resolve(filePath);
   let configPath2 = "";
   for (let i = 0; i < 12; i++) {
-    const probe = path18.join(candidate, ".zcode", "v2", "config.json");
+    const probe = path19.join(candidate, ".zcode", "v2", "config.json");
     try {
-      await stat10(probe);
+      await stat11(probe);
       configPath2 = probe;
       break;
     } catch {
-      const parent = path18.dirname(candidate);
+      const parent = path19.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -8319,9 +9540,9 @@ async function parseZCodeDb(filePath, options) {
 }
 async function zcodeBackfillFiles(sourceRoot, home, env) {
   const candidate = sourceRoot || zcodeDbPath(home, env);
-  const filePath = candidate.endsWith(".sqlite") ? candidate : path18.join(candidate, "db", "db.sqlite");
+  const filePath = candidate.endsWith(".sqlite") ? candidate : path19.join(candidate, "db", "db.sqlite");
   try {
-    const info = await stat10(filePath);
+    const info = await stat11(filePath);
     return [{ path: filePath, modifiedAt: info.mtime.toISOString() }];
   } catch {
     return [];
@@ -8352,6 +9573,404 @@ function createZCodeAdapter() {
   };
 }
 
+// src/adapters/zed.ts
+import os9 from "node:os";
+import path20 from "node:path";
+function zedThreadsCandidates(home, env) {
+  const candidates = [];
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    candidates.push(path20.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
+  } else if (platform2 === "win32") {
+    const appdata = env?.APPDATA;
+    if (appdata && appdata.trim()) {
+      candidates.push(path20.join(path20.resolve(appdata), "Zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
+  } else {
+    const xdgData = env?.XDG_DATA_HOME;
+    if (xdgData && xdgData.trim()) {
+      candidates.push(path20.join(path20.resolve(xdgData), "zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, ".local", "share", "zed", "threads", "threads.db"));
+    const xdgConfig = env?.XDG_CONFIG_HOME;
+    if (xdgConfig && xdgConfig.trim()) {
+      candidates.push(path20.join(path20.resolve(xdgConfig), "zed", "threads", "threads.db"));
+    }
+    candidates.push(path20.join(home, ".config", "zed", "threads", "threads.db"));
+  }
+  return candidates;
+}
+function zedConfigDir(home, env) {
+  const platform2 = process.platform;
+  if (platform2 === "darwin") {
+    return path20.join(home, "Library", "Application Support", "Zed");
+  }
+  if (platform2 === "win32") {
+    const appdata = env?.APPDATA;
+    if (appdata && appdata.trim()) {
+      return path20.join(path20.resolve(appdata), "Zed");
+    }
+    return path20.join(home, "AppData", "Roaming", "Zed");
+  }
+  const xdgConfig = env?.XDG_CONFIG_HOME;
+  if (xdgConfig && xdgConfig.trim()) {
+    return path20.join(path20.resolve(xdgConfig), "zed");
+  }
+  return path20.join(home, ".config", "zed");
+}
+function baseZedEvent(event) {
+  return {
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: "zed",
+    agent: "zed",
+    workspaceId: createWorkspaceId({ projectName: event.project, repoRoot: event.cwd }),
+    ...event
+  };
+}
+function zedUsageFromRequest(entry) {
+  const input = Math.max(0, numberField(entry, "input_tokens") || 0);
+  const output = Math.max(0, numberField(entry, "output_tokens") || 0);
+  if (input <= 0 && output <= 0) {
+    return void 0;
+  }
+  return {
+    tokensInput: input || void 0,
+    tokensOutput: output || void 0,
+    tokensTotal: input + output
+  };
+}
+function filePathFromToolInput(tool, input) {
+  if (!isPlainObject(input)) {
+    return void 0;
+  }
+  const direct = stringField(input, "path") || stringField(input, "file_path") || stringField(input, "filePath");
+  if (direct) {
+    return direct;
+  }
+  if (tool === "save_file") {
+    const paths = arrayField(input, "paths");
+    if (paths && paths.length > 0) {
+      const first = paths[0];
+      if (typeof first === "string") {
+        return first;
+      }
+    }
+  }
+  return void 0;
+}
+async function parseZedSessionFile(dbPath, options) {
+  const { DatabaseSync } = await import("node:sqlite");
+  const fzstd = await Promise.resolve().then(() => (init_esm(), esm_exports));
+  const decompress2 = fzstd.decompress;
+  if (!dbPath.endsWith(".db")) {
+    return [];
+  }
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  const events = [];
+  try {
+    const rows = db.prepare(
+      "SELECT id, data, data_type, updated_at, created_at, summary, folder_paths FROM threads ORDER BY updated_at"
+    ).all();
+    for (const row of rows) {
+      const sessionId = row.id;
+      const threadTs = row.updated_at;
+      if (!threadTs) {
+        continue;
+      }
+      const folderRaw = row.folder_paths || "";
+      const folder = folderRaw.split(/[\n,]/).map((s) => s.trim()).find(Boolean);
+      const cwd = folder || void 0;
+      const project = cwd ? path20.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
+      let json;
+      try {
+        const bytes = row.data_type === "zstd" ? decompress2(new Uint8Array(row.data)) : new Uint8Array(row.data);
+        json = JSON.parse(new TextDecoder().decode(bytes));
+      } catch {
+        continue;
+      }
+      if (!isPlainObject(json)) {
+        continue;
+      }
+      const modelObj = objectField(json, "model");
+      const model = modelObj ? stringField(modelObj, "model") : void 0;
+      const provider = modelObj ? stringField(modelObj, "provider") : void 0;
+      const requestUsage = objectField(json, "request_token_usage");
+      const messages = arrayField(json, "messages") || [];
+      events.push(baseZedEvent({
+        ts: row.created_at || threadTs,
+        type: "session.started",
+        sessionId,
+        cwd,
+        project,
+        model,
+        provider,
+        operation: "session start",
+        confidence: "partial"
+      }));
+      let currentTurnId;
+      let turnStarted = false;
+      let msgIndex = 0;
+      for (const msg of messages) {
+        msgIndex++;
+        if (!isPlainObject(msg)) {
+          continue;
+        }
+        const userPayload = objectField(msg, "User");
+        const agentPayload = objectField(msg, "Agent");
+        if (userPayload) {
+          if (turnStarted && currentTurnId) {
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "turn.completed",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              operation: "turn completed",
+              confidence: "partial"
+            }));
+          }
+          const requestId = stringField(userPayload, "id") || `${sessionId}:${msgIndex}`;
+          currentTurnId = `turn_${createStableHash([sessionId, requestId]).slice(0, 24)}`;
+          turnStarted = true;
+          events.push(baseZedEvent({
+            ts: threadTs,
+            type: "turn.started",
+            sessionId,
+            turnId: currentTurnId,
+            cwd,
+            project,
+            model,
+            provider,
+            operation: "turn start",
+            confidence: "partial"
+          }));
+          const content = arrayField(userPayload, "content") || [];
+          let promptText = "";
+          for (const part of content) {
+            if (!isPlainObject(part)) {
+              continue;
+            }
+            const text = stringField(part, "Text");
+            if (text) {
+              promptText += text;
+            }
+          }
+          if (promptText) {
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "prompt.submitted",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              operation: "prompt submitted",
+              confidence: "partial",
+              metrics: { prompts: 1, promptChars: promptText.length },
+              refs: stringRefs({ promptHash: `sha256:${createStableHash(promptText)}` })
+            }));
+          }
+          const usageEntry = requestUsage ? objectField(requestUsage, requestId) : void 0;
+          if (usageEntry) {
+            const usage = zedUsageFromRequest(usageEntry);
+            if (usage) {
+              const metrics = {
+                tokensInput: usage.tokensInput,
+                tokensOutput: usage.tokensOutput,
+                tokensTotal: usage.tokensTotal
+              };
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: "model.usage",
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                operation: "model usage",
+                confidence: "partial",
+                metrics
+              }));
+            }
+          }
+        }
+        if (agentPayload) {
+          const content = arrayField(agentPayload, "content") || [];
+          for (const part of content) {
+            if (!isPlainObject(part)) {
+              continue;
+            }
+            const toolUse = objectField(part, "ToolUse");
+            if (!toolUse) {
+              continue;
+            }
+            const tool = stringField(toolUse, "name") || "unknown";
+            const callId = stringField(toolUse, "id") || `call_${createStableHash([sessionId, currentTurnId || "", tool, msgIndex]).slice(0, 16)}`;
+            const input = objectField(toolUse, "input");
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: "tool.started",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              tool,
+              operation: `${tool} started`,
+              metrics: { toolCalls: 1 },
+              refs: stringRefs({ sourceId: callId }),
+              confidence: "exact"
+            }));
+            const toolResults = objectField(agentPayload, "tool_results");
+            const resultEntry = toolResults ? objectField(toolResults, callId) : void 0;
+            const isError = resultEntry ? Boolean(numberField(resultEntry, "is_error")) : false;
+            const success = !isError;
+            events.push(baseZedEvent({
+              ts: threadTs,
+              type: success ? "tool.completed" : "tool.failed",
+              sessionId,
+              turnId: currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              tool,
+              success,
+              operation: success ? `${tool} completed` : `${tool} failed`,
+              refs: stringRefs({ sourceId: callId }),
+              confidence: "exact"
+            }));
+            if (tool === "terminal") {
+              const command = input ? stringField(input, "command") : void 0;
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: success ? "command.completed" : "command.failed",
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                tool: "terminal",
+                success,
+                operation: success ? "command completed" : "command failed",
+                metrics: { commandCalls: 1 },
+                refs: stringRefs({
+                  sourceId: callId,
+                  commandHash: command ? `sha256:${createStableHash(String(command))}` : void 0
+                }),
+                confidence: "partial"
+              }));
+            }
+            const filePath = filePathFromToolInput(tool, input);
+            if (filePath) {
+              events.push(baseZedEvent({
+                ts: threadTs,
+                type: toolFileActivityType(tool),
+                sessionId,
+                turnId: currentTurnId,
+                cwd,
+                project,
+                model,
+                provider,
+                tool,
+                success,
+                operation: `${tool} file activity`,
+                fileActivities: [{
+                  ts: threadTs,
+                  path: filePath,
+                  operation: operationForTool(tool)
+                }],
+                refs: stringRefs({ sourceId: callId }),
+                confidence: "partial"
+              }));
+            }
+          }
+        }
+      }
+      if (turnStarted && currentTurnId) {
+        events.push(baseZedEvent({
+          ts: threadTs,
+          type: "turn.completed",
+          sessionId,
+          turnId: currentTurnId,
+          cwd,
+          project,
+          model,
+          provider,
+          operation: "turn completed",
+          confidence: "partial"
+        }));
+      }
+      events.push(baseZedEvent({
+        ts: threadTs,
+        type: "session.ended",
+        sessionId,
+        cwd,
+        project,
+        model,
+        provider,
+        operation: "session end",
+        confidence: "partial"
+      }));
+    }
+  } finally {
+    db.close();
+  }
+  return events.filter((event) => matchesBackfillFilters(event, options));
+}
+async function zedBackfillFiles(sourceRoot, home = os9.homedir(), env) {
+  const { stat: stat14 } = await import("node:fs/promises");
+  if (sourceRoot) {
+    if (!sourceRoot.endsWith(".db")) {
+      return [];
+    }
+    const info = await stat14(sourceRoot).catch(() => null);
+    if (!info) {
+      return [];
+    }
+    return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
+  }
+  for (const candidatePath of zedThreadsCandidates(home, env)) {
+    const info = await stat14(candidatePath).catch(() => null);
+    if (info) {
+      return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
+    }
+  }
+  return [];
+}
+function createZedAdapter() {
+  return {
+    id: "zed",
+    label: "Zed",
+    agentName: "zed",
+    kind: "ide",
+    detectPath(home, env) {
+      return zedConfigDir(home, env);
+    },
+    installedPath(home, env) {
+      return path20.join(zedConfigDir(home, env), "vibetime-marker");
+    },
+    async isInstalled() {
+      return false;
+    },
+    installEntries(_home, _env) {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return zedThreadsCandidates(home, env);
+    },
+    parseSessionFile: parseZedSessionFile
+  };
+}
+
 // src/lib/pricing.ts
 function estimateEventCostUsd(event) {
   if (event.type !== "model.usage") {
@@ -8583,11 +10202,11 @@ function buildSessionRollup(rollupKey, events) {
       bucket.activityCount += 1;
     }
     for (const file of event.fileActivities || []) {
-      const displayPath = displayBackfillPath(file.path);
-      const pathHash = `sha256:${createStableHash(displayPath)}`;
+      const displayPath2 = displayBackfillPath(file.path);
+      const pathHash = `sha256:${createStableHash(displayPath2)}`;
       const fileRollup = fileRollups.get(pathHash) || {
         pathHash,
-        displayPath,
+        displayPath: displayPath2,
         reads: 0,
         writes: 0,
         linesAdded: 0,
@@ -8796,15 +10415,15 @@ function hookCommandFromGroup(group) {
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path19 from "node:path";
+import path21 from "node:path";
 function configDir(home = homedir()) {
-  return path19.join(home, ".vibetime");
+  return path21.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path19.join(configDir(home), "config.json");
+  return path21.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path19.join(configDir(home), "machine-id");
+  return path21.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -8851,15 +10470,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir4, rename, stat as stat11 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir4, rename, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path20 from "node:path";
+import path22 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path20.join(home, ".vibetime", "logs");
+  return path22.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path20.join(logDir(home), name);
+  return path22.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -8869,7 +10488,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat11(file);
+    const info = await stat12(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -9034,8 +10653,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path22) {
-  return new URL(path22, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path24) {
+  return new URL(path24, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -9117,6 +10736,8 @@ function createRegistry() {
   registry.register(createQoderCnAdapter());
   registry.register(createWorkbuddyAdapter());
   registry.register(createZCodeAdapter());
+  registry.register(createGrokBuildAdapter());
+  registry.register(createZedAdapter());
   return registry;
 }
 var defaultContext = {
@@ -9629,11 +11250,17 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "copilot") {
     return copilotBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
   }
+  if (source.id === "grok-build") {
+    return grokBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
+  }
+  if (source.id === "zed") {
+    return zedBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
+  }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat12(filePath);
+    const info = await stat13(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -9946,13 +11573,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path21.join(home, ".vibetime", "backfill-state.json");
+  return path23.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path21.join(home, ".vibetime", "sync-local-trigger.json");
+  return path23.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path21.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path23.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 function backfillRemoteKey(baseUrl) {
   try {
@@ -10014,7 +11641,7 @@ async function readBackfillIncrementalStateFile(home, ctx) {
 }
 async function writeBackfillIncrementalStateFile(home, file) {
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir5(path21.dirname(statePath), { recursive: true });
+  await mkdir5(path23.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
@@ -10063,7 +11690,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir5(path21.dirname(statePath), { recursive: true });
+  await mkdir5(path23.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -10078,12 +11705,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir5(path21.dirname(lockPath), { recursive: true });
+  await mkdir5(path23.dirname(lockPath), { recursive: true });
   await writeFile4(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
 async function acquireSyncLocalLock(lockPath, lock) {
-  await mkdir5(path21.dirname(lockPath), { recursive: true });
+  await mkdir5(path23.dirname(lockPath), { recursive: true });
   try {
     const handle = await open(lockPath, "wx");
     try {
@@ -10163,10 +11790,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path21.resolve(path21.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path23.resolve(path23.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome3(options, ctx) {
-  return path21.resolve(stringOption(options.home) || ctx.env.HOME || os9.homedir());
+  return path23.resolve(stringOption(options.home) || ctx.env.HOME || os10.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;