@raindrop-ai/opencode-plugin 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -24,7 +24,521 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// ../core/dist/chunk-3V4MIA75.js
+// ../core/dist/chunk-BYBMRLZM.js
+var EVAL_CORRELATION_ID_ATTRIBUTE = "raindrop.eval_correlation_id";
+var PROBE_SCOPE = { correlationId: "" };
+var EvalScopeStorage = class {
+  constructor() {
+    this._als = null;
+    this._probed = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._probed) return;
+    this._probed = true;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (!Ctor) return;
+      const als = new Ctor();
+      als.run(PROBE_SCOPE, () => {
+      });
+      this._als = als;
+    } catch (e) {
+      this._als = null;
+    }
+  }
+  run(scope, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.run(scope, callback);
+    const previous = this._syncScope;
+    this._syncScope = scope;
+    try {
+      return callback();
+    } finally {
+      this._syncScope = previous;
+    }
+  }
+  current() {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return this._als.getStore();
+    return this._syncScope;
+  }
+};
+var EVAL_SCOPE_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.evalScopeStorage");
+function evalScopeStorage() {
+  const holder = globalThis;
+  let storage = holder[EVAL_SCOPE_STORAGE_KEY];
+  if (!storage) {
+    storage = new EvalScopeStorage();
+    holder[EVAL_SCOPE_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function currentEvalScope() {
+  try {
+    return evalScopeStorage().current();
+  } catch (e) {
+    return void 0;
+  }
+}
+function evalScopeAttributes() {
+  const scope = currentEvalScope();
+  if (!scope) return {};
+  return { [EVAL_CORRELATION_ID_ATTRIBUTE]: scope.correlationId };
+}
+
+// ../core/dist/chunk-WJOR6M7H.js
+var STATE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.replayTraceRoutingState");
+function state() {
+  const holder = globalThis;
+  let current = holder[STATE_KEY];
+  if (!current) {
+    let storage = null;
+    try {
+      const Ctor = globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+      if (Ctor) storage = new Ctor();
+    } catch (e) {
+      storage = null;
+    }
+    current = {
+      storage,
+      syncDestination: void 0,
+      spanDestinations: /* @__PURE__ */ new WeakMap()
+    };
+    holder[STATE_KEY] = current;
+  }
+  return current;
+}
+function currentReplayTraceDestination() {
+  var _a, _b;
+  const routing = state();
+  return (_b = (_a = routing.storage) == null ? void 0 : _a.getStore()) != null ? _b : routing.syncDestination;
+}
+function rememberReplayTraceDestination(span) {
+  const destination = currentReplayTraceDestination();
+  if (destination) state().spanDestinations.set(span, destination);
+}
+function copyReplayTraceDestination(source, target) {
+  const destination = state().spanDestinations.get(source);
+  if (destination) state().spanDestinations.set(target, destination);
+}
+function replayTraceDestinationFor(value) {
+  if (typeof value !== "object" && typeof value !== "function" || value === null) {
+    return void 0;
+  }
+  return state().spanDestinations.get(value);
+}
+function recordReplayExportedSpan(destination, spanId, traceId) {
+  var _a, _b;
+  if (!destination || !spanId || !traceId) return;
+  (_a = destination.exportedSpanIds) == null ? void 0 : _a.add(spanId);
+  (_b = destination.exportedTraceIds) == null ? void 0 : _b.add(traceId);
+}
+function replayTraceUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/v1/traces`;
+}
+function getAsyncLocalStorageCtor() {
+  return globalThis.RAINDROP_ASYNC_LOCAL_STORAGE;
+}
+var MAX_BINDING_STACK = 128;
+var EMPTY_STACK = [];
+var ContextStackStorage = class {
+  /** Emitted once when this runtime cannot support an ambient push. */
+  constructor(noAmbientBindWarning) {
+    this.noAmbientBindWarning = noAmbientBindWarning;
+    this._als = null;
+    this._enterWithUsable = false;
+    this._syncStack = EMPTY_STACK;
+    this._adoptionChecked = false;
+    this._warnedNoAmbientBind = false;
+  }
+  maybeAdoptAsyncLocalStorage() {
+    if (this._adoptionChecked) return;
+    this._adoptionChecked = true;
+    const Ctor = getAsyncLocalStorageCtor();
+    if (!Ctor) return;
+    const als = new Ctor();
+    try {
+      als.run(EMPTY_STACK, () => {
+      });
+    } catch (e) {
+      return;
+    }
+    this._als = als;
+    if (typeof als.enterWith === "function") {
+      try {
+        als.enterWith(EMPTY_STACK);
+        this._enterWithUsable = true;
+      } catch (e) {
+        this._enterWithUsable = false;
+      }
+    }
+  }
+  getStack() {
+    var _a;
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) return (_a = this._als.getStore()) != null ? _a : this._syncStack;
+    return this._syncStack;
+  }
+  /**
+   * Persist an ambient stack mutation. Returns false when an ALS is adopted but
+   * `enterWith` is unusable (workerd): callers must NOT fall back to the
+   * process-shared sync stack, since concurrent isolates would cross-stamp.
+   */
+  setAmbientStack(stack) {
+    if (this._als) {
+      if (!this._enterWithUsable) return false;
+      this._als.enterWith(stack);
+      return true;
+    }
+    this._syncStack = stack;
+    return true;
+  }
+  push(binding) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als && !this._enterWithUsable) {
+      this.warnNoAmbientBindOnce();
+      return;
+    }
+    let stack = this.getStack();
+    if (stack.length >= MAX_BINDING_STACK) {
+      stack = stack.filter((b) => b.isLive());
+      if (stack.length >= MAX_BINDING_STACK) {
+        stack = stack.slice(stack.length - (MAX_BINDING_STACK - 1));
+      }
+    }
+    this.setAmbientStack([...stack, binding]);
+  }
+  remove(binding) {
+    binding.markDead();
+    const stack = this.getStack();
+    const pruned = stack.filter((b) => b !== binding && b.isLive());
+    if (pruned.length !== stack.length) {
+      this.setAmbientStack(pruned);
+    }
+  }
+  runWith(binding, callback) {
+    this.maybeAdoptAsyncLocalStorage();
+    if (this._als) {
+      return this._als.run([...this.getStack(), binding], callback);
+    }
+    const previous = this._syncStack;
+    this._syncStack = [...previous, binding];
+    try {
+      return callback();
+    } finally {
+      this._syncStack = previous;
+    }
+  }
+  current() {
+    const stack = this.getStack();
+    if (stack.length === 0) return void 0;
+    const top = stack[stack.length - 1];
+    if (top.isLive()) return top;
+    const pruned = stack.filter((b) => b.isLive());
+    this.setAmbientStack(pruned);
+    return pruned.length > 0 ? pruned[pruned.length - 1] : void 0;
+  }
+  warnNoAmbientBindOnce() {
+    if (this._warnedNoAmbientBind) return;
+    this._warnedNoAmbientBind = true;
+    console.warn(this.noAmbientBindWarning);
+  }
+};
+var NO_AMBIENT_ROUTING_BIND_WARNING = "[raindrop] This runtime's AsyncLocalStorage does not implement enterWith (e.g. Cloudflare Workers), so begin()/finish() cannot scope auto-instrumented spans to a project without cross-contaminating concurrent requests. Manual events and explicit span routing are unaffected; use asCurrent()/withSpan (run-based) to route auto-instrumented spans on this runtime.";
+var ROUTING_STORAGE_KEY = /* @__PURE__ */ Symbol.for("raindrop.tracing.routingContextStorage");
+function routingStorage() {
+  const holder = globalThis;
+  let storage = holder[ROUTING_STORAGE_KEY];
+  if (!storage) {
+    storage = new ContextStackStorage(NO_AMBIENT_ROUTING_BIND_WARNING);
+    holder[ROUTING_STORAGE_KEY] = storage;
+  }
+  return storage;
+}
+function currentRoutingBinding() {
+  const bound = routingStorage().current();
+  if (!bound) return void 0;
+  return {
+    projectId: bound.projectId,
+    authHint: bound.authHint,
+    ...bound.appGit ? { appGit: bound.appGit } : {},
+    ...bound.appGitSource ? { appGitSource: bound.appGitSource } : {}
+  };
+}
+var APP_COMMIT_SHA = "raindrop.app.commit_sha";
+var APP_COMMIT_DIRTY = "raindrop.app.commit_dirty";
+var APP_BRANCH = "raindrop.app.branch";
+var APP_GIT_KEYS = [APP_COMMIT_SHA, APP_COMMIT_DIRTY, APP_BRANCH];
+var own = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function appGitExplicitKeys(properties) {
+  const keys = /* @__PURE__ */ new Set();
+  if (!properties) return keys;
+  for (const key of APP_GIT_KEYS) {
+    if (own(properties, key)) keys.add(key);
+  }
+  return keys;
+}
+function mergeAppGitSnapshot(base, properties, explicitKeys = /* @__PURE__ */ new Set()) {
+  try {
+    const result = { ...base };
+    if (properties && own(properties, APP_COMMIT_SHA) && properties[APP_COMMIT_SHA] !== result[APP_COMMIT_SHA]) {
+      if (!explicitKeys.has(APP_COMMIT_DIRTY) && !own(properties, APP_COMMIT_DIRTY)) {
+        delete result[APP_COMMIT_DIRTY];
+      }
+      if (!explicitKeys.has(APP_BRANCH) && !own(properties, APP_BRANCH)) {
+        delete result[APP_BRANCH];
+      }
+    }
+    for (const key of APP_GIT_KEYS) {
+      if (properties && own(properties, key)) result[key] = properties[key];
+    }
+    return Object.freeze(result);
+  } catch (e) {
+    return Object.freeze({});
+  }
+}
+function validAppCommitSha(value) {
+  if (typeof value !== "string" || value.length > 128) return void 0;
+  const cleaned = value.trim();
+  return /^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(cleaned) ? cleaned.toLowerCase() : void 0;
+}
+function shortString(value) {
+  if (typeof value !== "string" || value.length > 1024) return void 0;
+  const cleaned = value.trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function flag(value) {
+  if (value === true || value === "true" || value === "1") return true;
+  if (value === false || value === "false" || value === "0") return false;
+  return void 0;
+}
+function environment() {
+  try {
+    return typeof process === "undefined" ? {} : process.env;
+  } catch (e) {
+    return {};
+  }
+}
+var DEPLOYMENTS = [
+  ["VERCEL", "VERCEL_GIT_COMMIT_SHA", "VERCEL_GIT_COMMIT_REF"],
+  ["NETLIFY", "COMMIT_REF", "BRANCH"],
+  ["RAILWAY_ENVIRONMENT_NAME", "RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH"],
+  ["RAILWAY_ENVIRONMENT", "RAILWAY_GIT_COMMIT_SHA", "RAILWAY_GIT_BRANCH"],
+  ["RENDER", "RENDER_GIT_COMMIT", "RENDER_GIT_BRANCH"],
+  ["DYNO", "HEROKU_BUILD_COMMIT", ""],
+  ["DYNO", "HEROKU_SLUG_COMMIT", ""],
+  ["AWS_APP_ID", "AWS_COMMIT_ID", "AWS_BRANCH"],
+  ["WORKERS_CI", "WORKERS_CI_COMMIT_SHA", "WORKERS_CI_BRANCH"]
+];
+var CI_SOURCES = [
+  ["GITHUB_ACTIONS", "GITHUB_SHA", "GITHUB_REF_NAME"],
+  ["GITLAB_CI", "CI_COMMIT_SHA", "CI_COMMIT_REF_NAME"],
+  ["CIRCLECI", "CIRCLE_SHA1", "CIRCLE_BRANCH"]
+];
+function detectedSource(env, table, detectBranch) {
+  for (const row of table) {
+    const [marker, shaKey, branchKey] = row;
+    if (!marker || !shaKey || !shortString(env[marker]) || flag(env[marker]) === false) continue;
+    const commitSha = validAppCommitSha(env[shaKey]);
+    if (commitSha)
+      return {
+        commitSha,
+        ...detectBranch && branchKey ? { branch: shortString(env[branchKey]) } : {}
+      };
+  }
+  return {};
+}
+var AppGitContextImpl = class {
+  constructor(options, runtime = {}) {
+    this.defaults = {};
+    this.explicit = {};
+    this.explicitKeys = /* @__PURE__ */ new Set();
+    this.disposed = false;
+    this.operations = /* @__PURE__ */ new Map();
+    this.operationOverflow = false;
+    this.detectBranch = false;
+    this.disabled = false;
+    var _a, _b, _c, _d, _e, _f;
+    try {
+      if (options === false) {
+        this.disabled = true;
+        return;
+      }
+      const opts = options != null ? options : {};
+      const env = (_a = runtime.env) != null ? _a : environment();
+      const detectBranch = (_c = (_b = flag(opts.detectBranch)) != null ? _b : flag(env.RAINDROP_GIT_DETECT_BRANCH)) != null ? _c : false;
+      this.detectBranch = detectBranch;
+      const collectBranch = detectBranch || runtime.captureLegacyReplayBranch === true;
+      const autoDetect = runtime.allowDiscovery === false ? false : (_e = (_d = flag(opts.autoDetect)) != null ? _d : flag(env.RAINDROP_GIT_AUTO_DETECT)) != null ? _e : true;
+      const configuredSha = opts.commitSha;
+      const explicitSha = configuredSha === void 0 ? env.RAINDROP_COMMIT_SHA : configuredSha;
+      if (explicitSha === null) this.explicit[APP_COMMIT_SHA] = null;
+      else if (typeof explicitSha === "string" && validAppCommitSha(explicitSha))
+        this.explicit[APP_COMMIT_SHA] = explicitSha;
+      const configuredDirty = opts.commitDirty;
+      const explicitDirty = configuredDirty === void 0 ? flag(env.RAINDROP_COMMIT_DIRTY) : configuredDirty;
+      if (explicitDirty === null || typeof explicitDirty === "boolean")
+        this.explicit[APP_COMMIT_DIRTY] = explicitDirty;
+      const configuredBranch = opts.branch;
+      const explicitBranch = configuredBranch === void 0 ? env.RAINDROP_BRANCH : configuredBranch;
+      if (explicitBranch === null) this.explicit[APP_BRANCH] = null;
+      else if (typeof explicitBranch === "string" && explicitBranch.length <= 1024)
+        this.explicit[APP_BRANCH] = explicitBranch;
+      this.explicitKeys = appGitExplicitKeys(this.explicit);
+      this.defaults = { ...this.explicit };
+      if (!autoDetect || explicitSha !== void 0) return;
+      const sourceDirectory = (_f = shortString(opts.sourceDirectory)) != null ? _f : shortString(env.RAINDROP_GIT_SOURCE_DIRECTORY);
+      if (runtime.allowLocalGit === false && !sourceDirectory) return;
+      const deploy = sourceDirectory ? {} : detectedSource(env, DEPLOYMENTS, collectBranch);
+      if (deploy.commitSha) {
+        this.accept(deploy);
+        return;
+      }
+      const fallback = sourceDirectory ? {} : detectedSource(env, CI_SOURCES, collectBranch);
+      if (runtime.resolveLocal && (runtime.allowLocalGit !== false || sourceDirectory)) {
+        this.cancel = runtime.resolveLocal(sourceDirectory, collectBranch, (result) => {
+          try {
+            if (!this.disposed) this.accept(result.commitSha ? result : fallback);
+          } catch (e) {
+          }
+        });
+      } else this.accept(fallback);
+    } catch (e) {
+    }
+  }
+  accept(result) {
+    const sha = validAppCommitSha(result.commitSha);
+    if (!sha) return;
+    this.replayBranch = shortString(result.branch);
+    this.defaults = {
+      [APP_COMMIT_SHA]: sha,
+      ...typeof result.commitDirty === "boolean" ? { [APP_COMMIT_DIRTY]: result.commitDirty } : {},
+      ...this.detectBranch && this.replayBranch ? { [APP_BRANCH]: this.replayBranch } : {},
+      ...this.explicit
+    };
+  }
+  snapshot(properties) {
+    var _a;
+    try {
+      const binding = currentRoutingBinding();
+      const base = this.disabled && (binding == null ? void 0 : binding.appGitSource) !== "replay-override" ? {} : (_a = binding == null ? void 0 : binding.appGit) != null ? _a : this.defaults;
+      return this.mergeSnapshot(base, properties);
+    } catch (e) {
+      return Object.freeze({});
+    }
+  }
+  /** Safe defaults when no operation/span start was observed; never infer identity. */
+  snapshotExplicit(properties, eventId) {
+    try {
+      const base = { ...this.explicit };
+      const operation = eventId ? this.operations.get(eventId) : void 0;
+      if (operation) {
+        for (const key of operation.explicitKeys) base[key] = operation.snapshot[key];
+      }
+      return this.mergeSnapshot(base, properties, new Set(Object.keys(base)));
+    } catch (e) {
+      return mergeAppGitSnapshot({}, properties);
+    }
+  }
+  /** Existing replay branch reporting stays separate from opt-in event properties. */
+  snapshotForReplay() {
+    const snapshot = this.snapshot();
+    if (this.replayBranch && !own(snapshot, APP_BRANCH) && snapshot[APP_COMMIT_SHA] === this.defaults[APP_COMMIT_SHA]) {
+      return Object.freeze({ ...snapshot, [APP_BRANCH]: this.replayBranch });
+    }
+    return snapshot;
+  }
+  /** Merge a frozen span snapshot without losing client-authored provenance. */
+  mergeSnapshot(base, properties, explicitKeys = this.explicitKeys) {
+    return mergeAppGitSnapshot(base, properties, /* @__PURE__ */ new Set([...this.explicitKeys, ...explicitKeys]));
+  }
+  /** Shippers belonging to one client share this bounded operation registry. */
+  forOperation(eventId, properties, owner) {
+    if (!eventId) return this.snapshot(properties);
+    let operation = this.operations.get(eventId);
+    if (!operation) {
+      if (this.operations.size >= 1e4) this.operationOverflow = true;
+      if (this.operationOverflow) return this.mergeSnapshot({}, properties);
+      operation = {
+        snapshot: this.snapshot(properties),
+        owners: /* @__PURE__ */ new Set(),
+        unowned: owner === void 0,
+        explicitKeys: appGitExplicitKeys(properties)
+      };
+      this.operations.set(eventId, operation);
+    } else if (properties && APP_GIT_KEYS.some((key) => own(properties, key))) {
+      const explicitKeys = /* @__PURE__ */ new Set([...this.explicitKeys, ...operation.explicitKeys]);
+      operation.snapshot = this.mergeSnapshot(operation.snapshot, properties, explicitKeys);
+      for (const key of appGitExplicitKeys(properties)) operation.explicitKeys.add(key);
+    }
+    if (!owner) operation.unowned = true;
+    if (owner) operation.owners.add(owner);
+    return operation.snapshot;
+  }
+  releaseOperation(eventId, owner) {
+    const operation = this.operations.get(eventId);
+    if (!operation) return;
+    operation.owners.delete(owner);
+    if (operation.owners.size === 0 && !operation.unowned) this.operations.delete(eventId);
+  }
+  finishOperation(eventId) {
+    this.operations.delete(eventId);
+  }
+  dispose() {
+    var _a;
+    this.disposed = true;
+    try {
+      (_a = this.cancel) == null ? void 0 : _a.call(this);
+    } catch (e) {
+    }
+  }
+};
+var AppGitContext = AppGitContextImpl;
+function createAppGitContext(options, runtime = {}) {
+  return new AppGitContext(options, runtime);
+}
+function withAppGitProperties(properties, snapshot) {
+  try {
+    const merged = { ...properties };
+    for (const key of APP_GIT_KEYS)
+      if (!own(merged, key) && own(snapshot, key)) merged[key] = snapshot[key];
+    return merged;
+  } catch (e) {
+    return properties != null ? properties : {};
+  }
+}
+function withAppGitAttributes(attributes, snapshot) {
+  try {
+    const present = new Set(attributes.flatMap((attr) => attr ? [attr.key] : []));
+    const added = [];
+    for (const key of APP_GIT_KEYS) {
+      if (present.has(key) || present.has(`ai.telemetry.metadata.${key}`) || present.has(`traceloop.association.properties.${key}`))
+        continue;
+      const value = snapshot[key];
+      if (typeof value === "string") added.push({ key, value: { stringValue: value } });
+      else if (typeof value === "boolean") added.push({ key, value: { boolValue: value } });
+    }
+    return added.length ? [...attributes, ...added] : attributes;
+  } catch (e) {
+    return attributes;
+  }
+}
+function appGitPropertiesFromAttributes(attributes) {
+  var _a, _b, _c;
+  const properties = {};
+  try {
+    for (const attr of attributes) {
+      if (!attr) continue;
+      for (const key of APP_GIT_KEYS) {
+        if (attr.key === key || attr.key === `ai.telemetry.metadata.${key}` || attr.key === `traceloop.association.properties.${key}`) {
+          properties[key] = (_c = (_b = (_a = attr.value.stringValue) != null ? _a : attr.value.boolValue) != null ? _b : attr.value.intValue) != null ? _c : null;
+        }
+      }
+    }
+  } catch (e) {
+  }
+  return properties;
+}
 function getCrypto() {
   const c = globalThis.crypto;
   return c;
@@ -79,6 +593,25 @@ function base64Encode(bytes) {
   }
   return out;
 }
+function base64ToHex(value) {
+  if (!value) return "";
+  const maybeBuffer = globalThis.Buffer;
+  if (maybeBuffer) {
+    return maybeBuffer.from(value, "base64").toString("hex");
+  }
+  const atobFn = globalThis.atob;
+  if (typeof atobFn !== "function") return "";
+  try {
+    const binary = atobFn(value);
+    let hex = "";
+    for (let i = 0; i < binary.length; i++) {
+      hex += (binary.charCodeAt(i) & 255).toString(16).padStart(2, "0");
+    }
+    return hex;
+  } catch (e) {
+    return "";
+  }
+}
 function generateId() {
   return randomUUID();
 }
@@ -113,7 +646,7 @@ function runWithTracingSuppressed(fn) {
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
 var MAX_RETRY_DELAY_MS = 3e4;
 function wait(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 function formatEndpoint(endpoint) {
   if (!endpoint) return void 0;
@@ -150,9 +683,9 @@ async function raceWithTimeout(promise, timeoutMs) {
       () => true,
       () => true
     ),
-    new Promise((resolve) => {
+    new Promise((resolve2) => {
       var _a;
-      timer = setTimeout(() => resolve(false), Math.max(0, timeoutMs));
+      timer = setTimeout(() => resolve2(false), Math.max(0, timeoutMs));
       (_a = timer.unref) == null ? void 0 : _a.call(timer);
     })
   ]);
@@ -223,6 +756,7 @@ async function postJson(url, body, headers, opts) {
       const resp = await runWithTracingSuppressed(
         () => fetch(url, {
           method: "POST",
+          redirect: headers["X-Raindrop-Replay-Id"] !== void 0 ? "error" : "follow",
           headers: {
             "Content-Type": "application/json",
             ...headers
@@ -391,26 +925,29 @@ function resolveLocalDebuggerBaseUrl(baseUrl) {
   if (shouldAutoEnableLocalWorkshop()) return DEFAULT_LOCAL_WORKSHOP_URL;
   return null;
 }
+var LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS = 2e3;
 function mirrorTraceExportToLocalDebugger(body, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
-  void postJson(`${baseUrl}traces`, body, {}, {
+  if (!baseUrl) return Promise.resolve();
+  return postJson(`${baseUrl}traces`, body, {}, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
 function mirrorPartialEventToLocalDebugger(event, options = {}) {
   var _a;
   const baseUrl = resolveLocalDebuggerBaseUrl(options.baseUrl);
-  if (!baseUrl) return;
+  if (!baseUrl) return Promise.resolve();
   const headers = options.writeKey ? { Authorization: `Bearer ${options.writeKey}` } : {};
-  void postJson(`${baseUrl}events/track_partial`, event, headers, {
+  return postJson(`${baseUrl}events/track_partial`, event, headers, {
     maxAttempts: 1,
     debug: (_a = options.debug) != null ? _a : false,
-    sdkName: options.sdkName
+    sdkName: options.sdkName,
+    timeoutMs: LOCAL_DEBUGGER_MIRROR_TIMEOUT_MS
   }).catch(() => {
   });
 }
@@ -435,6 +972,13 @@ function projectIdHeaders(projectId) {
 }
 var SHUTDOWN_DEADLINE_MS = 1e4;
 var POST_SHUTDOWN_TIMEOUT_MS = 5e3;
+function appGitOwnerId(prefix) {
+  try {
+    return `${prefix}:${randomUUID()}`;
+  } catch (e) {
+    return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+}
 function mergePatches(target, source) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const out = { ...target, ...source };
@@ -484,22 +1028,25 @@ function eventTelemetryProperties(patch) {
 }
 var EventShipper = class {
   constructor(opts) {
+    this.appGitOwner = appGitOwnerId("event");
     this.buffers = /* @__PURE__ */ new Map();
     this.sticky = /* @__PURE__ */ new Map();
     this.timers = /* @__PURE__ */ new Map();
     this.inFlight = /* @__PURE__ */ new Set();
     this.hasShutdown = false;
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
-    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
+    this.ownsAppGitContext = opts.appGitContext === void 0;
+    this.writeKey = (_b = opts.writeKey) == null ? void 0 : _b.trim();
+    this.baseUrl = (_c = formatEndpoint(opts.endpoint)) != null ? _c : "https://api.raindrop.ai/v1/";
     this.enabled = opts.enabled !== false;
     this.debug = opts.debug;
-    this.partialFlushMs = (_c = opts.partialFlushMs) != null ? _c : 1e3;
-    this.sdkName = (_d = opts.sdkName) != null ? _d : "core";
+    this.partialFlushMs = (_d = opts.partialFlushMs) != null ? _d : 1e3;
+    this.sdkName = (_e = opts.sdkName) != null ? _e : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
-    this.defaultEventName = (_e = opts.defaultEventName) != null ? _e : "ai_generation";
+    this.defaultEventName = (_f = opts.defaultEventName) != null ? _f : "ai_generation";
     this.maxTextFieldCharsOpt = opts.maxTextFieldChars;
-    this.localDebuggerUrl = (_f = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _f : void 0;
+    this.localDebuggerUrl = (_g = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _g : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
     }
@@ -510,8 +1057,8 @@ var EventShipper = class {
     const isNode = typeof process !== "undefined" && typeof process.version === "string";
     this.context = {
       library: {
-        name: (_g = opts.libraryName) != null ? _g : "@raindrop-ai/core",
-        version: (_h = opts.libraryVersion) != null ? _h : "0.0.0"
+        name: (_h = opts.libraryName) != null ? _h : "@raindrop-ai/core",
+        version: (_i = opts.libraryVersion) != null ? _i : "0.0.0"
       },
       metadata: {
         jsRuntime: isNode ? "node" : "web",
@@ -519,6 +1066,9 @@ var EventShipper = class {
       }
     };
   }
+  ownAppGitContextForShutdown() {
+    this.ownsAppGitContext = true;
+  }
   isDebugEnabled() {
     return this.debug;
   }
@@ -567,6 +1117,15 @@ var EventShipper = class {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
     if (!this.enabled) return;
     if (!eventId || !eventId.trim()) return;
+    const capturedSticky = this.sticky.get(eventId);
+    const eventAlreadyKnown = capturedSticky !== void 0 || this.buffers.has(eventId);
+    const destination = currentReplayTraceDestination();
+    const cloudReplay = destination !== void 0 && destination.kind !== "workshop";
+    if ((capturedSticky == null ? void 0 : capturedSticky.replayOnly) === true || !eventAlreadyKnown && cloudReplay) {
+      if (patch.isPending === false) this.sticky.delete(eventId);
+      else this.sticky.set(eventId, { ...capturedSticky, replayOnly: true });
+      return;
+    }
     const maxChars = resolveMaxTextFieldChars(this.maxTextFieldCharsOpt);
     if (typeof patch.input === "string" && patch.input.length > maxChars) {
       patch = { ...patch, input: capText(patch.input, maxChars) };
@@ -588,6 +1147,13 @@ var EventShipper = class {
     }
     const sticky = (_c = this.sticky.get(eventId)) != null ? _c : {};
     const existing = (_d = this.buffers.get(eventId)) != null ? _d : {};
+    patch = {
+      ...patch,
+      properties: withAppGitProperties(
+        patch.properties,
+        this.appGitContext.forOperation(eventId, patch.properties, this.appGitOwner)
+      )
+    };
     const merged = mergePatches(existing, patch);
     merged.isPending = (_g = (_f = (_e = patch.isPending) != null ? _e : existing.isPending) != null ? _f : sticky.isPending) != null ? _g : true;
     this.buffers.set(eventId, merged);
@@ -601,6 +1167,8 @@ var EventShipper = class {
     if (t) clearTimeout(t);
     if (merged.isPending === false) {
       await this.flushOne(eventId);
+      if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(eventId, this.appGitOwner);
+      else this.appGitContext.finishOperation(eventId);
       return;
     }
     const timeout = setTimeout(() => {
@@ -625,15 +1193,21 @@ var EventShipper = class {
     try {
       for (const t of this.timers.values()) clearTimeout(t);
       this.timers.clear();
+      for (const [eventId, sticky] of this.sticky) {
+        if (sticky.replayOnly) this.sticky.delete(eventId);
+      }
       const settled = await raceWithTimeout(this.flush(), SHUTDOWN_DEADLINE_MS);
       if (!settled) this.warnShutdownDrop("in-flight request(s) at shutdown");
     } finally {
       this.shutdownDeadlineAt = void 0;
+      if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
   }
   async trackSignal(signal) {
     var _a, _b;
     if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") return;
     const body = [
       {
         event_id: signal.eventId,
@@ -668,6 +1242,8 @@ var EventShipper = class {
   }
   async identify(users) {
     if (!this.enabled) return;
+    const destination = currentReplayTraceDestination();
+    if (destination && destination.kind !== "workshop") return;
     const list = Array.isArray(users) ? users : [users];
     const body = list.filter((user) => {
       if (!(user == null ? void 0 : user.userId) || !user.userId.trim()) {
@@ -720,8 +1296,9 @@ var EventShipper = class {
     this.buffers.delete(eventId);
     if (!accumulated) return;
     const sticky = (_a = this.sticky.get(eventId)) != null ? _a : {};
-    const eventName = (_c = (_b = accumulated.eventName) != null ? _b : sticky.eventName) != null ? _c : this.defaultEventName;
-    const userId = (_d = accumulated.userId) != null ? _d : sticky.userId;
+    const isPending = (_c = (_b = accumulated.isPending) != null ? _b : sticky.isPending) != null ? _c : true;
+    const eventName = (_e = (_d = accumulated.eventName) != null ? _d : sticky.eventName) != null ? _e : this.defaultEventName;
+    const userId = (_f = accumulated.userId) != null ? _f : sticky.userId;
     if (!userId) {
       if (this.debug) {
         console.warn(`${this.prefix} skipping track_partial for ${eventId}: missing userId`);
@@ -729,14 +1306,13 @@ var EventShipper = class {
       this.sticky.delete(eventId);
       return;
     }
-    const { wizardSession, ...restProperties } = (_e = accumulated.properties) != null ? _e : {};
+    const { wizardSession, ...restProperties } = (_g = accumulated.properties) != null ? _g : {};
     let telemetryProperties = {};
     try {
       telemetryProperties = eventTelemetryProperties(accumulated);
     } catch (e) {
     }
-    const convoId = (_f = accumulated.convoId) != null ? _f : sticky.convoId;
-    const isPending = (_h = (_g = accumulated.isPending) != null ? _g : sticky.isPending) != null ? _h : true;
+    const convoId = (_h = accumulated.convoId) != null ? _h : sticky.convoId;
     const payload = {
       event_id: eventId,
       user_id: userId,
@@ -778,29 +1354,30 @@ var EventShipper = class {
         endpoint: url
       });
     }
-    if (this.localDebuggerUrl) {
-      mirrorPartialEventToLocalDebugger(payload, {
-        baseUrl: this.localDebuggerUrl,
-        writeKey: this.writeKey,
-        debug: this.debug,
-        sdkName: this.sdkName
-      });
-    }
+    const mirror = this.localDebuggerUrl ? mirrorPartialEventToLocalDebugger(payload, {
+      baseUrl: this.localDebuggerUrl,
+      writeKey: this.writeKey,
+      debug: this.debug,
+      sdkName: this.sdkName
+    }) : void 0;
     if (!this.writeKey) {
       if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
       return;
     }
     const opts = this.requestOpts();
     if (!opts) {
       this.warnShutdownDrop(`track_partial ${eventId}`);
       if (!isPending) this.sticky.delete(eventId);
+      if (mirror) await mirror;
       return;
     }
     const p = postJson(url, payload, this.requestHeaders(), opts);
-    this.inFlight.add(p);
+    const combined = mirror ? Promise.all([mirror, p]).then(() => void 0) : p;
+    this.inFlight.add(combined);
     try {
       try {
-        await p;
+        await combined;
         if (this.debug) {
           console.log(`${this.prefix} sent track_partial ${eventId} (${eventName})`);
         }
@@ -812,7 +1389,7 @@ var EventShipper = class {
         );
       }
     } finally {
-      this.inFlight.delete(p);
+      this.inFlight.delete(combined);
     }
     if (!isPending) {
       this.sticky.delete(eventId);
@@ -1065,6 +1642,13 @@ function redactJsonAttributeValue(key, value) {
   if (scrubbedJson === json) return void 0;
   return { stringValue: scrubbedJson };
 }
+function appGitOwnerId2(prefix) {
+  try {
+    return `${prefix}:${randomUUID()}`;
+  } catch (e) {
+    return `${prefix}:${Date.now().toString(36)}:${Math.random().toString(36).slice(2)}`;
+  }
+}
 function identityAttrs(args) {
   return [
     attrString("ai.telemetry.metadata.raindrop.ai.userId", args.userId),
@@ -1087,23 +1671,30 @@ function applyOtelSpanAttributeLimit(limit) {
 }
 var TraceShipper = class {
   constructor(opts) {
+    this.appGitOwner = appGitOwnerId2("trace");
+    this.appGitEventIds = /* @__PURE__ */ new WeakMap();
+    this.appGitActiveSpans = /* @__PURE__ */ new Map();
+    this.appGitCaptured = /* @__PURE__ */ new WeakSet();
+    this.appGitAdded = /* @__PURE__ */ new WeakMap();
     this.queue = [];
     this.inFlight = /* @__PURE__ */ new Set();
     this.hasShutdown = false;
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    this.writeKey = (_a = opts.writeKey) == null ? void 0 : _a.trim();
-    this.baseUrl = (_b = formatEndpoint(opts.endpoint)) != null ? _b : "https://api.raindrop.ai/v1/";
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+    this.appGitContext = (_a = opts.appGitContext) != null ? _a : createAppGitContext(opts.appGit);
+    this.ownsAppGitContext = opts.appGitContext === void 0;
+    this.writeKey = (_b = opts.writeKey) == null ? void 0 : _b.trim();
+    this.baseUrl = (_c = formatEndpoint(opts.endpoint)) != null ? _c : "https://api.raindrop.ai/v1/";
     this.enabled = opts.enabled !== false;
     this.debug = opts.debug;
     this.debugSpans = opts.debugSpans === true;
-    this.flushIntervalMs = (_c = opts.flushIntervalMs) != null ? _c : 1e3;
-    this.maxBatchSize = (_d = opts.maxBatchSize) != null ? _d : 50;
-    this.maxQueueSize = (_e = opts.maxQueueSize) != null ? _e : 5e3;
-    this.sdkName = (_f = opts.sdkName) != null ? _f : "core";
+    this.flushIntervalMs = (_d = opts.flushIntervalMs) != null ? _d : 1e3;
+    this.maxBatchSize = (_e = opts.maxBatchSize) != null ? _e : 50;
+    this.maxQueueSize = (_f = opts.maxQueueSize) != null ? _f : 5e3;
+    this.sdkName = (_g = opts.sdkName) != null ? _g : "core";
     this.prefix = `[raindrop-ai/${this.sdkName}]`;
-    this.serviceName = (_g = opts.serviceName) != null ? _g : "raindrop.core";
-    this.serviceVersion = (_h = opts.serviceVersion) != null ? _h : "0.0.0";
-    this.localDebuggerUrl = (_i = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _i : void 0;
+    this.serviceName = (_h = opts.serviceName) != null ? _h : "raindrop.core";
+    this.serviceVersion = (_i = opts.serviceVersion) != null ? _i : "0.0.0";
+    this.localDebuggerUrl = (_j = resolveLocalDebuggerBaseUrl(opts.localDebuggerUrl)) != null ? _j : void 0;
     if (this.debug && this.localDebuggerUrl) {
       console.log(`${this.prefix} Local debugger mirroring: ${this.localDebuggerUrl}`);
     }
@@ -1167,7 +1758,10 @@ var TraceShipper = class {
       try {
         const result = this.transformSpanHook(current);
         if (result === null) return null;
-        if (result !== void 0) current = result;
+        if (result !== void 0) {
+          copyReplayTraceDestination(current, result);
+          current = result;
+        }
       } catch (err) {
         if (this.debug) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -1177,13 +1771,19 @@ var TraceShipper = class {
       }
     }
     try {
-      current = normalizeModelUsageSpan(current);
+      const normalized = normalizeModelUsageSpan(current);
+      copyReplayTraceDestination(current, normalized);
+      current = normalized;
     } catch (e) {
     }
     if (!this.disableDefaultRedaction) {
-      current = defaultTransformSpan(current);
+      const redacted = defaultTransformSpan(current);
+      copyReplayTraceDestination(current, redacted);
+      current = redacted;
     }
-    return this.capSpanAttributes(current);
+    const capped = this.capSpanAttributes(current);
+    copyReplayTraceDestination(current, capped);
+    return capped;
   }
   isDebugEnabled() {
     return this.debug;
@@ -1195,46 +1795,84 @@ var TraceShipper = class {
     return { ...this.authHeaders(), ...projectIdHeaders(this.projectId) };
   }
   startSpan(args) {
-    var _a, _b;
+    var _a, _b, _c;
     const ids = createSpanIds(args.parent);
     const started = (_a = args.startTimeUnixNano) != null ? _a : nowUnixNanoString();
     const attrs = [
       attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
       ...identityAttrs(args),
-      attrString("ai.operationId", args.operationId)
+      attrString("ai.operationId", args.operationId),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_b = args.attributes) == null ? void 0 : _b.length) attrs.push(...args.attributes);
-    const span = { ids, name: args.name, startTimeUnixNano: started, attributes: attrs };
-    this.mirrorToLocalDebugger(
-      buildOtlpSpan({
-        ids: span.ids,
-        name: span.name,
-        startTimeUnixNano: span.startTimeUnixNano,
-        endTimeUnixNano: span.startTimeUnixNano,
-        // placeholder — will be updated on endSpan
-        attributes: span.attributes,
-        status: { code: SpanStatusCode.UNSET }
-      })
-    );
+    const tracksAppGit = this.appGitActiveSpans.has(args.eventId) || this.appGitActiveSpans.size < 1e4;
+    const appGitOverrides = appGitPropertiesFromAttributes(attrs);
+    const span = {
+      ids,
+      name: args.name,
+      startTimeUnixNano: started,
+      attributes: withAppGitAttributes(
+        attrs,
+        this.appGitContext.forOperation(args.eventId, appGitOverrides, this.appGitOwner)
+      )
+    };
+    rememberReplayTraceDestination(span);
+    this.appGitCaptured.add(span);
+    this.appGitEventIds.set(span, args.eventId);
+    if (tracksAppGit) {
+      this.appGitActiveSpans.set(args.eventId, ((_c = this.appGitActiveSpans.get(args.eventId)) != null ? _c : 0) + 1);
+    }
+    this.appGitAdded.set(span, new Set(span.attributes.filter((attr) => !attrs.includes(attr))));
+    const openSpan = buildOtlpSpan({
+      ids: span.ids,
+      name: span.name,
+      startTimeUnixNano: span.startTimeUnixNano,
+      endTimeUnixNano: span.startTimeUnixNano,
+      // placeholder — will be updated on endSpan
+      attributes: span.attributes,
+      status: { code: SpanStatusCode.UNSET }
+    });
+    copyReplayTraceDestination(span, openSpan);
+    this.mirrorToLocalDebugger(openSpan);
     return span;
   }
-  mirrorToLocalDebugger(span) {
-    if (!this.localDebuggerUrl) return;
+  mirrorToLocalDebugger(span, completed = false) {
+    const destination = replayTraceDestinationFor(span);
+    if (destination && destination.kind !== "workshop") return;
+    const localDebuggerUrl = (destination == null ? void 0 : destination.kind) === "workshop" ? destination.url : this.localDebuggerUrl;
+    if (!localDebuggerUrl) return;
     const redacted = this.redactSpan(span);
     if (redacted === null) return;
+    if (completed && (destination == null ? void 0 : destination.kind) === "workshop") {
+      recordReplayExportedSpan(
+        destination,
+        base64ToHex(redacted.spanId),
+        base64ToHex(redacted.traceId)
+      );
+    }
     const body = buildExportTraceServiceRequest([redacted], this.serviceName, this.serviceVersion);
-    mirrorTraceExportToLocalDebugger(body, {
-      baseUrl: this.localDebuggerUrl,
+    const p = mirrorTraceExportToLocalDebugger(body, {
+      baseUrl: localDebuggerUrl,
       debug: false,
       sdkName: this.sdkName
     });
+    this.inFlight.add(p);
+    void p.finally(() => {
+      this.inFlight.delete(p);
+    });
   }
   endSpan(span, extra) {
-    var _a, _b;
+    var _a, _b, _c;
     if (span.endTimeUnixNano) return;
     span.endTimeUnixNano = (_a = extra == null ? void 0 : extra.endTimeUnixNano) != null ? _a : nowUnixNanoString();
     if ((_b = extra == null ? void 0 : extra.attributes) == null ? void 0 : _b.length) {
+      const overrides = appGitPropertiesFromAttributes(extra.attributes);
+      const eventId2 = this.appGitEventIds.get(span);
+      const snapshot = eventId2 ? this.appGitContext.forOperation(eventId2, overrides, this.appGitOwner) : overrides;
+      const added = this.appGitAdded.get(span);
+      span.attributes = span.attributes.filter((attr) => !(added == null ? void 0 : added.has(attr)) || !attr || !Object.prototype.hasOwnProperty.call(overrides, APP_COMMIT_SHA) && !Object.prototype.hasOwnProperty.call(overrides, attr.key));
       span.attributes.push(...extra.attributes);
+      span.attributes = withAppGitAttributes(span.attributes, snapshot);
     }
     let status = extra == null ? void 0 : extra.status;
     if (!status && (extra == null ? void 0 : extra.error) !== void 0) {
@@ -1249,30 +1887,65 @@ var TraceShipper = class {
       attributes: span.attributes,
       status
     });
+    copyReplayTraceDestination(span, otlp);
+    this.appGitCaptured.add(otlp);
     this.enqueue(otlp);
-    this.mirrorToLocalDebugger(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
+    const eventId = this.appGitEventIds.get(span);
+    if (eventId && this.appGitActiveSpans.has(eventId)) {
+      const remaining = ((_c = this.appGitActiveSpans.get(eventId)) != null ? _c : 1) - 1;
+      if (remaining > 0) this.appGitActiveSpans.set(eventId, remaining);
+      else {
+        this.appGitActiveSpans.delete(eventId);
+        if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(eventId, this.appGitOwner);
+        else if (this.ownsAppGitContext) this.appGitContext.finishOperation(eventId);
+      }
+    }
   }
   createSpan(args) {
     var _a;
     const ids = createSpanIds(args.parent);
     const attrs = [
       attrString("ai.telemetry.metadata.raindrop.eventId", args.eventId),
-      ...identityAttrs(args)
+      ...identityAttrs(args),
+      ...Object.entries(evalScopeAttributes()).map(([key, value]) => attrString(key, value))
     ];
     if ((_a = args.attributes) == null ? void 0 : _a.length) attrs.push(...args.attributes);
+    const tracksAppGit = !this.appGitActiveSpans.has(args.eventId);
     const otlp = buildOtlpSpan({
       ids,
       name: args.name,
       startTimeUnixNano: args.startTimeUnixNano,
       endTimeUnixNano: args.endTimeUnixNano,
-      attributes: attrs,
+      attributes: withAppGitAttributes(
+        attrs,
+        this.appGitContext.forOperation(
+          args.eventId,
+          appGitPropertiesFromAttributes(attrs),
+          this.appGitOwner
+        )
+      ),
       status: args.status
     });
+    rememberReplayTraceDestination(otlp);
+    this.appGitCaptured.add(otlp);
+    if (tracksAppGit) {
+      if (this.appGitContext.releaseOperation) this.appGitContext.releaseOperation(args.eventId, this.appGitOwner);
+      else if (this.ownsAppGitContext) this.appGitContext.finishOperation(args.eventId);
+    }
     this.enqueue(otlp);
-    this.mirrorToLocalDebugger(otlp);
+    this.mirrorToLocalDebugger(otlp, true);
   }
   enqueue(span) {
+    var _a;
     if (!this.enabled) return;
+    const attributes = (_a = span.attributes) != null ? _a : [];
+    const enriched = this.appGitCaptured.has(span) ? attributes : withAppGitAttributes(attributes, this.appGitContext.snapshot(appGitPropertiesFromAttributes(attributes)));
+    if (enriched !== attributes) {
+      const original = span;
+      span = { ...span, attributes: enriched.filter((attr) => attr !== void 0) };
+      copyReplayTraceDestination(original, span);
+    }
     if (this.debugSpans) {
       const short = (s) => s ? s.slice(-8) : "none";
       console.log(
@@ -1283,6 +1956,13 @@ var TraceShipper = class {
     }
     const redacted = this.redactSpan(span);
     if (redacted === null) return;
+    const destination = replayTraceDestinationFor(redacted);
+    recordReplayExportedSpan(
+      destination,
+      base64ToHex(redacted.spanId),
+      base64ToHex(redacted.traceId)
+    );
+    if ((destination == null ? void 0 : destination.kind) === "workshop") return;
     if (this.queue.length >= this.maxQueueSize) {
       this.queue.shift();
     }
@@ -1301,47 +1981,67 @@ var TraceShipper = class {
     }
   }
   async flush() {
-    if (!this.enabled) return;
+    var _a;
+    if (!this.enabled) {
+      await Promise.all([...this.inFlight].map((p) => p.catch(() => {
+      })));
+      return;
+    }
     if (this.timer) {
       clearTimeout(this.timer);
       this.timer = void 0;
     }
     while (this.queue.length > 0) {
       const batch = this.queue.splice(0, this.maxBatchSize);
-      if (!this.writeKey) continue;
-      const opts = this.requestOpts();
-      if (!opts) {
-        rateLimitedLog(
-          `${this.prefix}.shutdown_deadline`,
-          () => console.warn(
-            `${this.prefix} shutdown flush deadline exceeded; dropping ${batch.length} spans`
-          )
-        );
-        continue;
+      const groups = /* @__PURE__ */ new Map();
+      for (const span of batch) {
+        const destination = replayTraceDestinationFor(span);
+        const spans = groups.get(destination);
+        if (spans) spans.push(span);
+        else groups.set(destination, [span]);
       }
-      const body = buildExportTraceServiceRequest(batch, this.serviceName, this.serviceVersion);
-      const url = `${this.baseUrl}traces`;
-      if (this.debug) {
-        console.log(`${this.prefix} sending traces batch`, {
-          spans: batch.length,
-          endpoint: url
-        });
-      }
-      const p = postJson(url, body, this.requestHeaders(), opts);
-      this.inFlight.add(p);
-      try {
-        try {
-          await p;
-          if (this.debug) console.log(`${this.prefix} sent ${batch.length} spans`);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
+      for (const [destination, spans] of groups) {
+        if (!destination && !this.writeKey) continue;
+        if ((destination == null ? void 0 : destination.kind) === "workshop") continue;
+        const opts = this.requestOpts();
+        if (!opts) {
           rateLimitedLog(
-            `${this.prefix}.send_spans_failed`,
-            () => console.warn(`${this.prefix} failed to send ${batch.length} spans: ${msg}`)
+            `${this.prefix}.shutdown_deadline`,
+            () => console.warn(
+              `${this.prefix} shutdown flush deadline exceeded; dropping ${spans.length} spans`
+            )
           );
+          continue;
+        }
+        const body = buildExportTraceServiceRequest(spans, this.serviceName, this.serviceVersion);
+        const url = destination ? replayTraceUrl(destination.url) : `${this.baseUrl}traces`;
+        const headers = destination ? {
+          Authorization: `Bearer ${destination.apiKey}`,
+          "X-Raindrop-Replay-Id": destination.replayId,
+          "X-Raindrop-Project-Id": (_a = destination.projectId) != null ? _a : "default"
+        } : this.requestHeaders();
+        if (this.debug) {
+          console.log(`${this.prefix} sending traces batch`, {
+            spans: spans.length,
+            endpoint: url
+          });
+        }
+        const p = postJson(url, body, headers, opts);
+        this.inFlight.add(p);
+        try {
+          try {
+            await p;
+            if (this.debug) console.log(`${this.prefix} sent ${spans.length} spans`);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            rateLimitedLog(
+              `${this.prefix}.send_spans_failed`,
+              () => console.warn(`${this.prefix} failed to send ${spans.length} spans: ${msg}`)
+            );
+          }
+        } finally {
+          this.inFlight.delete(p);
         }
-      } finally {
-        this.inFlight.delete(p);
       }
     }
   }
@@ -1384,17 +2084,165 @@ var TraceShipper = class {
       if (!settled) {
         rateLimitedLog(
           `${this.prefix}.shutdown_deadline`,
-          () => console.warn(`${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`)
+          () => console.warn(
+            `${this.prefix} shutdown flush deadline exceeded; abandoning in-flight spans`
+          )
         );
       }
     } finally {
       this.shutdownDeadlineAt = void 0;
+      if (this.ownsAppGitContext) this.appGitContext.dispose();
     }
   }
 };
 
 // ../core/dist/index.node.js
 var import_async_hooks = require("async_hooks");
+var import_child_process = require("child_process");
+var import_path = require("path");
+var resolveLocal = (sourceDirectory, detectBranch, completed) => {
+  const cwd = sourceDirectory ? (0, import_path.resolve)(sourceDirectory) : process.cwd();
+  let cancelled = false;
+  let active;
+  let deadlineTimer;
+  const deadline = Date.now() + 1e3;
+  const run = (args, done) => {
+    if (cancelled) return;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      done(void 0);
+      return;
+    }
+    try {
+      active = (0, import_child_process.execFile)(
+        "git",
+        args,
+        {
+          cwd,
+          encoding: "utf8",
+          maxBuffer: 4096,
+          windowsHide: true,
+          env: {
+            ...process.env,
+            // The selected application cwd, not the invoking shell's Git plumbing, owns identity.
+            GIT_DIR: void 0,
+            GIT_WORK_TREE: void 0,
+            GIT_COMMON_DIR: void 0,
+            GIT_NAMESPACE: void 0,
+            GIT_INDEX_FILE: void 0,
+            GIT_OBJECT_DIRECTORY: void 0,
+            GIT_ALTERNATE_OBJECT_DIRECTORIES: void 0,
+            GIT_CONFIG_PARAMETERS: void 0,
+            GIT_CONFIG_COUNT: "0",
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_OPTIONAL_LOCKS: "0"
+          }
+        },
+        (error, stdout) => {
+          clearTimeout(deadlineTimer);
+          deadlineTimer = void 0;
+          active = void 0;
+          if (!cancelled) {
+            try {
+              done(error ? void 0 : stdout.trim());
+            } catch (e) {
+            }
+          }
+        }
+      );
+      active.unref();
+      if (active.stdout && "unref" in active.stdout && typeof active.stdout.unref === "function")
+        active.stdout.unref();
+      if (active.stderr && "unref" in active.stderr && typeof active.stderr.unref === "function")
+        active.stderr.unref();
+      deadlineTimer = setTimeout(() => {
+        try {
+          active == null ? void 0 : active.kill("SIGKILL");
+        } catch (e) {
+        }
+      }, remaining);
+      deadlineTimer.unref();
+    } catch (e) {
+      try {
+        done(void 0);
+      } catch (e2) {
+      }
+    }
+  };
+  const scheduled = setTimeout(() => {
+    try {
+      run(["rev-parse", "HEAD"], (rawSha) => {
+        const commitSha = validAppCommitSha(rawSha);
+        if (!commitSha) {
+          completed({});
+          return;
+        }
+        run(["-c", "core.fsmonitor=false", "status", "--porcelain"], (status) => {
+          const finish = (branch) => {
+            run(["rev-parse", "HEAD"], (finalSha) => {
+              const coherent = validAppCommitSha(finalSha) === commitSha;
+              completed({
+                commitSha,
+                ...coherent && status !== void 0 ? { commitDirty: status !== "" } : {},
+                ...coherent && branch && branch !== "HEAD" ? { branch } : {}
+              });
+            });
+          };
+          if (detectBranch) run(["symbolic-ref", "--quiet", "--short", "HEAD"], finish);
+          else finish();
+        });
+      });
+    } catch (e) {
+      completed({});
+    }
+  }, 0);
+  scheduled.unref();
+  return () => {
+    cancelled = true;
+    clearTimeout(scheduled);
+    clearTimeout(deadlineTimer);
+    try {
+      active == null ? void 0 : active.kill("SIGKILL");
+    } catch (e) {
+    }
+  };
+};
+function createAppGitContext2(options, runtime = {}) {
+  return new AppGitContext(options, { ...runtime, resolveLocal });
+}
+function hasDestination(options) {
+  var _a;
+  if (options.enabled === false) return false;
+  return Boolean(((_a = options.writeKey) == null ? void 0 : _a.trim()) || resolveLocalDebuggerBaseUrl(options.localDebuggerUrl));
+}
+var EventShipper2 = class extends EventShipper {
+  constructor(options) {
+    var _a;
+    const ownsAppGitContext = options.appGitContext === void 0;
+    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
+    try {
+      super({ ...options, appGitContext });
+    } catch (error) {
+      if (ownsAppGitContext) appGitContext.dispose();
+      throw error;
+    }
+    if (ownsAppGitContext) this.ownAppGitContextForShutdown();
+  }
+};
+var TraceShipper2 = class extends TraceShipper {
+  constructor(options) {
+    var _a;
+    const ownsAppGitContext = options.appGitContext === void 0;
+    const appGitContext = (_a = options.appGitContext) != null ? _a : createAppGitContext2(options.appGit, { allowDiscovery: hasDestination(options) });
+    try {
+      super({ ...options, appGitContext });
+    } catch (error) {
+      if (ownsAppGitContext) appGitContext.dispose();
+      throw error;
+    }
+    this.ownsAppGitContext = ownsAppGitContext;
+  }
+};
 globalThis.RAINDROP_ASYNC_LOCAL_STORAGE = import_async_hooks.AsyncLocalStorage;
 var SUPPRESS_TRACING_KEY = /* @__PURE__ */ Symbol.for(
   "OpenTelemetry SDK Context Key SUPPRESS_TRACING"
@@ -1459,7 +2307,20 @@ function loadConfig(projectDirectory) {
     debug: process.env["RAINDROP_DEBUG"] === "true" ? true : (_g = merged.debug) != null ? _g : false,
     captureSystemPrompt: process.env["RAINDROP_CAPTURE_SYSTEM_PROMPT"] !== void 0 ? process.env["RAINDROP_CAPTURE_SYSTEM_PROMPT"] === "true" : (_h = merged.capture_system_prompt) != null ? _h : false,
     eventMetadata,
-    localWorkshopUrl: resolveLocalWorkshopUrl(merged.local_workshop_url)
+    localWorkshopUrl: resolveLocalWorkshopUrl(merged.local_workshop_url),
+    appGit: mapAppGit(merged.app_git)
+  };
+}
+function mapAppGit(value) {
+  if (value === false) return false;
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+  return {
+    commitSha: "commit_sha" in value && (typeof value.commit_sha === "string" || value.commit_sha === null) ? value.commit_sha : void 0,
+    commitDirty: "commit_dirty" in value && (typeof value.commit_dirty === "boolean" || value.commit_dirty === null) ? value.commit_dirty : void 0,
+    branch: "branch" in value && (typeof value.branch === "string" || value.branch === null) ? value.branch : void 0,
+    detectBranch: "detect_branch" in value && typeof value.detect_branch === "boolean" ? value.detect_branch : void 0,
+    sourceDirectory: "source_directory" in value && typeof value.source_directory === "string" ? value.source_directory : void 0,
+    autoDetect: "auto_detect" in value && typeof value.auto_detect === "boolean" ? value.auto_detect : void 0
   };
 }
 function resolveLocalWorkshopUrl(fileValue) {
@@ -1476,7 +2337,7 @@ function resolveLocalWorkshopUrl(fileValue) {
 // package.json
 var package_default = {
   name: "@raindrop-ai/opencode-plugin",
-  version: "0.1.3",
+  version: "0.1.4",
   description: "Raindrop observability plugin for OpenCode \u2014 automatic session/event/span tracing",
   type: "module",
   main: "dist/index.js",
@@ -1547,7 +2408,7 @@ var PLUGIN_NAME = package_default.name;
 var PLUGIN_VERSION = package_default.version;
 
 // src/shipper.ts
-var EventShipper2 = class extends EventShipper {
+var EventShipper3 = class extends EventShipper2 {
   constructor(opts) {
     var _a, _b, _c, _d;
     super({
@@ -1559,7 +2420,7 @@ var EventShipper2 = class extends EventShipper {
     });
   }
 };
-var TraceShipper2 = class extends TraceShipper {
+var TraceShipper3 = class extends TraceShipper2 {
   constructor(opts) {
     var _a, _b, _c;
     super({
@@ -1717,11 +2578,11 @@ function createSessionParentMapHelpers({
 }) {
   function applyChildSessionParentToState(childSessionId) {
     const parentInfo = mapChildSessionToParent2.get(childSessionId);
-    const state = sessions2.get(childSessionId);
-    if (!parentInfo || !state) return;
-    state.parentId = parentInfo.parentId;
-    state.parentTaskSpanIds = parentInfo.parentTaskSpanIds;
-    state.parentEventContext = parentInfo.eventContext;
+    const state2 = sessions2.get(childSessionId);
+    if (!parentInfo || !state2) return;
+    state2.parentId = parentInfo.parentId;
+    state2.parentTaskSpanIds = parentInfo.parentTaskSpanIds;
+    state2.parentEventContext = parentInfo.eventContext;
   }
   function queuePendingChildByCallKey(key, childSessionId) {
     var _a;
@@ -1817,10 +2678,10 @@ function markTaskCallFinished(sessionID, callID) {
   running.delete(callID);
   if (running.size === 0) runningTaskCallsBySession.delete(sessionID);
 }
-function endPendingToolSpanWithError(state, callID, tool, toolCallArgs, errorMessage, traceShipper) {
-  const startInfo = state.toolSpanStarts.get(callID);
+function endPendingToolSpanWithError(state2, callID, tool, toolCallArgs, errorMessage, traceShipper) {
+  const startInfo = state2.toolSpanStarts.get(callID);
   if (!startInfo) return false;
-  state.toolSpanStarts.delete(callID);
+  state2.toolSpanStarts.delete(callID);
   const error = new Error(errorMessage);
   const endAttrs = [
     attrString("ai.toolCall.args", toolCallArgs),
@@ -1920,17 +2781,17 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
           if (info == null || typeof info !== "object")
             throw new Error("session.created: props.info is required");
           const parentID = info["parentID"];
-          let state = sessions.get(sessionID);
-          if (!state) {
-            state = createSessionState(sessionID);
-            sessions.set(sessionID, state);
+          let state2 = sessions.get(sessionID);
+          if (!state2) {
+            state2 = createSessionState(sessionID);
+            sessions.set(sessionID, state2);
           }
-          state.parentId = parentID;
-          if (state.parentId) mapChildSessionToParent.set(sessionID, { parentId: state.parentId });
+          state2.parentId = parentID;
+          if (state2.parentId) mapChildSessionToParent.set(sessionID, { parentId: state2.parentId });
         } else if (event.type === "session.compacted") {
-          const state = sessions.get(String(sessionID));
-          if (!state) return;
-          state.isCompacting = true;
+          const state2 = sessions.get(String(sessionID));
+          if (!state2) return;
+          state2.isCompacting = true;
         } else if (event.type === "message.part.updated") {
           const part = props["part"];
           if (part == null || typeof part !== "object")
@@ -1942,10 +2803,10 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
             throw new Error("message.part.updated: part.sessionID is required");
           if (messageId == null || messageId === "")
             throw new Error("message.part.updated: part.messageID is required");
-          const state = sessions.get(partSessionID);
-          if (!state) return;
+          const state2 = sessions.get(partSessionID);
+          if (!state2) return;
           if (partObj["type"] === "text" && typeof partObj["text"] === "string") {
-            state.outputParts.set(messageId, capText2(partObj["text"]));
+            state2.outputParts.set(messageId, capText2(partObj["text"]));
           } else if (partObj["type"] === "tool" && messageId) {
             const tool = partObj["tool"];
             const callID = partObj["callID"];
@@ -1977,7 +2838,7 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
               const input = toolState["input"];
               const toolCallArgs = input === void 0 ? void 0 : typeof input === "string" ? capText2(input) : boundedStringify(input);
               if (endPendingToolSpanWithError(
-                state,
+                state2,
                 callID,
                 tool,
                 toolCallArgs,
@@ -1988,7 +2849,7 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
               }
             }
           } else if (partObj["type"] === "reasoning" && typeof partObj["text"] === "string") {
-            state.reasoningParts.set(messageId, capText2(partObj["text"]));
+            state2.reasoningParts.set(messageId, capText2(partObj["text"]));
           }
         } else if (event.type === "message.updated") {
           const msgInfo = props["info"];
@@ -2008,10 +2869,10 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
             throw new Error("message.updated: info.time is required");
           const timeObj = time;
           if (timeObj["completed"] == null) return;
-          const state = sessions.get(msgSessionID);
-          if (!state || !state.currentEventId || !state.currentRootSpan) return;
-          if (state.processedMessages.has(messageId)) return;
-          state.processedMessages.add(messageId);
+          const state2 = sessions.get(msgSessionID);
+          if (!state2 || !state2.currentEventId || !state2.currentRootSpan) return;
+          if (state2.processedMessages.has(messageId)) return;
+          state2.processedMessages.add(messageId);
           const tokens = info2["tokens"];
           if (tokens == null || typeof tokens !== "object")
             throw new Error("message.updated: info.tokens is required");
@@ -2028,13 +2889,13 @@ function createHooks(config, worktree, directory, eventShipper, traceShipper) {
             );
           const modelName = `${providerID}/${modelID}`;
           const finishReason = info2["finish"];
-          const outputText = state.outputParts.get(messageId);
-          const reasoningText = state.reasoningParts.get(messageId);
+          const outputText = state2.outputParts.get(messageId);
+          const reasoningText = state2.reasoningParts.get(messageId);
           const isToolCallsCompletion = finishReason === "tool-calls";
           if (outputText !== void 0 && outputText.trim().length > 0) {
-            state.turnOutputParts.push(outputText);
+            state2.turnOutputParts.push(outputText);
           }
-          state.turnOutputTokens += outputTokens;
+          state2.turnOutputTokens += outputTokens;
           if (outputText === void 0 && !isToolCallsCompletion) return;
           const msgError = info2["error"];
           const errorForSpan = msgError ? (() => {
@@ -2054,17 +2915,17 @@ type: ${name != null ? name : "UnknownError"}`;
               attrString("ai.response.text", responseText),
               ...buildLlmGenAiAttributes({ providerID, modelID, tokens: tokensObj })
             ];
-            if (state.currentSystemPrompt) {
+            if (state2.currentSystemPrompt) {
               llmAttrs.push(
                 attrString("gen_ai.prompt.0.role", "system"),
-                attrString("gen_ai.prompt.0.content", state.currentSystemPrompt)
+                attrString("gen_ai.prompt.0.content", state2.currentSystemPrompt)
               );
             }
-            const llmParent = state.parentId && state.parentTaskSpanIds ? state.parentTaskSpanIds : state.currentRootSpan.ids;
+            const llmParent = state2.parentId && state2.parentTaskSpanIds ? state2.parentTaskSpanIds : state2.currentRootSpan.ids;
             const llmSpan = traceShipper.startSpan({
               name: modelName,
               parent: llmParent,
-              eventId: state.currentEventId,
+              eventId: state2.currentEventId,
               attributes: llmAttrs
             });
             if (typeof timeObj["created"] === "number") {
@@ -2075,40 +2936,40 @@ type: ${name != null ? name : "UnknownError"}`;
             return;
           }
           if (outputText === void 0) return;
-          const turnOutputText = capText2(state.turnOutputParts.join("\n\n"));
-          const rootSpan = state.currentRootSpan;
-          const isCompaction = state.isCompacting === true;
-          if (state.parentId) {
-            const userInput = unwrapQuotes(state.currentInput);
+          const turnOutputText = capText2(state2.turnOutputParts.join("\n\n"));
+          const rootSpan = state2.currentRootSpan;
+          const isCompaction = state2.isCompacting === true;
+          if (state2.parentId) {
+            const userInput = unwrapQuotes(state2.currentInput);
             const llmAttrs = [
               attrString("ai.operationId", "generateText"),
               attrString("ai.prompt", userInput),
               attrString(
                 "ai.prompt.messages",
-                buildPromptMessages(state.currentSystemPrompt, state.currentInput)
+                buildPromptMessages(state2.currentSystemPrompt, state2.currentInput)
               ),
               attrString("ai.response.text", turnOutputText),
               ...buildLlmGenAiAttributes({ providerID, modelID, tokens: tokensObj })
             ];
-            if (state.currentSystemPrompt) {
+            if (state2.currentSystemPrompt) {
               llmAttrs.push(
                 attrString("gen_ai.prompt.0.role", "system"),
-                attrString("gen_ai.prompt.0.content", state.currentSystemPrompt)
+                attrString("gen_ai.prompt.0.content", state2.currentSystemPrompt)
               );
             }
-            if (!state.parentTaskSpanIds) {
+            if (!state2.parentTaskSpanIds) {
               traceShipper.endSpan(rootSpan, {
                 error: "Missing strict parent task for child session"
               });
-              state.currentRootSpan = void 0;
-              state.currentEventId = void 0;
+              state2.currentRootSpan = void 0;
+              state2.currentEventId = void 0;
               await traceShipper.flush();
               return;
             }
             const finalLlmSpan = traceShipper.startSpan({
               name: modelName,
-              parent: state.parentTaskSpanIds,
-              eventId: state.currentEventId,
+              parent: state2.parentTaskSpanIds,
+              eventId: state2.currentEventId,
               attributes: llmAttrs
             });
             if (typeof timeObj["created"] === "number") {
@@ -2118,19 +2979,19 @@ type: ${name != null ? name : "UnknownError"}`;
             traceShipper.endSpan(rootSpan, {
               attributes: [
                 attrString("is_subagent", "true"),
-                attrString("parent_session_id", state.parentId)
+                attrString("parent_session_id", state2.parentId)
               ],
               error: errorForSpan
             });
           } else {
             rootSpan.name = isCompaction ? "ai.compaction" : modelName;
-            const userInput = unwrapQuotes(state.currentInput);
+            const userInput = unwrapQuotes(state2.currentInput);
             const rootAttrs = [
               attrString("ai.operationId", "generateText"),
               attrString("ai.prompt", userInput),
               attrString(
                 "ai.prompt.messages",
-                buildPromptMessages(state.currentSystemPrompt, state.currentInput)
+                buildPromptMessages(state2.currentSystemPrompt, state2.currentInput)
               ),
               attrString("ai.response.text", turnOutputText),
               ...buildLlmGenAiAttributes({ providerID, modelID, tokens: tokensObj })
@@ -2139,10 +3000,10 @@ type: ${name != null ? name : "UnknownError"}`;
               rootAttrs.push(attrString("is_compaction", "true"));
             }
             rootAttrs.push(attrString("message_id", messageId));
-            if (state.currentSystemPrompt) {
+            if (state2.currentSystemPrompt) {
               rootAttrs.push(
                 attrString("gen_ai.prompt.0.role", "system"),
-                attrString("gen_ai.prompt.0.content", state.currentSystemPrompt)
+                attrString("gen_ai.prompt.0.content", state2.currentSystemPrompt)
               );
             }
             traceShipper.endSpan(rootSpan, {
@@ -2150,24 +3011,24 @@ type: ${name != null ? name : "UnknownError"}`;
               error: errorForSpan
             });
             if (isCompaction) {
-              state.isCompacting = false;
+              state2.isCompacting = false;
             }
           }
-          state.currentRootSpan = void 0;
+          state2.currentRootSpan = void 0;
           const hasAssistantResponse = turnOutputText.trim().length > 0;
           if (!hasAssistantResponse && !msgError) {
             await traceShipper.flush();
-            state.currentEventId = void 0;
+            state2.currentEventId = void 0;
             return;
           }
-          if (!state.parentId) {
-            await eventShipper.finish(state.currentEventId, {
-              userId: (_d = (_c = state.eventMetadata) == null ? void 0 : _c.userId) != null ? _d : state.sessionId,
+          if (!state2.parentId) {
+            await eventShipper.finish(state2.currentEventId, {
+              userId: (_d = (_c = state2.eventMetadata) == null ? void 0 : _c.userId) != null ? _d : state2.sessionId,
               model: modelID,
               output: msgError ? void 0 : turnOutputText,
               usage: {
                 promptTokens: inputTokens,
-                completionTokens: state.turnOutputTokens
+                completionTokens: state2.turnOutputTokens
               },
               error: msgError ? {
                 name: msgError.name,
@@ -2182,35 +3043,35 @@ type: ${name != null ? name : "UnknownError"}`;
             });
           }
           await traceShipper.flush();
-          state.currentEventId = void 0;
+          state2.currentEventId = void 0;
         } else if (event.type === "session.idle") {
           if (!sessionID) return;
-          const state = sessions.get(String(sessionID));
-          if (!state) return;
-          if (state.currentRootSpan) {
-            traceShipper.endSpan(state.currentRootSpan);
-            state.currentRootSpan = void 0;
+          const state2 = sessions.get(String(sessionID));
+          if (!state2) return;
+          if (state2.currentRootSpan) {
+            traceShipper.endSpan(state2.currentRootSpan);
+            state2.currentRootSpan = void 0;
           }
-          if (state.currentEventId) {
-            state.currentEventId = void 0;
+          if (state2.currentEventId) {
+            state2.currentEventId = void 0;
           }
-          state.isCompacting = false;
+          state2.isCompacting = false;
           await Promise.all([eventShipper.flush(), traceShipper.flush()]);
-          if (state.parentId) {
+          if (state2.parentId) {
             cleanupSessionParentMap(String(sessionID));
             sessions.delete(String(sessionID));
           } else {
           }
         } else if (event.type === "session.deleted") {
           if (!sessionID) return;
-          const state = sessions.get(String(sessionID));
-          if (!state) return;
-          if (state.currentRootSpan) {
-            traceShipper.endSpan(state.currentRootSpan);
-            state.currentRootSpan = void 0;
+          const state2 = sessions.get(String(sessionID));
+          if (!state2) return;
+          if (state2.currentRootSpan) {
+            traceShipper.endSpan(state2.currentRootSpan);
+            state2.currentRootSpan = void 0;
           }
-          if (state.currentEventId) {
-            state.currentEventId = void 0;
+          if (state2.currentEventId) {
+            state2.currentEventId = void 0;
           }
           cleanupSessionParentMap(String(sessionID));
           await Promise.all([eventShipper.flush(), traceShipper.flush()]);
@@ -2219,8 +3080,8 @@ type: ${name != null ? name : "UnknownError"}`;
           const errorSessionID = (_h = props["sessionID"]) != null ? _h : sessionID;
           if (errorSessionID === void 0 || errorSessionID === "")
             throw new Error("session.error: missing sessionID");
-          const state = sessions.get(String(errorSessionID));
-          if (!state) return;
+          const state2 = sessions.get(String(errorSessionID));
+          if (!state2) return;
           const errorObj = props["error"];
           if (errorObj == null) throw new Error("session.error: missing error object");
           const errorName = errorObj.name;
@@ -2230,12 +3091,12 @@ type: ${name != null ? name : "UnknownError"}`;
           const errorStr = `${errorMessage != null ? errorMessage : errorName}
 
 type: ${errorName != null ? errorName : "UnknownError"}`;
-          if (state.currentRootSpan) {
-            traceShipper.endSpan(state.currentRootSpan, { error: errorStr });
-            state.currentRootSpan = void 0;
+          if (state2.currentRootSpan) {
+            traceShipper.endSpan(state2.currentRootSpan, { error: errorStr });
+            state2.currentRootSpan = void 0;
           }
-          if (state.currentEventId) {
-            state.currentEventId = void 0;
+          if (state2.currentEventId) {
+            state2.currentEventId = void 0;
           }
           cleanupSessionParentMap(String(errorSessionID));
           await Promise.all([eventShipper.flush(), traceShipper.flush()]);
@@ -2255,15 +3116,15 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
       var _a, _b, _c, _d, _e, _f, _g;
       try {
         const { sessionID } = messageInput;
-        let state = sessions.get(sessionID);
-        if (!state) {
-          state = createSessionState(sessionID);
-          sessions.set(sessionID, state);
+        let state2 = sessions.get(sessionID);
+        if (!state2) {
+          state2 = createSessionState(sessionID);
+          sessions.set(sessionID, state2);
         }
         applyChildSessionParentToState(sessionID);
-        if (state.currentRootSpan) {
-          traceShipper.endSpan(state.currentRootSpan);
-          state.currentRootSpan = void 0;
+        if (state2.currentRootSpan) {
+          traceShipper.endSpan(state2.currentRootSpan);
+          state2.currentRootSpan = void 0;
         }
         if (output == null) throw new Error("chat.message: output is required");
         const parts = output.parts;
@@ -2294,39 +3155,39 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             }
           }
         }
-        state.eventMetadata = {
+        state2.eventMetadata = {
           ...baseMeta,
           ...promptMeta,
           properties: baseMeta.properties || promptMeta.properties ? { ...(_a = baseMeta.properties) != null ? _a : {}, ...(_b = promptMeta.properties) != null ? _b : {} } : void 0
         };
         const userText = capText2(textParts.join("\n"));
-        state.currentInput = userText;
-        state.turnOutputParts = [];
-        state.turnOutputTokens = 0;
-        if (state.parentId) {
-          if (!state.parentTaskSpanIds || !state.parentEventContext) {
+        state2.currentInput = userText;
+        state2.turnOutputParts = [];
+        state2.turnOutputTokens = 0;
+        if (state2.parentId) {
+          if (!state2.parentTaskSpanIds || !state2.parentEventContext) {
             return;
           }
-          state.currentEventId = state.parentEventContext.eventId;
-          state.currentRootSpan = traceShipper.startSpan({
+          state2.currentEventId = state2.parentEventContext.eventId;
+          state2.currentRootSpan = traceShipper.startSpan({
             name: "Subagent",
-            parent: state.parentTaskSpanIds,
-            eventId: state.currentEventId,
+            parent: state2.parentTaskSpanIds,
+            eventId: state2.currentEventId,
             attributes: [
               attrString("workspace", worktree),
               attrString("directory", directory),
               attrString("hostname", hostname),
               attrString("os", os),
               attrString("is_subagent", "true"),
-              attrString("parent_session_id", state.parentId)
+              attrString("parent_session_id", state2.parentId)
             ]
           });
           return;
         }
-        state.currentEventId = generateId();
-        state.currentRootSpan = traceShipper.startSpan({
-          name: state.isCompacting ? "ai.compaction" : "ai.event",
-          eventId: state.currentEventId,
+        state2.currentEventId = generateId();
+        state2.currentRootSpan = traceShipper.startSpan({
+          name: state2.isCompacting ? "ai.compaction" : "ai.event",
+          eventId: state2.currentEventId,
           attributes: [
             attrString("workspace", worktree),
             attrString("directory", directory),
@@ -2334,11 +3195,11 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             attrString("os", os)
           ]
         });
-        await eventShipper.patch(state.currentEventId, {
+        await eventShipper.patch(state2.currentEventId, {
           isPending: true,
-          userId: (_d = (_c = state.eventMetadata) == null ? void 0 : _c.userId) != null ? _d : state.sessionId,
-          convoId: state.sessionId,
-          eventName: (_f = (_e = state.eventMetadata) == null ? void 0 : _e.eventName) != null ? _f : config.eventName,
+          userId: (_d = (_c = state2.eventMetadata) == null ? void 0 : _c.userId) != null ? _d : state2.sessionId,
+          convoId: state2.sessionId,
+          eventName: (_f = (_e = state2.eventMetadata) == null ? void 0 : _e.eventName) != null ? _f : config.eventName,
           input: userText,
           ...newAttachments.length > 0 ? { attachments: newAttachments } : {},
           properties: {
@@ -2347,7 +3208,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
             hostname,
             os,
             plugin_version: PLUGIN_VERSION,
-            ...(_g = state.eventMetadata) == null ? void 0 : _g.properties
+            ...(_g = state2.eventMetadata) == null ? void 0 : _g.properties
           }
         });
       } catch (err) {
@@ -2361,16 +3222,16 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
       var _a, _b, _c;
       try {
         const { tool, sessionID, callID } = toolInput;
-        const state = sessions.get(sessionID);
-        if (!state || !state.currentEventId) return;
-        const spanParent = state.parentId && state.parentTaskSpanIds ? state.parentTaskSpanIds : (_a = state.currentRootSpan) == null ? void 0 : _a.ids;
+        const state2 = sessions.get(sessionID);
+        if (!state2 || !state2.currentEventId) return;
+        const spanParent = state2.parentId && state2.parentTaskSpanIds ? state2.parentTaskSpanIds : (_a = state2.currentRootSpan) == null ? void 0 : _a.ids;
         if (!spanParent) return;
         const startTimeUnixNano = nowUnixNanoString();
         if (tool === "task") {
           const liveTaskSpan = traceShipper.startSpan({
             name: "ai.toolCall",
             parent: spanParent,
-            eventId: state.currentEventId,
+            eventId: state2.currentEventId,
             attributes: [
               attrString("ai.operationId", "ai.toolCall"),
               attrString("ai.toolCall.name", tool),
@@ -2381,9 +3242,9 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
           const ctx = {
             ids: liveTaskSpan.ids,
             eventContext: {
-              eventId: state.currentEventId,
-              userId: (_c = (_b = state.eventMetadata) == null ? void 0 : _b.userId) != null ? _c : state.sessionId,
-              convoId: state.sessionId
+              eventId: state2.currentEventId,
+              userId: (_c = (_b = state2.eventMetadata) == null ? void 0 : _b.userId) != null ? _c : state2.sessionId,
+              convoId: state2.sessionId
             }
           };
           taskContexts.set(callKey(sessionID, callID), ctx);
@@ -2394,18 +3255,18 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
           }
           running.add(callID);
           resolvePendingChildrenForCall(sessionID, callID, "tool.execute.before");
-          state.toolSpanStarts.set(callID, {
+          state2.toolSpanStarts.set(callID, {
             startTimeUnixNano,
             parent: spanParent,
-            eventId: state.currentEventId,
+            eventId: state2.currentEventId,
             name: tool,
             liveSpan: liveTaskSpan
           });
         } else {
-          state.toolSpanStarts.set(callID, {
+          state2.toolSpanStarts.set(callID, {
             startTimeUnixNano,
             parent: spanParent,
-            eventId: state.currentEventId,
+            eventId: state2.currentEventId,
             name: tool
           });
         }
@@ -2422,13 +3283,13 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
     "tool.execute.after": async (toolInput, result) => {
       try {
         const { tool, sessionID, callID, args } = toolInput;
-        const state = sessions.get(sessionID);
-        if (!state || !state.currentEventId) return;
+        const state2 = sessions.get(sessionID);
+        if (!state2 || !state2.currentEventId) return;
         if (args === void 0 || args === null)
           throw new Error("tool.execute.after: args is required");
         const toolCallArgs = typeof args === "string" ? capText2(args) : boundedStringify(args);
-        const startInfo = state.toolSpanStarts.get(callID);
-        state.toolSpanStarts.delete(callID);
+        const startInfo = state2.toolSpanStarts.get(callID);
+        state2.toolSpanStarts.delete(callID);
         const resultMetadata = result.metadata;
         const childSessionId = resultMetadata == null ? void 0 : resultMetadata["sessionId"];
         if (tool === "task" && childSessionId) {
@@ -2481,9 +3342,9 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
       try {
         const sessionID = input.sessionID;
         if (!sessionID) return;
-        const state = sessions.get(sessionID);
-        if (state) {
-          state.isCompacting = true;
+        const state2 = sessions.get(sessionID);
+        if (state2) {
+          state2.isCompacting = true;
         }
       } catch (err) {
         rateLimitedErrorLog(
@@ -2500,15 +3361,15 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
         if (!config.captureSystemPrompt) return;
         const sessionID = input.sessionID;
         if (!sessionID) return;
-        let state = sessions.get(sessionID);
-        if (!state) {
-          state = createSessionState(sessionID);
-          sessions.set(sessionID, state);
+        let state2 = sessions.get(sessionID);
+        if (!state2) {
+          state2 = createSessionState(sessionID);
+          sessions.set(sessionID, state2);
         }
         const MAX_SYSTEM_PROMPT_LENGTH = 32768;
         const TRUNCATION_MARKER3 = "\n...[truncated]";
         const joined = output.system.join("\n\n");
-        state.currentSystemPrompt = joined.length > MAX_SYSTEM_PROMPT_LENGTH ? joined.slice(0, MAX_SYSTEM_PROMPT_LENGTH - TRUNCATION_MARKER3.length) + TRUNCATION_MARKER3 : joined;
+        state2.currentSystemPrompt = joined.length > MAX_SYSTEM_PROMPT_LENGTH ? joined.slice(0, MAX_SYSTEM_PROMPT_LENGTH - TRUNCATION_MARKER3.length) + TRUNCATION_MARKER3 : joined;
       } catch (err) {
         rateLimitedErrorLog(
           "experimental.chat.system.transform",
@@ -2520,7 +3381,7 @@ type: ${errorName != null ? errorName : "UnknownError"}`;
 }
 
 // src/index.ts
-function createRaindropHandle(eventShipper, traceShipper) {
+function createRaindropHandle(eventShipper, traceShipper, appGitContext) {
   return {
     users: {
       async identify(users) {
@@ -2531,12 +3392,19 @@ function createRaindropHandle(eventShipper, traceShipper) {
       await Promise.all([eventShipper.flush(), traceShipper.flush()]);
     },
     async shutdown() {
-      await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+      try {
+        await Promise.all([eventShipper.shutdown(), traceShipper.shutdown()]);
+      } finally {
+        try {
+          appGitContext.dispose();
+        } catch (e) {
+        }
+      }
     }
   };
 }
-async function plugin(input) {
-  var _a;
+async function plugin(input, opts = {}) {
+  var _a, _b, _c;
   const config = loadConfig(input.directory);
   function appLog(level, message) {
     console.log(`[raindrop-ai/opencode-plugin] [${level}] ${message}`);
@@ -2558,21 +3426,28 @@ async function plugin(input) {
     ].filter(Boolean);
     appLog("info", `Raindrop tracing enabled \u2014 destinations: ${destinations.join(", ")}`);
   }
-  const eventShipper = new EventShipper2({
+  const configuredAppGit = (_a = opts.appGit) != null ? _a : config.appGit;
+  const appGitContext = createAppGitContext2(
+    ((_b = config.writeKey) == null ? void 0 : _b.trim()) || hasLocalDestination ? configuredAppGit : false,
+    { allowLocalGit: false }
+  );
+  const eventShipper = new EventShipper3({
     writeKey: config.writeKey,
     endpoint: config.endpoint,
     debug: config.debug,
     projectId: config.projectId,
-    localDebuggerUrl: config.localWorkshopUrl
+    localDebuggerUrl: config.localWorkshopUrl,
+    appGitContext
   });
-  const traceShipper = new TraceShipper2({
+  const traceShipper = new TraceShipper3({
     writeKey: config.writeKey,
     endpoint: config.endpoint,
     debug: config.debug,
     projectId: config.projectId,
-    localDebuggerUrl: config.localWorkshopUrl
+    localDebuggerUrl: config.localWorkshopUrl,
+    appGitContext
   });
-  const worktree = (_a = input.worktree) != null ? _a : input.directory;
+  const worktree = (_c = input.worktree) != null ? _c : input.directory;
   const hooks = createHooks(
     config,
     worktree,
@@ -2580,5 +3455,5 @@ async function plugin(input) {
     eventShipper,
     traceShipper
   );
-  return { ...hooks, raindrop: createRaindropHandle(eventShipper, traceShipper) };
+  return { ...hooks, raindrop: createRaindropHandle(eventShipper, traceShipper, appGitContext) };
 }