@merittdev/horus 0.21.6 → 0.21.8

package/dist/index.cjs

@@ -3057,7 +3057,7 @@ var init_version = __esm({
   "../../packages/core/src/version.ts"() {
     "use strict";
     init_cjs_shims();
-    HORUS_VERSION = true ? "0.21.6" : "dev";
+    HORUS_VERSION = true ? "0.21.8" : "dev";
     PINNED_SOURCE_VERSION = HORUS_VERSION;
     SOURCE_PIN_ENFORCED = HORUS_VERSION !== "dev";
     EXPECTED_INDEX_CAPABILITY = 2;
@@ -29518,7 +29518,7 @@ var require_lib = __commonJS({
       }
       return new ErrorType(`${options.context ? options.context : "Value"} ${message}.`);
     }
-    function toNumber2(value, options) {
+    function toNumber3(value, options) {
       if (typeof value === "bigint") {
         throw makeException(TypeError, "is a BigInt which cannot be converted to a number", options);
       }
@@ -29561,7 +29561,7 @@ var require_lib = __commonJS({
       const twoToTheBitLength = 2 ** bitLength;
       const twoToOneLessThanTheBitLength = 2 ** (bitLength - 1);
       return (value, options = {}) => {
-        let x4 = toNumber2(value, options);
+        let x4 = toNumber3(value, options);
         x4 = censorNegativeZero(x4);
         if (options.enforceRange) {
           if (!Number.isFinite(x4)) {
@@ -29601,7 +29601,7 @@ var require_lib = __commonJS({
       const lowerBound = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
       const asBigIntN = unsigned ? BigInt.asUintN : BigInt.asIntN;
       return (value, options = {}) => {
-        let x4 = toNumber2(value, options);
+        let x4 = toNumber3(value, options);
         x4 = censorNegativeZero(x4);
         if (options.enforceRange) {
           if (!Number.isFinite(x4)) {
@@ -29648,18 +29648,18 @@ var require_lib = __commonJS({
     exports2["long long"] = createLongLongConversion(64, { unsigned: false });
     exports2["unsigned long long"] = createLongLongConversion(64, { unsigned: true });
     exports2.double = (value, options = {}) => {
-      const x4 = toNumber2(value, options);
+      const x4 = toNumber3(value, options);
       if (!Number.isFinite(x4)) {
         throw makeException(TypeError, "is not a finite floating-point value", options);
       }
       return x4;
     };
     exports2["unrestricted double"] = (value, options = {}) => {
-      const x4 = toNumber2(value, options);
+      const x4 = toNumber3(value, options);
       return x4;
     };
     exports2.float = (value, options = {}) => {
-      const x4 = toNumber2(value, options);
+      const x4 = toNumber3(value, options);
       if (!Number.isFinite(x4)) {
         throw makeException(TypeError, "is not a finite floating-point value", options);
       }
@@ -29673,7 +29673,7 @@ var require_lib = __commonJS({
       return y5;
     };
     exports2["unrestricted float"] = (value, options = {}) => {
-      const x4 = toNumber2(value, options);
+      const x4 = toNumber3(value, options);
       if (isNaN(x4)) {
         return x4;
       }
@@ -75376,6 +75376,501 @@ function shortTs2(iso) {
   return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
 }
 
+// ../../packages/connectors/src/lens/client.ts
+init_cjs_shims();
+init_src();
+var LensCloudClient = class {
+  apiBaseUrl;
+  token;
+  workspaceId;
+  http;
+  constructor(opts) {
+    this.apiBaseUrl = opts.apiBaseUrl.replace(/\/$/, "");
+    this.token = opts.token;
+    this.workspaceId = opts.workspaceId;
+    this.http = opts.http ?? {};
+  }
+  async request(path) {
+    const url = `${this.apiBaseUrl}${path}`;
+    const res = await fetchWithRetry(
+      url,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.token}`,
+          "Content-Type": "application/json"
+        }
+      },
+      this.http
+    );
+    if (!res.ok) {
+      const text2 = await res.text().catch(() => "");
+      throw new Error(`Lens GET ${path} -> ${res.status}: ${redactUpstreamBody(text2)}`);
+    }
+    return res.json();
+  }
+  get base() {
+    return `/v1/workspaces/${encodeURIComponent(this.workspaceId)}/lens`;
+  }
+  /**
+   * List the Lens sites the workspace owns. Reports are site-scoped, so this is the
+   * discovery step before `listReports`. Transport/auth failures PROPAGATE (like Sentry's
+   * `listIssues`) so an outage reads as a gap, not as "no sites".
+   */
+  async listSites() {
+    const raw = await this.request(`${this.base}/sites`);
+    const sites = Array.isArray(raw) ? raw : raw?.["sites"];
+    if (!Array.isArray(sites)) return [];
+    return sites.map((s5) => ({
+      id: typeof s5["id"] === "string" ? s5["id"] : "",
+      name: typeof s5["name"] === "string" && s5["name"] !== "" ? s5["name"] : typeof s5["id"] === "string" ? s5["id"] : ""
+    })).filter((s5) => s5.id !== "");
+  }
+  /** Build the site-reports query path with the incident-window + filter params. */
+  reportsPath(siteId, opts = {}) {
+    const params = new URLSearchParams();
+    if (opts.from !== void 0) params.set("from", opts.from);
+    if (opts.to !== void 0) params.set("to", opts.to);
+    if (opts.q !== void 0 && opts.q !== "") params.set("q", opts.q);
+    if (opts.status !== void 0) params.set("status", opts.status);
+    params.set("limit", String(Math.max(1, Math.min(opts.limit ?? 25, 200))));
+    return `${this.base}/sites/${encodeURIComponent(siteId)}/reports?${params.toString()}`;
+  }
+  /**
+   * List reports for a site within an optional incident window. `from`/`to` are inclusive
+   * `createdAt` ISO-8601 bounds; `q` is a single case-insensitive substring over the
+   * comment + env URL (NOT hint fan-out — the provider relevance-ranks client-side).
+   * Returns the first page; transport/auth failures PROPAGATE.
+   */
+  async listReports(siteId, opts = {}) {
+    const raw = await this.request(this.reportsPath(siteId, opts));
+    const reports = raw?.["reports"];
+    if (!Array.isArray(reports)) return [];
+    return reports.map((r) => parseSummary(r, siteId));
+  }
+  /**
+   * Fetch one full report (with metadata) by id, scoped to its site. Transport/auth
+   * failures PROPAGATE; the provider wraps each call so one bad report never aborts a
+   * collection.
+   */
+  async getReport(siteId, reportId) {
+    const raw = await this.request(
+      `${this.base}/sites/${encodeURIComponent(siteId)}/reports/${encodeURIComponent(reportId)}`
+    );
+    return parseReport(raw);
+  }
+  /** Cheap reachability probe: `listSites` succeeds → ok. Never throws. */
+  async health() {
+    try {
+      const sites = await this.listSites();
+      return { ok: true, detail: `lens reachable (workspace ${this.workspaceId}, ${sites.length} site(s))` };
+    } catch (err2) {
+      return { ok: false, detail: redactErrorMessage(err2) };
+    }
+  }
+};
+function toNumber2(v4) {
+  if (typeof v4 === "number") return Number.isFinite(v4) ? v4 : 0;
+  if (typeof v4 === "string") {
+    const n4 = Number(v4);
+    return Number.isFinite(n4) ? n4 : 0;
+  }
+  return 0;
+}
+function parseSummary(raw, siteId) {
+  const summary = {
+    id: String(raw["id"] ?? ""),
+    lensSiteId: typeof raw["lensSiteId"] === "string" ? raw["lensSiteId"] : siteId,
+    status: typeof raw["status"] === "string" ? raw["status"] : "",
+    createdAt: typeof raw["createdAt"] === "string" ? raw["createdAt"] : "",
+    submittedAt: typeof raw["submittedAt"] === "string" ? raw["submittedAt"] : null,
+    externalIssue: raw["externalIssue"] ?? null,
+    lensIssueId: typeof raw["lensIssueId"] === "string" ? raw["lensIssueId"] : null,
+    issueOccurrenceCount: typeof raw["issueOccurrenceCount"] === "number" ? raw["issueOccurrenceCount"] : null,
+    errorCount: toNumber2(raw["errorCount"]),
+    hasReplay: raw["hasReplay"] === true
+  };
+  if (typeof raw["comment"] === "string") summary.comment = raw["comment"];
+  if (typeof raw["url"] === "string") summary.url = raw["url"];
+  return summary;
+}
+function parseReport(raw) {
+  const o5 = raw ?? {};
+  return {
+    id: String(o5["id"] ?? ""),
+    status: typeof o5["status"] === "string" ? o5["status"] : "",
+    createdAt: typeof o5["createdAt"] === "string" ? o5["createdAt"] : "",
+    submittedAt: typeof o5["submittedAt"] === "string" ? o5["submittedAt"] : null,
+    metadata: parseMetadata(o5["metadata"])
+  };
+}
+function parseMetadata(raw) {
+  if (raw === null || raw === void 0 || typeof raw !== "object") return null;
+  const m5 = raw;
+  const meta = {
+    errors: parseErrors(m5["errors"]),
+    networkTail: parseNetworkTail(m5["networkTail"])
+  };
+  if (typeof m5["comment"] === "string") meta.comment = m5["comment"];
+  if (typeof m5["trigger"] === "string") meta.trigger = m5["trigger"];
+  const target = m5["target"];
+  if (target && typeof target === "object") {
+    const t2 = target;
+    const parsed = {};
+    if (typeof t2["domPath"] === "string") parsed.domPath = t2["domPath"];
+    if (typeof t2["tagName"] === "string") parsed.tagName = t2["tagName"];
+    if (typeof t2["text"] === "string") parsed.text = t2["text"];
+    if (Array.isArray(t2["reactComponents"])) {
+      parsed.reactComponents = t2["reactComponents"].filter(
+        (c4) => typeof c4 === "string"
+      );
+    }
+    meta.target = parsed;
+  }
+  const env = m5["env"];
+  if (env && typeof env === "object") {
+    const e = env;
+    const parsed = { url: typeof e["url"] === "string" ? e["url"] : "" };
+    if (typeof e["route"] === "string") parsed.route = e["route"];
+    if (typeof e["userAgent"] === "string") parsed.userAgent = e["userAgent"];
+    if (typeof e["browser"] === "string") parsed.browser = e["browser"];
+    if (typeof e["os"] === "string") parsed.os = e["os"];
+    meta.env = parsed;
+  }
+  const app = m5["app"];
+  if (app && typeof app === "object") {
+    const a2 = app;
+    const parsed = {};
+    if (typeof a2["release"] === "string") parsed.release = a2["release"];
+    if (typeof a2["gitSha"] === "string") parsed.gitSha = a2["gitSha"];
+    if (typeof a2["environment"] === "string") parsed.environment = a2["environment"];
+    if (a2["featureFlags"] && typeof a2["featureFlags"] === "object") {
+      parsed.featureFlags = a2["featureFlags"];
+    }
+    meta.app = parsed;
+  }
+  return meta;
+}
+function parseErrors(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((e) => typeof e["message"] === "string").map((e) => {
+    const err2 = {
+      message: e["message"],
+      source: typeof e["source"] === "string" ? e["source"] : "",
+      timestamp: toNumber2(e["timestamp"])
+    };
+    if (typeof e["stack"] === "string") err2.stack = e["stack"];
+    return err2;
+  });
+}
+function parseNetworkTail(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((n4) => {
+    const entry = {
+      method: typeof n4["method"] === "string" ? n4["method"] : "",
+      url: typeof n4["url"] === "string" ? n4["url"] : "",
+      status: typeof n4["status"] === "number" ? n4["status"] : null,
+      ok: typeof n4["ok"] === "boolean" ? n4["ok"] : null,
+      durationMs: typeof n4["durationMs"] === "number" ? n4["durationMs"] : null,
+      requestType: typeof n4["requestType"] === "string" ? n4["requestType"] : "",
+      startedAt: toNumber2(n4["startedAt"])
+    };
+    if (typeof n4["error"] === "string") entry.error = n4["error"];
+    return entry;
+  });
+}
+
+// ../../packages/connectors/src/lens/provider.ts
+init_cjs_shims();
+init_src();
+var LensProvider = class {
+  constructor(client, opts = {}) {
+    this.client = client;
+    this.opts = opts;
+  }
+  client;
+  opts;
+  id = "lens";
+  kind = "logs";
+  sitesCache = null;
+  get limit() {
+    return this.opts.limit ?? 25;
+  }
+  get statusFilter() {
+    return this.opts.statusFilter ?? "submitted";
+  }
+  /**
+   * Collect recent reports across every site within the window and resolve each one's
+   * top frame + failing requests. Reports are low-volume, so we fetch the full metadata
+   * for up to `limit` (relevance-ranked) reports. A failing site LIST or reports LIST
+   * PROPAGATES so the engine records a gap; per-report metadata fetches are best-effort
+   * (a report still becomes a signal from its summary alone). Use queryEvidence() for the
+   * degrade-to-[] contract.
+   */
+  async collect(opts = {}) {
+    const siteIds = await this.sites();
+    const hintTerms = opts.hintTerms ?? [];
+    const summaries = [];
+    for (const siteId of siteIds) {
+      const page = await this.client.listReports(siteId, {
+        ...opts.from !== void 0 ? { from: opts.from } : {},
+        ...opts.to !== void 0 ? { to: opts.to } : {},
+        status: this.statusFilter,
+        limit: this.limit
+      });
+      summaries.push(...page);
+    }
+    const windowed = summaries.filter((s5) => inWindow(s5.createdAt, opts.from, opts.to));
+    const ranked = rankSummaries(windowed, hintTerms).slice(0, this.limit);
+    const reports = await Promise.all(
+      ranked.map(
+        (s5) => this.client.getReport(s5.lensSiteId, s5.id).catch(() => null)
+      )
+    );
+    return ranked.map((summary, i3) => buildSignal(summary, reports[i3] ?? null));
+  }
+  /**
+   * Synthesize Evidence from Lens reports. One `kind: 'log'` Evidence per report, with the
+   * comment as the human signature, the captured error + failing requests + app context in
+   * the payload, and the top frame surfaced as `filePath`/`symbolName`/`lineStart` (payload)
+   * and `file`/`line` (links) so the engine can seed directly on it.
+   */
+  toEvidence(signals, hintTerms, collectedAt) {
+    const query = `lens reports (status:${this.statusFilter}, up to ${this.limit})`;
+    return signals.map((sig, i3) => signalToEvidence(sig, hintTerms, query, collectedAt, i3));
+  }
+  /**
+   * One-shot evidence query: collect reports, convert to redacted Evidence. Preferred entry
+   * point for the investigation engine. Degrades to [] on any failure so a flaky Cloud never
+   * aborts an investigation.
+   */
+  async queryEvidence(opts = {}) {
+    try {
+      const hintTerms = opts.hintTerms ?? [];
+      const signals = await this.collect({
+        ...opts.from !== void 0 ? { from: opts.from } : {},
+        ...opts.to !== void 0 ? { to: opts.to } : {},
+        hintTerms
+      });
+      return this.toEvidence(signals, hintTerms, opts.collectedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+    } catch {
+      return [];
+    }
+  }
+  async health() {
+    return this.client.health();
+  }
+  /** In-instance site-id cache — reports are site-scoped and the site list is stable. */
+  async sites() {
+    if (this.sitesCache !== null) return this.sitesCache;
+    const sites = await this.client.listSites();
+    this.sitesCache = sites.map((s5) => s5.id);
+    return this.sitesCache;
+  }
+};
+function buildSignal(summary, report) {
+  const meta = report?.metadata ?? null;
+  const errors2 = meta?.errors ?? [];
+  const { frame, message } = topFrameFromErrors(errors2);
+  const signal = {
+    id: summary.id,
+    lensSiteId: summary.lensSiteId,
+    status: summary.status,
+    createdAt: summary.createdAt,
+    submittedAt: summary.submittedAt,
+    issueOccurrenceCount: summary.issueOccurrenceCount,
+    errorCount: summary.errorCount || errors2.length,
+    hasReplay: summary.hasReplay,
+    topFrame: frame,
+    failingRequests: failingRequestsFrom(meta?.networkTail ?? [])
+  };
+  const comment = meta?.comment ?? summary.comment;
+  if (comment !== void 0) signal.comment = comment;
+  const route2 = meta?.env?.route;
+  if (route2 !== void 0) signal.route = route2;
+  const url = meta?.env?.url && meta.env.url !== "" ? meta.env.url : summary.url;
+  if (url !== void 0) signal.url = url;
+  if (meta?.app?.release !== void 0) signal.release = meta.app.release;
+  if (meta?.app?.gitSha !== void 0) signal.gitSha = meta.app.gitSha;
+  if (meta?.app?.environment !== void 0) signal.environment = meta.app.environment;
+  if (meta?.app?.featureFlags !== void 0) signal.featureFlags = meta.app.featureFlags;
+  if (meta?.trigger !== void 0) signal.trigger = meta.trigger;
+  if (message !== void 0) signal.topErrorMessage = message;
+  const react = meta?.target?.reactComponents;
+  if (react !== void 0 && react.length > 0) signal.reactComponents = react;
+  return signal;
+}
+function failingRequestsFrom(tail) {
+  return tail.filter((n4) => n4.ok === false || typeof n4.status === "number" && n4.status >= 500).slice(0, 5).map((n4) => ({ method: n4.method, url: n4.url, status: n4.status }));
+}
+function topFrameFromErrors(errors2) {
+  let firstMessage;
+  for (const err2 of errors2) {
+    if (firstMessage === void 0 && err2.message) firstMessage = err2.message;
+    if (!err2.stack) continue;
+    const frame = parseStackTopFrame(err2.stack);
+    if (frame) return { frame, message: err2.message || firstMessage };
+  }
+  return firstMessage !== void 0 ? { frame: null, message: firstMessage } : { frame: null };
+}
+function isSkippableLocation(location2) {
+  if (location2 === "") return true;
+  if (location2.includes("node_modules")) return true;
+  if (/^[a-z-]+-extension:\/\//i.test(location2)) return true;
+  if (location2.includes("[native code]") || location2.includes("<anonymous>")) return true;
+  return false;
+}
+function parseStackTopFrame(stack) {
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    const line2 = raw.trim();
+    if (line2 === "") continue;
+    let fnName;
+    let location2;
+    if (line2.startsWith("at ")) {
+      const body2 = line2.slice(3).trim();
+      const parenMatch = /^(.*?)\s*\((.+)\)\s*$/.exec(body2);
+      if (parenMatch) {
+        fnName = parenMatch[1]?.trim() || void 0;
+        location2 = parenMatch[2].trim();
+      } else {
+        location2 = body2;
+      }
+    } else if (line2.includes("@")) {
+      const at4 = line2.lastIndexOf("@");
+      fnName = line2.slice(0, at4).trim() || void 0;
+      location2 = line2.slice(at4 + 1).trim();
+    } else {
+      continue;
+    }
+    if (location2 === void 0 || isSkippableLocation(location2)) continue;
+    const parsed = parseLocation(location2);
+    if (!parsed) continue;
+    if (isSkippableLocation(parsed.filename)) continue;
+    const frame = { filename: parsed.filename };
+    if (fnName !== void 0 && fnName !== "") frame.function = fnName;
+    if (parsed.lineno !== void 0) frame.lineno = parsed.lineno;
+    return frame;
+  }
+  return null;
+}
+function parseLocation(location2) {
+  const m5 = /^(.*?):(\d+)(?::(\d+))?$/.exec(location2);
+  const rawUrl = m5 ? m5[1] : location2;
+  const lineno = m5 ? Number(m5[2]) : void 0;
+  let filename = rawUrl;
+  try {
+    if (/^[a-z]+:\/\//i.test(rawUrl)) filename = new URL(rawUrl).pathname;
+  } catch {
+    filename = rawUrl;
+  }
+  if (filename === "") return null;
+  return lineno !== void 0 && Number.isFinite(lineno) ? { filename, lineno } : { filename };
+}
+function signalToEvidence(sig, hintTerms, query, collectedAt, index2) {
+  const frame = sig.topFrame;
+  const title = buildTitle2(sig);
+  const relevance = computeRelevance2(sig, hintTerms);
+  const payload = {
+    source: "lens",
+    reportId: sig.id,
+    ...sig.comment !== void 0 ? { comment: redactSecrets(sig.comment) } : {},
+    ...sig.route !== void 0 ? { route: sig.route } : {},
+    ...sig.url !== void 0 ? { url: sig.url } : {},
+    ...sig.release !== void 0 ? { release: sig.release } : {},
+    ...sig.gitSha !== void 0 ? { gitSha: sig.gitSha } : {},
+    ...sig.trigger !== void 0 ? { trigger: sig.trigger } : {},
+    errorCount: sig.errorCount,
+    ...sig.topErrorMessage !== void 0 ? { topError: redactSecrets(sig.topErrorMessage) } : {},
+    ...sig.failingRequests.length > 0 ? { failingRequests: sig.failingRequests } : {},
+    ...sig.reactComponents !== void 0 ? { reactComponents: sig.reactComponents } : {},
+    ...sig.featureFlags !== void 0 ? { featureFlags: sig.featureFlags } : {}
+  };
+  if (frame?.filename !== void 0) payload["filePath"] = frame.filename;
+  if (frame?.function !== void 0) payload["symbolName"] = frame.function;
+  if (frame?.lineno !== void 0) payload["lineStart"] = frame.lineno;
+  const links = {};
+  if (frame?.filename !== void 0) links.file = frame.filename;
+  if (frame?.lineno !== void 0) links.line = frame.lineno;
+  const ev = {
+    id: `ev_lens_${index2}`,
+    source: "logs",
+    kind: "log",
+    title,
+    relevance,
+    payload,
+    links,
+    provenance: { query, collectedAt }
+  };
+  const ts = sig.submittedAt ?? sig.createdAt;
+  if (ts) ev.timestamp = ts;
+  return ev;
+}
+function buildTitle2(sig) {
+  const rawComment = sig.comment ? redactSecrets(sig.comment) : "";
+  const comment = rawComment !== "" ? rawComment.slice(0, 80) : "(no comment)";
+  const errs = `${sig.errorCount} error(s)`;
+  const where = sig.route ?? sig.url ?? "";
+  const whereStr = where !== "" ? ` \xB7 ${where}` : "";
+  const when = sig.createdAt ? ` \xB7 ${shortTs3(sig.createdAt)}` : "";
+  return `Lens report: "${comment}" \xB7 ${errs}${whereStr}${when}`.slice(0, 220);
+}
+function computeRelevance2(sig, hintTerms, now = Date.now()) {
+  let score = 0.6;
+  const hay = [
+    sig.comment ?? "",
+    sig.route ?? "",
+    sig.url ?? "",
+    sig.topErrorMessage ?? "",
+    sig.topFrame?.filename ?? "",
+    sig.topFrame?.function ?? ""
+  ].join(" ").toLowerCase();
+  const domainTerms = hintTerms.filter((t2) => t2.length > 2);
+  if (domainTerms.some((t2) => hay.includes(t2.toLowerCase()))) score += 0.2;
+  const ts = sig.submittedAt ?? sig.createdAt;
+  if (ts) {
+    const ageMs = now - Date.parse(ts);
+    if (Number.isFinite(ageMs)) {
+      if (ageMs <= 864e5) score += 0.1;
+      else if (ageMs <= 7 * 864e5) score += 0.05;
+    }
+  }
+  if ((sig.issueOccurrenceCount ?? 0) >= 3) score += 0.05;
+  return Math.min(0.95, Math.max(0.5, score));
+}
+function rankSummaries(summaries, hintTerms, now = Date.now()) {
+  const domainTerms = hintTerms.filter((t2) => t2.length > 2);
+  const score = (s5) => {
+    let v4 = 0;
+    const hay = `${s5.comment ?? ""} ${s5.url ?? ""}`.toLowerCase();
+    if (domainTerms.some((t2) => hay.includes(t2.toLowerCase()))) v4 += 2;
+    if (s5.createdAt) {
+      const ageMs = now - Date.parse(s5.createdAt);
+      if (Number.isFinite(ageMs) && ageMs <= 864e5) v4 += 1;
+    }
+    if ((s5.issueOccurrenceCount ?? 0) >= 3) v4 += 0.5;
+    return v4;
+  };
+  return [...summaries].sort((a2, b5) => {
+    const d3 = score(b5) - score(a2);
+    if (d3 !== 0) return d3;
+    return (Date.parse(b5.createdAt) || 0) - (Date.parse(a2.createdAt) || 0);
+  });
+}
+function inWindow(createdAt, from, to) {
+  const t2 = Date.parse(createdAt);
+  if (!Number.isFinite(t2)) return true;
+  const lo = from !== void 0 ? Date.parse(from) : NaN;
+  const hi = to !== void 0 ? Date.parse(to) : NaN;
+  if (Number.isFinite(lo) && t2 < lo) return false;
+  if (Number.isFinite(hi) && t2 > hi) return false;
+  return true;
+}
+function shortTs3(iso) {
+  if (!iso || iso.length < 16) return iso || "\u2014";
+  return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
+}
+
 // ../../packages/connectors/src/axiom/client.ts
 init_cjs_shims();
 init_src();
@@ -75629,8 +76124,8 @@ var AxiomProvider = class {
     return this.client.health();
   }
   recordToEvidence(rec, hintTerms, query, collectedAt, index2) {
-    const title = buildTitle2(rec, this.opts.dataset);
-    const relevance = computeRelevance2(rec, hintTerms);
+    const title = buildTitle3(rec, this.opts.dataset);
+    const relevance = computeRelevance3(rec, hintTerms);
     const payload = {
       source: "axiom",
       dataset: this.opts.dataset,
@@ -75660,7 +76155,7 @@ function pickField2(fields, candidates) {
   }
   return void 0;
 }
-function buildTitle2(rec, dataset) {
+function buildTitle3(rec, dataset) {
   const msg = pickField2(rec.fields, MESSAGE_FIELDS);
   const level = pickField2(rec.fields, LEVEL_FIELDS);
   const lvl = level ? `[${level}] ` : "";
@@ -75668,13 +76163,13 @@ function buildTitle2(rec, dataset) {
   const rawCount = rec.fields["count"];
   const count = typeof rawCount === "number" && Number.isFinite(rawCount) && rawCount > 1 ? rawCount : void 0;
   if (count !== void 0) {
-    const latest = rec.timestamp ? ` (latest ${shortTs3(rec.timestamp)})` : "";
+    const latest = rec.timestamp ? ` (latest ${shortTs4(rec.timestamp)})` : "";
     return `Axiom ${dataset}: ${lvl}${body2} \xD7${count.toLocaleString("en-US")}${latest}`.slice(0, 220);
   }
-  const ts = rec.timestamp ? ` \xB7 ${shortTs3(rec.timestamp)}` : "";
+  const ts = rec.timestamp ? ` \xB7 ${shortTs4(rec.timestamp)}` : "";
   return `Axiom ${dataset}: ${lvl}${body2}${ts}`.slice(0, 220);
 }
-function computeRelevance2(rec, hintTerms, now = Date.now()) {
+function computeRelevance3(rec, hintTerms, now = Date.now()) {
   let score = 0.6;
   const hay = JSON.stringify(rec.fields).toLowerCase();
   const domainTerms = hintTerms.filter((t2) => t2.length > 2);
@@ -75693,7 +76188,7 @@ function computeRelevance2(rec, hintTerms, now = Date.now()) {
   if (typeof count === "number" && count >= 10) score += 0.1;
   return Math.min(0.95, Math.max(0.5, score));
 }
-function shortTs3(iso) {
+function shortTs4(iso) {
   if (!iso || iso.length < 16) return iso || "\u2014";
   return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
 }
@@ -75942,8 +76437,8 @@ var ShopifyProvider = class {
       id: `ev_shopify_${index2}`,
       source: KIND_TO_SOURCE[rec.kind],
       kind: rec.kind,
-      title: buildTitle3(rec, this.opts.store),
-      relevance: computeRelevance3(rec, hintTerms),
+      title: buildTitle4(rec, this.opts.store),
+      relevance: computeRelevance4(rec, hintTerms),
       payload,
       links: {},
       provenance: { query: `shopify ${this.opts.store} ${rec.name}`, collectedAt }
@@ -75960,8 +76455,8 @@ function bindWindowVars(q2, from, to) {
   if (to !== void 0) window2["to"] = to;
   return { ...base2, ...window2 };
 }
-function buildTitle3(rec, store) {
-  const ts = rec.timestamp ? ` \xB7 ${shortTs4(rec.timestamp)}` : "";
+function buildTitle4(rec, store) {
+  const ts = rec.timestamp ? ` \xB7 ${shortTs5(rec.timestamp)}` : "";
   return redactSecrets(`Shopify ${store} ${rec.name}: ${summarize2(rec)}${ts}`).slice(0, 220);
 }
 function summarize2(rec) {
@@ -75988,14 +76483,14 @@ function countResults(data) {
   }
   return found ? total : null;
 }
-function computeRelevance3(rec, hintTerms) {
+function computeRelevance4(rec, hintTerms) {
   let score = rec.relevance ?? 0.6;
   const hay = JSON.stringify(rec.data ?? {}).toLowerCase();
   const domainTerms = hintTerms.filter((t2) => t2.length > 2);
   if (domainTerms.some((t2) => hay.includes(t2.toLowerCase()))) score += 0.2;
   return Math.min(0.95, Math.max(0.5, score));
 }
-function shortTs4(iso) {
+function shortTs5(iso) {
   if (!iso || iso.length < 16) return iso || "\u2014";
   return `${iso.slice(5, 10)} ${iso.slice(11, 16)}`;
 }
@@ -76714,6 +77209,15 @@ function shopifyForEnv(renv) {
     }
   );
 }
+function lensForCloud(opts) {
+  return new LensProvider(
+    new LensCloudClient({
+      apiBaseUrl: opts.apiBaseUrl,
+      token: opts.token,
+      workspaceId: opts.workspaceId
+    })
+  );
+}
 function codeForRepo(config2, repoName) {
   const renv = resolveEnvironment(config2, { project: repoName });
   const c4 = codeForEnv(renv);
@@ -77096,6 +77600,9 @@ async function redisServerStatus(renv) {
 // ../../packages/connectors/src/shopify/index.ts
 init_cjs_shims();
 
+// ../../packages/connectors/src/lens/index.ts
+init_cjs_shims();
+
 // ../../packages/cli/src/lib/bundled-backend.ts
 init_cjs_shims();
 var import_node_fs5 = require("fs");
@@ -77378,6 +77885,35 @@ var CloudClient = class {
       `/v1/projects/${projectId}/memory-items${qs ? `?${qs}` : ""}`
     );
   }
+  // ── Team memory (HOR-464 / M4) ────────────────────────────────────────────
+  /**
+   * One-way PROMOTE local items into the workspace's shared team-memory store. Server-wins &
+   * idempotent (`ON CONFLICT (workspace_id, origin_client_id) DO NOTHING`); it clamps/skips
+   * confirmed-outcome (privacy). The body is a positive allowlist — vectors NEVER cross the wire.
+   */
+  promoteTeamMemory(projectId, body2) {
+    return this.request(
+      "POST",
+      `/v1/projects/${projectId}/team-memory/promote`,
+      body2
+    );
+  }
+  /**
+   * Read the workspace's team-memory items with `seq > since`, ORDER BY seq ASC. The v1 client pulls
+   * `since:'0'` and paginates on `nextCursor` until `hasMore` is false, then reconciles the local
+   * cache. `includeDeleted` surfaces tombstones (deletedAt) so the cache can drop removed rows.
+   */
+  listTeamMemorySince(projectId, q2) {
+    const params = new URLSearchParams();
+    params.set("since", q2.since);
+    if (q2.limit !== void 0) params.set("limit", String(q2.limit));
+    if (q2.includeDeleted) params.set("includeDeleted", "true");
+    if (q2.search) params.set("search", q2.search);
+    return this.request(
+      "GET",
+      `/v1/projects/${projectId}/team-memory?${params.toString()}`
+    );
+  }
 };
 
 // ../../packages/cli/src/lib/cloud/auth-store.ts
@@ -84445,6 +84981,21 @@ var memoryItem = pgTable(
     userId: text("user_id"),
     visibility: text("visibility").notNull().default("private"),
     // private|team
+    // HOR-464 (M4): team-memory cache provenance. `origin` distinguishes a locally-authored row
+    // (`local`) from a disposable read-cache row pulled from the cloud team store (`cloud`). The
+    // cloud-owned copy is server-authoritative — `origin='cloud'` rows are readonly locally (any
+    // local mutation throws `MemoryCacheReadonlyError`; re-promote to change) and are NEVER re-pushed
+    // by `memory sync` (which pushes `origin='local'` only). `cloudId` is the server team-memory id,
+    // `authorName` the promoting teammate (DISPLAY-ONLY — never feeds rank), `pulledAt` the last
+    // refresh time (staleness).
+    origin: text("origin").notNull().default("local"),
+    // local|cloud
+    cloudId: text("cloud_id"),
+    // server team_memory id (provenance/join)
+    authorName: text("author_name"),
+    // promoting teammate's display name (attribution, display-only)
+    pulledAt: timestamp("pulled_at", { withTimezone: true }),
+    // last cache-refresh time
     payload: jsonb("payload"),
     // forward-compat, zero-migration extension
     // Incident-family recall keys, populated at WRITE for incident-derived kinds
@@ -84461,7 +85012,9 @@ var memoryItem = pgTable(
     index("memory_item_scope_idx").on(t2.scope),
     index("memory_item_status_idx").on(t2.status),
     index("memory_item_tenancy_idx").on(t2.orgId, t2.workspaceId, t2.repo, t2.userId),
-    index("memory_item_signature_idx").on(t2.signature)
+    index("memory_item_signature_idx").on(t2.signature),
+    // HOR-464: fast repo-scoped split of local-authored vs cloud-cached rows (pull reconcile + sync filter).
+    index("memory_item_origin_idx").on(t2.repo, t2.origin)
   ]
 );
 var memoryLink = pgTable(
@@ -92771,6 +93324,16 @@ WHERE im.investigation_id IS NOT NULL AND im.project IS NULL;`,
 WHERE "project" IS NULL AND incident_input->>'repo' IS NOT NULL;`,
       'CREATE INDEX "investigations_project_created_idx" ON "investigations" ("project","created_at");'
     ]
+  },
+  {
+    "tag": "0012_memory_item_origin",
+    "statements": [
+      `ALTER TABLE "memory_item" ADD COLUMN "origin" text DEFAULT 'local' NOT NULL;`,
+      'ALTER TABLE "memory_item" ADD COLUMN "cloud_id" text;',
+      'ALTER TABLE "memory_item" ADD COLUMN "author_name" text;',
+      'ALTER TABLE "memory_item" ADD COLUMN "pulled_at" timestamp with time zone;',
+      'CREATE INDEX IF NOT EXISTS "memory_item_origin_idx" ON "memory_item" ("repo","origin");'
+    ]
   }
 ];
 
@@ -94177,6 +94740,7 @@ init_cjs_shims();
 
 // ../../packages/engine/src/engine.ts
 init_cjs_shims();
+init_src();
 
 // ../../packages/engine/src/render.ts
 init_cjs_shims();
@@ -96403,6 +96967,16 @@ var MemorySecretError = class extends Error {
     this.kind = kind;
   }
 };
+var MemoryCacheReadonlyError = class extends Error {
+  id;
+  constructor(id) {
+    super(
+      `refusing to mutate a cloud-owned cached memory item (${id}); the team store owns it \u2014 re-promote to change it`
+    );
+    this.name = "MemoryCacheReadonlyError";
+    this.id = id;
+  }
+};
 var CLAIM_SECRET_PATTERNS = [
   { label: "private-key", re: /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/ },
   { label: "jwt", re: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/ },
@@ -96562,6 +97136,7 @@ function createLocalMemoryStore(db) {
     async update(id, patch, opts) {
       const current = await getById(id);
       if (current === null) throw new Error(`memory item not found: ${id}`);
+      if (current.origin === "cloud") throw new MemoryCacheReadonlyError(id);
       const set = {};
       if (patch.claim !== void 0) {
         assertClaimClean(patch.claim);
@@ -96594,6 +97169,7 @@ function createLocalMemoryStore(db) {
       if (repo === "") return [];
       const conds = [eq(memoryItem.repo, repo)];
       if (q2.scope !== void 0) conds.push(eq(memoryItem.scope, q2.scope));
+      if (q2.origin !== void 0) conds.push(eq(memoryItem.origin, q2.origin));
       if (q2.visibility !== void 0) conds.push(eq(memoryItem.visibility, q2.visibility));
       if (q2.orgId !== void 0) conds.push(eq(memoryItem.orgId, q2.orgId));
       if (q2.workspaceId !== void 0) conds.push(eq(memoryItem.workspaceId, q2.workspaceId));
@@ -96614,6 +97190,7 @@ function createLocalMemoryStore(db) {
     async setStatus(id, status, audit) {
       const current = await getById(id);
       if (current === null) throw new Error(`memory item not found: ${id}`);
+      if (current.origin === "cloud") throw new MemoryCacheReadonlyError(id);
       await db.update(memoryItem).set({ status }).where(eq(memoryItem.id, id));
       await appendAudit({
         memoryId: id,
@@ -96627,6 +97204,7 @@ function createLocalMemoryStore(db) {
     async setVisibility(id, v4, audit) {
       const current = await getById(id);
       if (current === null) throw new Error(`memory item not found: ${id}`);
+      if (current.origin === "cloud") throw new MemoryCacheReadonlyError(id);
       await db.update(memoryItem).set({ visibility: v4 }).where(eq(memoryItem.id, id));
       await appendAudit({
         memoryId: id,
@@ -96771,6 +97349,96 @@ function createLocalMemoryStore(db) {
     },
     async history(id) {
       return db.select().from(memoryAudit).where(eq(memoryAudit.memoryId, id)).orderBy(desc(memoryAudit.at), desc(memoryAudit.id));
+    },
+    // ---- HOR-464 / M4: disposable team-memory read-cache + one-way promote ----
+    async upsertCached(item, audit) {
+      assertClaimClean(item.claim);
+      const repo = (item.repo ?? "").trim();
+      if (repo === "") throw new Error("memory_item requires a repo (HOR-46 fail-closed)");
+      const id = (item.id ?? "").trim();
+      if (id === "") throw new Error("upsertCached requires a stable item id (the origin client id)");
+      const status = item.status ?? "fresh";
+      const now = /* @__PURE__ */ new Date();
+      const values2 = {
+        ...item,
+        id,
+        repo,
+        status,
+        origin: "cloud",
+        pulledAt: now,
+        signature: null,
+        tags: null
+      };
+      await db.insert(memoryItem).values(values2).onConflictDoUpdate({
+        target: memoryItem.id,
+        set: {
+          kind: values2.kind,
+          claim: values2.claim,
+          scope: values2.scope,
+          source: values2.source,
+          status,
+          confidence: values2.confidence,
+          visibility: values2.visibility ?? "team",
+          evidence: values2.evidence,
+          cloudId: values2.cloudId ?? null,
+          authorName: values2.authorName ?? null,
+          lastVerifiedAt: values2.lastVerifiedAt ?? null,
+          lastVerifiedHash: values2.lastVerifiedHash ?? null,
+          origin: "cloud",
+          // Re-scope to the repo we're pulling into. The cache is disposable and
+          // project-isolated (HOR-46): a team item's id is the promoter's local id and is
+          // stable across a workspace, so pulling it from a different repo on the same store
+          // must move the cache row to the current repo — otherwise "pull here" silently
+          // leaves it invisible here, stuck in whichever repo first pulled it.
+          repo: values2.repo,
+          pulledAt: now
+        }
+      });
+      const row = await getById(id);
+      if (row === null) throw new Error("memory_item upsertCached returned no row");
+      await appendAudit({
+        memoryId: id,
+        action: "pulled",
+        actor: audit.actor,
+        fromStatus: null,
+        toStatus: status,
+        note: audit.note ?? null,
+        detail: { origin: "cloud", ...values2.cloudId ? { cloudId: values2.cloudId } : {} }
+      });
+      return row;
+    },
+    async reconcileCache(repo, keepIds) {
+      const r = repo.trim();
+      if (r === "") return 0;
+      const conds = keepIds.length > 0 ? and(
+        eq(memoryItem.repo, r),
+        eq(memoryItem.origin, "cloud"),
+        notInArray(memoryItem.id, keepIds)
+      ) : and(eq(memoryItem.repo, r), eq(memoryItem.origin, "cloud"));
+      const deleted = await db.delete(memoryItem).where(conds).returning();
+      return deleted.length;
+    },
+    async markPromoted(id, provenance, audit) {
+      const current = await getById(id);
+      if (current === null) throw new Error(`memory item not found: ${id}`);
+      await db.update(memoryItem).set({
+        visibility: "team",
+        origin: "cloud",
+        cloudId: provenance.cloudId,
+        authorName: provenance.authorName ?? current.authorName ?? null
+      }).where(eq(memoryItem.id, id));
+      await appendAudit({
+        memoryId: id,
+        action: "promote",
+        actor: audit.actor,
+        fromStatus: null,
+        toStatus: null,
+        note: audit.note ?? `promoted to team (cloud id ${provenance.cloudId})`,
+        detail: { origin: "cloud", visibility: "team", cloudId: provenance.cloudId }
+      });
+      const updated = await getById(id);
+      if (updated === null) throw new Error(`memory item vanished during promote: ${id}`);
+      return updated;
     }
   };
 }
@@ -97168,7 +97836,7 @@ async function captureInvestigationMemory(store, investigationId, report, report
 init_cjs_shims();
 function hasAnyRuntimeConnector(c4) {
   return Boolean(
-    c4.elasticsearch || c4.sentry || c4.axiom || c4.grafana || c4.mongodb || c4.postgres || c4.redis || c4.queue || c4.shopify
+    c4.elasticsearch || c4.sentry || c4.lens || c4.axiom || c4.grafana || c4.mongodb || c4.postgres || c4.redis || c4.queue || c4.shopify
   );
 }
 function isUnavailable(c4, kind) {
@@ -99895,6 +100563,88 @@ async function investigate(input, deps) {
       sentryFailureReason = connectorFailureReason(sentryErr);
     }
   }
+  let lensCollected = false;
+  let lensFailureReason;
+  let lensReportCount = 0;
+  if (deps.lens) {
+    try {
+      const from = logWindowFrom(input.logsSince ?? input.since);
+      const to = (/* @__PURE__ */ new Date()).toISOString();
+      const lensSeedBase = top ? top.filePath.split("/").pop() ?? "" : "";
+      const lensTerms = top ? [.../* @__PURE__ */ new Set([...tokenize(hint), ...tokenize(top.name), ...tokenize(lensSeedBase)])] : [...new Set(tokenize(hint))];
+      const seedFileBase = top ? (top.filePath.split("/").pop() ?? "").toLowerCase() : "";
+      const signals = await deps.lens.collect({ from, to, hintTerms: lensTerms });
+      lensCollected = true;
+      lensReportCount = signals.length;
+      for (const sig of signals.slice(0, 10)) {
+        const frame = sig.topFrame;
+        const sigKey = [sig.comment ?? "", sig.topErrorMessage ?? "", frame?.function ?? "", frame?.filename ?? ""].filter(Boolean).join(" ");
+        const frameFileBase = (frame?.filename ?? "").split("/").pop()?.toLowerCase() ?? "";
+        const frameMatchesSeed = seedFileBase.length > 0 && frameFileBase.length > 0 && (frameFileBase === seedFileBase || frameFileBase.includes(seedFileBase) || seedFileBase.includes(frameFileBase));
+        const { relevanceClass: classified, relevanceReason } = classifyLogRelevance(
+          sigKey,
+          frame?.filename ? [frame.filename] : [],
+          lensTerms,
+          input.service
+        );
+        const relevanceClass = frameMatchesSeed ? "direct" : classified;
+        const reason = frameMatchesSeed ? `Lens report frame at seed file ${frame?.filename ?? ""}` : relevanceReason;
+        const commentText = sig.comment ? redactSecrets(sig.comment).slice(0, 80) : "(no comment)";
+        const where = sig.route ?? sig.url ?? "";
+        const whereStr = where !== "" ? ` \xB7 ${where}` : "";
+        const frameLoc = frame?.filename ? ` @ ${frame.filename}${frame.lineno !== void 0 ? `:${frame.lineno}` : ""}` : "";
+        const tag = relevanceClass === "ambient" ? " [ambient]" : "";
+        const title = `Lens report: "${commentText}" \xB7 ${sig.errorCount} error(s)${whereStr} (${shortTs(sig.createdAt)})${frameLoc}${tag}`.slice(
+          0,
+          220
+        );
+        const links = {};
+        if (frame?.filename !== void 0) links.file = frame.filename;
+        if (frame?.lineno !== void 0) links.line = frame.lineno;
+        const ev = mkEv(
+          "log",
+          title,
+          {
+            source: "lens",
+            reportId: sig.id,
+            comment: sig.comment ? redactSecrets(sig.comment) : null,
+            route: sig.route ?? null,
+            url: sig.url ?? null,
+            release: sig.release ?? null,
+            gitSha: sig.gitSha ?? null,
+            trigger: sig.trigger ?? null,
+            errorCount: sig.errorCount,
+            topError: sig.topErrorMessage ? redactSecrets(sig.topErrorMessage) : null,
+            // Direct code seed — same fields the engine reads off a code symbol.
+            filePath: frame?.filename ?? null,
+            symbolName: frame?.function ?? null,
+            lineStart: frame?.lineno ?? null,
+            failingRequests: sig.failingRequests,
+            reactComponents: sig.reactComponents ?? null,
+            featureFlags: sig.featureFlags ?? null,
+            relevanceClass,
+            relevanceReason: reason
+          },
+          links,
+          sig.submittedAt ?? sig.createdAt ?? void 0,
+          // Direct: full report weight, boosted when the raise-site frame is resolved.
+          // Ambient: demoted so unrelated reports don't inflate confidence.
+          relevanceClass === "direct" ? frame?.filename ? 0.95 : 0.9 : 0.45
+        );
+        logEvIds.push(ev.id);
+        if (relevanceClass === "direct") {
+          directLogEvIds.push(ev.id);
+          const sigLabel = sig.comment && sig.comment.trim() !== "" ? redactSecrets(sig.comment).slice(0, 120) : sig.topErrorMessage ? redactSecrets(sig.topErrorMessage) : `Lens report ${sig.id}`;
+          directSignatures.push({ key: sigLabel, count: Math.max(1, sig.errorCount), message: sigLabel });
+        } else {
+          ambientLogEvIds.push(ev.id);
+        }
+      }
+    } catch (lensErr) {
+      lensCollected = false;
+      lensFailureReason = connectorFailureReason(lensErr);
+    }
+  }
   let axiomCollected = false;
   let axiomFailureReason;
   if (deps.axiom) {
@@ -100920,6 +101670,7 @@ async function investigate(input, deps) {
     ["mongodb", deps.connectors.mongodb, deps.mongo],
     ["postgres", deps.connectors.postgres, deps.postgres],
     ["sentry", deps.connectors.sentry, deps.sentry],
+    ["lens", deps.connectors.lens, deps.lens],
     ["axiom", deps.connectors.axiom, deps.axiom],
     ["shopify", deps.connectors.shopify, deps.shopify],
     ["redis", deps.connectors.redis, deps.redisState]
@@ -100935,6 +101686,8 @@ async function investigate(input, deps) {
     // `unavailable` instead of silently flipping to "not configured".
     sentryCollected,
     sentryFailureReason,
+    lensCollected,
+    lensFailureReason,
     axiomCollected,
     axiomFailureReason,
     shopifyCollected,
@@ -100957,6 +101710,9 @@ async function investigate(input, deps) {
     sentry: deps.sentry != null,
     sentryCollected,
     sentryFailureReason,
+    lens: deps.lens != null,
+    lensCollected,
+    lensFailureReason,
     axiom: deps.axiom != null,
     axiomCollected,
     axiomFailureReason,
@@ -104291,8 +105047,8 @@ function buildLowerPriority(report, seedLowConfidence, effectiveTopLower) {
     });
     const noEvidence = !c4.implicated && !hasRuntimeEvidence;
     if (!noEvidence) continue;
-    const inWindow = [...c4.files].some((f5) => changedFiles.has(f5));
-    if (inWindow) continue;
+    const inWindow2 = [...c4.files].some((f5) => changedFiles.has(f5));
+    if (inWindow2) continue;
     out2.push({
       area: c4.area,
       reasons: [
@@ -119879,6 +120635,9 @@ async function buildInvestigationContext(renv, opts) {
   const mongo = mongoForEnv(renv);
   const postgres2 = postgresForEnv(renv);
   const sentry = sentryForEnv(renv);
+  const auth = readAuth();
+  const cloudCfg = readCloudConfig(renv.path);
+  const lens = auth && cloudCfg?.workspace?.id ? lensForCloud({ apiBaseUrl: auth.apiBaseUrl, token: auth.token, workspaceId: cloudCfg.workspace.id }) : null;
   const axiom = axiomForEnv(renv);
   const shopify = shopifyForEnv(renv);
   const queue = queueForEnv(renv);
@@ -119897,6 +120656,7 @@ async function buildInvestigationContext(renv, opts) {
     mongo,
     postgres: postgres2,
     sentry,
+    lens,
     axiom,
     shopify,
     queue,
@@ -119949,6 +120709,7 @@ async function runOneInvestigation(input, ctx, opts = {}) {
       mongo: ctx.mongo,
       postgres: ctx.postgres,
       sentry: ctx.sentry,
+      lens: ctx.lens,
       axiom: ctx.axiom,
       shopify: ctx.shopify,
       queue: ctx.queue,
@@ -119965,6 +120726,9 @@ async function runOneInvestigation(input, ctx, opts = {}) {
         mongodb: !!renv.connectors.mongodb,
         postgres: !!renv.connectors.postgres,
         sentry: !!renv.connectors.sentry,
+        // Lens is NATIVE (no config stanza) — "configured" == provider present, mirroring how
+        // `queue` is derived from `ctx.queue`. Absent when not logged in / repo not cloud-linked.
+        lens: ctx.lens != null,
         axiom: !!renv.connectors.axiom,
         shopify: !!renv.connectors.shopify,
         redis: !!renv.connectors.redis,
@@ -122314,6 +123078,12 @@ function fromWire(r, repo) {
     repo,
     userId: r.createdByUserId ?? null,
     visibility: r.visibility,
+    // This is the write-only private mirror path (dualWrite reads local): a round-tripped record is
+    // the device's OWN authored item, so it carries no team-cache provenance (HOR-464).
+    origin: "local",
+    cloudId: null,
+    authorName: null,
+    pulledAt: null,
     payload: null,
     // Incident-family recall keys are LOCAL-ONLY context (like vectors): they never enter the
     // cloud-sync path, so a cloud-read row carries neither.
@@ -122375,6 +123145,10 @@ function createCloudMemoryStore(client, cfg) {
         repo: item.repo ?? repoFallback,
         userId: item.userId ?? null,
         visibility: input.visibility ?? "private",
+        origin: "local",
+        cloudId: null,
+        authorName: null,
+        pulledAt: null,
         payload: null,
         // Incident-family recall keys stay LOCAL-ONLY — never synced, so the cloud echo carries neither.
         signature: null,
@@ -122409,6 +123183,10 @@ function createCloudMemoryStore(client, cfg) {
         repo: repoFallback,
         userId: null,
         visibility: "private",
+        origin: "local",
+        cloudId: null,
+        authorName: null,
+        pulledAt: null,
         payload: null,
         signature: null,
         tags: null
@@ -122667,6 +123445,10 @@ function recalledToJSON(r) {
     effectiveStatus: r.freshness.status,
     confidence: r.item.confidence,
     visibility: r.item.visibility,
+    // HOR-464: provenance + teammate attribution. `origin='cloud'` marks a pulled team item; the
+    // `authorName` is DISPLAY-ONLY (it is never read into rank/order — the honesty invariant).
+    origin: r.item.origin,
+    authorName: r.item.authorName ?? null,
     evidence: r.item.evidence,
     freshness: {
       label: r.freshness.label,
@@ -122693,6 +123475,10 @@ function renderStoredItems(items) {
     lines.push(
       `  - ${r.item.kind} \xB7 scope: ${r.item.scope} \xB7 ${r.freshness.label}${drift} \xB7 confidence: ${conf}`
     );
+    if (r.item.origin === "cloud") {
+      const who = r.item.authorName ? `teammate ${r.item.authorName}` : "a teammate";
+      lines.push(`  - ${import_picocolors36.default.dim(`shared by ${who} (team)`)}`);
+    }
   }
   return lines.join("\n");
 }
@@ -123171,6 +123957,7 @@ async function runMemorySync(opts) {
     const store = createLocalMemoryStore(db);
     items = await store.query({
       repo: project,
+      origin: "local",
       status: SYNCABLE_STATUSES,
       limit: opts.limit ?? 5e3
     });
@@ -123305,6 +124092,215 @@ async function runMemorySync(opts) {
   }
   return failed > 0 ? 1 : 0;
 }
+function toPromoteInput(item) {
+  return {
+    originClientId: item.id,
+    kind: item.kind,
+    claim: item.claim,
+    scope: item.scope,
+    source: item.source,
+    status: item.status,
+    confidence: item.confidence,
+    contentHash: item.lastVerifiedHash ?? null,
+    provenance: {}
+  };
+}
+async function runMemoryPromote(id, opts) {
+  const json2 = opts.json === true;
+  const fail = (msg) => {
+    if (json2) console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+    else console.error(import_picocolors36.default.red(msg));
+    return 1;
+  };
+  const memId = (id ?? "").trim();
+  if (memId === "") return fail("A memory item id is required.");
+  const root = repoRootOrCwd(opts.cwd);
+  const cfg = readCloudConfig(root);
+  if (!isCloudActive(cfg) || !cfg.project) {
+    return fail("This repo isn't linked to a cloud project. Run `horus cloud link` first.");
+  }
+  const session = authedClient();
+  if (!session) return fail("Not logged in. Run `horus login` first.");
+  let config2;
+  try {
+    config2 = await loadConfig(opts.config);
+  } catch (err2) {
+    return fail(err2.message);
+  }
+  const project = resolveProject(config2, opts.repo);
+  if (!project) return 1;
+  const { db, sql: sql2 } = await openDb(config2.database.url);
+  try {
+    const store = createLocalMemoryStore(db);
+    const row = await store.get(memId);
+    if (row === null) return fail(`Memory item not found: ${memId}`);
+    if (row.kind === "confirmed-outcome" || row.source === "confirmed-outcome") {
+      return fail("Refusing to promote a confirmed-outcome item \u2014 it stays private (spec \xA75.2).");
+    }
+    if (row.origin === "cloud") {
+      if (json2) console.log(JSON.stringify({ ok: true, id: memId, alreadyTeam: true }, null, 2));
+      else console.log(import_picocolors36.default.dim(`${memId} is already a team item \u2014 nothing to promote.`));
+      return 0;
+    }
+    const res = await session.client.promoteTeamMemory(cfg.project.id, {
+      items: [toPromoteInput(row)]
+    });
+    const promoted = res.items.find((it2) => it2.originClientId === memId);
+    if (!promoted) {
+      return fail(
+        `The server did not promote ${memId} (skipped ${res.skipped}/${res.total}). Local state unchanged.`
+      );
+    }
+    const updated = await store.markPromoted(
+      memId,
+      { cloudId: promoted.id, authorName: promoted.authorName ?? null },
+      { actor: { kind: "user" }, note: `promoted to team ${cfg.project.slug}` }
+    );
+    if (json2) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: true,
+            id: memId,
+            cloudId: promoted.id,
+            visibility: updated.visibility,
+            origin: updated.origin
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(
+        import_picocolors36.default.green(`Promoted ${memId} to team memory (${cfg.project.slug}) \u2014 now visible to teammates.`)
+      );
+    }
+    return 0;
+  } catch (err2) {
+    return fail(err2.message);
+  } finally {
+    await sql2.end();
+  }
+}
+var TEAM_PULL_PAGE_LIMIT = 200;
+var TEAM_PULL_MAX_PAGES = 1e4;
+function formatAge3(ms) {
+  const mins = Math.floor(ms / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h ago`;
+  return `${Math.floor(hrs / 24)}d ago`;
+}
+async function runMemoryPull(opts) {
+  const json2 = opts.json === true;
+  const fail = (msg) => {
+    if (json2) console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+    else console.error(import_picocolors36.default.red(msg));
+    return 1;
+  };
+  const root = repoRootOrCwd(opts.cwd);
+  const cfg = readCloudConfig(root);
+  if (!isCloudActive(cfg) || !cfg.project) {
+    return fail("This repo isn't linked to a cloud project. Run `horus cloud link` first.");
+  }
+  const session = authedClient();
+  if (!session) return fail("Not logged in. Run `horus login` first.");
+  let config2;
+  try {
+    config2 = await loadConfig(opts.config);
+  } catch (err2) {
+    return fail(err2.message);
+  }
+  const project = resolveProject(config2, opts.repo);
+  if (!project) return 1;
+  const { db, sql: sql2 } = await openDb(config2.database.url);
+  try {
+    const store = createLocalMemoryStore(db);
+    const vectorIndex = buildVectorIndex(config2, project);
+    const items = [];
+    let since = "0";
+    try {
+      for (let page = 0; page < TEAM_PULL_MAX_PAGES; page++) {
+        const res = await session.client.listTeamMemorySince(cfg.project.id, {
+          since,
+          limit: TEAM_PULL_PAGE_LIMIT,
+          includeDeleted: true
+        });
+        items.push(...res.items);
+        if (!res.hasMore || !res.nextCursor) break;
+        since = res.nextCursor;
+      }
+    } catch (err2) {
+      if (err2 instanceof CloudOfflineError) {
+        const cached2 = await store.query({ repo: project, origin: "cloud" });
+        const newest = cached2.map((c4) => c4.pulledAt ? new Date(c4.pulledAt).getTime() : 0).reduce((a2, b5) => Math.max(a2, b5), 0);
+        const note = newest > 0 ? `stale \u2014 last pulled ${formatAge3(Date.now() - newest)}` : "stale \u2014 never pulled";
+        if (json2) {
+          console.log(
+            JSON.stringify({ ok: true, offline: true, stale: true, cached: cached2.length, note }, null, 2)
+          );
+        } else {
+          console.log(import_picocolors36.default.yellow(`Offline \u2014 serving ${cached2.length} cached team item(s) (${note}).`));
+        }
+        return 0;
+      }
+      throw err2;
+    }
+    const keepIds = [];
+    let upserted = 0;
+    let removed = 0;
+    for (const it2 of items) {
+      if (it2.deletedAt) {
+        await bestEffortRemove(vectorIndex, it2.originClientId);
+        continue;
+      }
+      const cacheRow = {
+        id: it2.originClientId,
+        // stable cross-device id (the promoting device's local id)
+        kind: it2.kind,
+        claim: it2.claim,
+        scope: it2.scope,
+        source: it2.source,
+        status: it2.status ?? "fresh",
+        // A null server confidence stores as 0 — honest (unknown confidence ranks low, never inflated).
+        confidence: it2.confidence ?? 0,
+        evidence: [],
+        repo: project,
+        visibility: "team",
+        cloudId: it2.id,
+        authorName: it2.authorName
+      };
+      await store.upsertCached(cacheRow, { actor: { kind: "system" }, note: "memory pull" });
+      await bestEffortUpsert(vectorIndex, {
+        memoryId: it2.originClientId,
+        claim: it2.claim,
+        repo: project,
+        scope: it2.scope
+      });
+      keepIds.push(it2.originClientId);
+      upserted += 1;
+    }
+    removed = await store.reconcileCache(project, keepIds);
+    if (json2) {
+      console.log(
+        JSON.stringify({ ok: true, project, pulled: upserted, removed, total: items.length }, null, 2)
+      );
+    } else {
+      console.log(
+        import_picocolors36.default.green(
+          `Pulled ${upserted} team memory item(s)` + (removed ? `, dropped ${removed} stale` : "") + "."
+        )
+      );
+      console.log(import_picocolors36.default.dim("Team items are read-only locally \u2014 re-promote to change one. Vectors stay local."));
+    }
+    return 0;
+  } catch (err2) {
+    return fail(err2.message);
+  } finally {
+    await sql2.end();
+  }
+}
 function outcomeLabelToJSON(l2) {
   return {
     id: l2.id,
@@ -129302,6 +130298,12 @@ Examples:
       process.exitCode = await runMemorySync(opts);
     }
   );
+  memory.command("promote <id>").description("Promote a local memory item into the shared team memory (one-way; refuses confirmed-outcome)").option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "repository/project WITHIN the loaded config (default: inferred from cwd) \u2014 cross-repo targeting is --config or cd").option("--json", "output JSON").action(async (id, opts) => {
+    process.exitCode = await runMemoryPromote(id, opts);
+  });
+  memory.command("pull").description("Refresh the local cache of shared team memory (full pull; offline serves stale cache)").option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "repository/project WITHIN the loaded config (default: inferred from cwd) \u2014 cross-repo targeting is --config or cd").option("--force", "force a full refresh even if the cache looks current").option("--json", "output JSON").action(async (opts) => {
+    process.exitCode = await runMemoryPull(opts);
+  });
   const evalCmd = program2.command("eval").description("Read-only accuracy harness over Horus's outcome-label eval set (never writes labels)");
   evalCmd.command("build").description("Emit a byte-stable corpus-<version>.jsonl + manifest from the eval set (read-only)").option("-c, --config <path>", "path to horus.config.ts").option("--repo <name>", "repository/project WITHIN the loaded config (default: inferred from cwd) \u2014 cross-repo targeting is --config or cd").option("--source <source>", "filter to one signal source: feedback | confirm").option("--days <n>", "only include labels from the last N days", (v4) => Number(v4)).option("--limit <n>", "max labels to scan", (v4) => Number(v4)).option("--out <dir>", "output directory for the corpus + manifest (default: ./.horus/eval)").option("--version <v>", "corpus schema version tag (default: v1)").option("--json", "output JSON").action(
     async (opts) => {