@oxygen-agent/cli 1.948.1 → 1.987.20

package/node_modules/@oxygen/shared/dist/knowledge-bootstrap.js

@@ -43,43 +43,16 @@
  *                    ordinary revisioned wiki writes a human can revert.
  *   6. EXACTLY-ONCE — the marker is claimed with a conditional UPDATE, so N worker
  *                    replicas polling one tenant produce one run, never N runs.
- *   7. OXYGEN-FUNDED — the automatic pass meters managed credits through the ordinary
- *                    tool and AI-column lanes (so the cap, the marker and the run row
- *                    all stay honest), and the worker then grants exactly the credits
- *                    it used back to the workspace as an idempotent `bonus` ledger
- *                    row keyed by the run (`KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX`).
- *                    The customer's balance nets to zero and both rows are visible in
- *                    their ledger. Only the AUTOMATIC pass is covered: a requested
- *                    `--live --max-credits` re-run is the customer's own paid action.
+ *   7. OXYGEN-FUNDED — the internal worker scope records nominal managed-credit
+ *                    holds and settlements with zero customer-balance deltas.
+ *                    Manual reruns remain customer-funded. Durable call checkpoints
+ *                    replay completed results and never repeat uncertain dispatch.
  *
- * CAP ARITHMETIC (prices re-read from packages/integrations/src/cogs-rates.ts —
- * confirm them there rather than trusting this comment after a re-pricing):
- *
- *   serper.search           5 cr per call   (cogs-rates: serper.customerOxygen…search)
- *   exa.contents            5 cr per CALL   (not per URL — this is the whole trick)
- *   AI column, medium tier 75 cr per run    (pricing-sheet: AI_COLUMN_CREDITS.medium)
- *
- *   Happy path  = 1 serper.search (5) + 1 exa.contents over <= 5 URLs (5)
- *                 + 1 medium synthesis pass (75)                        =  85 cr
- *   Enrichment sub-cap  60 cr  — ~6x the 10 cr the happy path needs, so a waterfall
- *                                retry or a second search fits, and a runaway
- *                                per-URL fetch loop is stopped long before the
- *                                overall ceiling.
- *   Hard cap           300 cr  — 85 cr nominal plus room for two retried synthesis
- *                                passes. 3% of the 10,000-credit signup grant
- *                                (FREE_SIGNUP_GRANT_CREDITS, ./billing.ts), which is
- *                                the headroom the balance gate needs even though the
- *                                spend is granted back.
- *
- *   The obvious implementation — firecrawl.map + 3x firecrawl.scrape — costs
- *   4 x 40 = 160 cr for the SAME job, because Firecrawl bills per page. exa.contents
- *   is priced per call and is built for fetching text at known URLs; that is why the
- *   read budget is a page COUNT (`KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ`) inside one
- *   call rather than a call count.
- *
- * This module is a leaf: constants and types only, no DB and no provider imports, so
- * the worker, tenant-db, CLI, and API surfaces all bind to one contract.
+ * New workspace consent scopes the submitted domain and actual signup creator.
+ * Professional person evidence remains actor-scoped; ICP/offers are hypotheses.
+ * The provider sub-cap covers every external research leg, including fallbacks.
  */
+import { normalizeLinkedinProfileUrl } from "./linkedin-url.js";
 /** Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases. */
 export const KNOWLEDGE_BOOTSTRAP_MAX_CREDITS = 300;
 /**
@@ -100,6 +73,19 @@ export const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_TIER = "medium";
  * it is a quality/latency knob, and the credit ceilings above remain the money guard.
  */
 export const KNOWLEDGE_BOOTSTRAP_MAX_PAGES_READ = 5;
+/**
+ * Per-call provider abort budget for every paid leg of the pass (LinkedIn company,
+ * person search/profile, page search, page read), in milliseconds.
+ *
+ * The platform default is 120 s, sized for a durable column run. This pass runs
+ * inside the worker's tenant-maintenance tick under a 300 s step deadline, so two
+ * hung LinkedIn calls at the default (measured 2026-09-15/16: the managed vendor
+ * accepted connections and never answered) consumed the whole budget before the
+ * page reads and the synthesis got a turn. 45 s keeps the worst case — five legs,
+ * every one hanging — inside the step, and a healthy vendor answers in well under
+ * it. This bounds latency only; the credit ceilings above remain the money guard.
+ */
+export const KNOWLEDGE_BOOTSTRAP_PROVIDER_TIMEOUT_MS = 45_000;
 /** Fleet-wide kill switch, matching OXYGEN_KNOWLEDGE_RETRIEVAL/AUTO_SOURCES_DISABLED. */
 export const KNOWLEDGE_BOOTSTRAP_DISABLED_ENV_VAR = "OXYGEN_KNOWLEDGE_BOOTSTRAP_DISABLED";
 /**
@@ -186,12 +172,22 @@ export function readKnowledgeBootstrapConsent(metadata) {
         return null;
     if (!Number.isFinite(Date.parse(grantedAt)))
         return null;
+    const scope = record.scope === "company_and_creator" ? "company_and_creator" : undefined;
+    const grantedBy = typeof record.granted_by_clerk_user_id === "string" && record.granted_by_clerk_user_id.length > 0
+        ? record.granted_by_clerk_user_id
+        : null;
+    // A person hint is valid only as part of the creator-scoped grant. Otherwise a
+    // stale metadata value could be mistaken for an organization-wide profile hint.
+    const creatorLinkedinUrl = scope && grantedBy && typeof record.creator_linkedin_url === "string"
+        ? normalizeLinkedinProfileUrl(record.creator_linkedin_url)?.dispatchUrl ?? null
+        : null;
     return {
         granted_at: grantedAt,
+        ...(scope ? { scope } : {}),
+        ...(typeof record.domain === "string" ? { domain: record.domain } : {}),
+        ...(creatorLinkedinUrl ? { creator_linkedin_url: creatorLinkedinUrl } : {}),
         source: typeof record.source === "string" && record.source.length > 0 ? record.source : null,
-        granted_by_clerk_user_id: typeof record.granted_by_clerk_user_id === "string" && record.granted_by_clerk_user_id.length > 0
-            ? record.granted_by_clerk_user_id
-            : null,
+        granted_by_clerk_user_id: grantedBy,
     };
 }
 /**
@@ -248,13 +244,14 @@ export const KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX = "knowledge_bootst
  */
 export const KNOWLEDGE_BOOTSTRAP_RESEARCH_PAGE_SLUG = "company-research";
 /**
- * The typed `company_profile` sections a bootstrap may write — and the exact set the
- * "never clobber a profile a human already filled" gate inspects.
+ * The typed `company_profile` sections inspected by the automatic bootstrap's
+ * "never clobber a profile a human already filled" gate.
  *
  * `gtm_stack` and `custom` are structurally excluded: research of a company's public
  * web presence says nothing about which tools it has connected here, and a workspace
  * that filled only those has told us nothing about its company and must still be
- * bootstrapped. Same reasoning as the slug above — the preview promises this list.
+ * bootstrapped. This is the existing-context guard's list, not a list of writes:
+ * current research writes company facts and stores inferred GTM hypotheses separately.
  */
 export const KNOWLEDGE_BOOTSTRAP_PROFILE_SECTIONS = [
     "company",

package/node_modules/@oxygen/shared/dist/knowledge-repository.d.ts

@@ -0,0 +1,22 @@
+export declare const KNOWLEDGE_REPOSITORY_FILE_LIMIT = 25000;
+export declare const KNOWLEDGE_REPOSITORY_POLL_MS: number;
+export declare const KNOWLEDGE_REPOSITORY_IDLE_MS = 15000;
+export declare const KNOWLEDGE_REPOSITORY_MAX_WAIT_MS = 60000;
+export type KnowledgeRepositoryMode = "import" | "two_way";
+/** Files may be preserved without being executed. Credentials and machine state are never imported. */
+export declare function knowledgeRepositoryExclusion(path: string, mode?: string): string | null;
+export declare function normalizeKnowledgeRepositoryRoot(root: string): string;
+export declare function knowledgeRepositoryRelativePath(path: string, root: string): string | null;
+export type KnowledgeMergeResult = {
+    kind: "merged";
+    text: string | null;
+} | {
+    kind: "conflict";
+};
+/** Conservative three-way merge: identical changes and disjoint line edits are safe.
+ * Overlap, edit/delete and binary changes retain both versions for an explicit decision. */
+export declare function mergeKnowledgeText(base: string | null, local: string | null, remote: string | null): KnowledgeMergeResult;
+export declare function parseKnowledgeLfsPointer(text: string): {
+    oid: string;
+    size: number;
+} | null;

package/node_modules/@oxygen/shared/dist/knowledge-repository.js

@@ -0,0 +1,121 @@
+import { OxygenError } from "./cli-result.js";
+export const KNOWLEDGE_REPOSITORY_FILE_LIMIT = 25_000;
+export const KNOWLEDGE_REPOSITORY_POLL_MS = 5 * 60_000;
+export const KNOWLEDGE_REPOSITORY_IDLE_MS = 15_000;
+export const KNOWLEDGE_REPOSITORY_MAX_WAIT_MS = 60_000;
+function isCredentialFile(name) {
+    if (name === ".env" ||
+        name.startsWith(".env.") ||
+        [
+            ".git-credentials",
+            ".git_credentials_input",
+            ".netrc",
+            ".npmrc",
+            ".pypirc",
+            "credentials",
+        ].includes(name) ||
+        /^(?:id_rsa|id_ed25519|id_ecdsa)(?:\.|$)/.test(name) ||
+        /\.(?:jks|kdbx|keystore|pem|p12|pfx|key)$/.test(name)) {
+        return true;
+    }
+    const extension = name.match(/\.([^.]+)$/)?.[1] ?? "";
+    return ([
+        "json",
+        "yaml",
+        "yml",
+        "toml",
+        "ini",
+        "cfg",
+        "conf",
+        "properties",
+    ].includes(extension) &&
+        /(?:^|[._-])(?:credentials?|secrets?)(?:[._-]|$)/.test(name));
+}
+/** Files may be preserved without being executed. Credentials and machine state are never imported. */
+export function knowledgeRepositoryExclusion(path, mode = "100644") {
+    if (mode === "120000")
+        return "Symbolic link";
+    if (mode === "160000")
+        return "Submodule";
+    if (!path ||
+        path.startsWith("/") ||
+        path.includes("\\") ||
+        /[\x00-\x1f\x7f]/.test(path) ||
+        path.split("/").some((p) => p === "." || p === ".." || !p))
+        return "Unsafe path";
+    const parts = path.toLowerCase().split("/");
+    if (parts.some((p) => [".git", "node_modules", ".venv", "venv", ".ssh"].includes(p)))
+        return "Machine or dependency files";
+    const name = parts.at(-1);
+    if (isCredentialFile(name))
+        return "Credential file";
+    if (path.startsWith(".github/workflows/"))
+        return "GitHub automation";
+    if (/^\.obsidian\/(?:workspace(?:-mobile)?\.json|cache\/)/.test(path))
+        return "Device layout or cache";
+    return null;
+}
+export function normalizeKnowledgeRepositoryRoot(root) {
+    if (root === "" || root === "/")
+        return "";
+    const value = root.replace(/\/$/, "");
+    if (knowledgeRepositoryExclusion(`${value}/file.md`)) {
+        throw new OxygenError("invalid_knowledge_repository_root", "Choose a relative repository folder without parent paths or excluded directories.");
+    }
+    return value;
+}
+export function knowledgeRepositoryRelativePath(path, root) {
+    if (!root)
+        return path;
+    return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : null;
+}
+/** Conservative three-way merge: identical changes and disjoint line edits are safe.
+ * Overlap, edit/delete and binary changes retain both versions for an explicit decision. */
+export function mergeKnowledgeText(base, local, remote) {
+    if (local === remote)
+        return { kind: "merged", text: local };
+    if (base === local)
+        return { kind: "merged", text: remote };
+    if (base === remote)
+        return { kind: "merged", text: local };
+    if (base === null || local === null || remote === null)
+        return { kind: "conflict" };
+    const lines = (s) => s.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    const original = lines(base);
+    const change = (s) => {
+        const updated = lines(s);
+        let start = 0, tail = 0;
+        while (start < original.length &&
+            start < updated.length &&
+            original[start] === updated[start])
+            start++;
+        while (tail < original.length - start &&
+            tail < updated.length - start &&
+            original[original.length - tail - 1] ===
+                updated[updated.length - tail - 1])
+            tail++;
+        return {
+            start,
+            end: original.length - tail,
+            insert: updated.slice(start, updated.length - tail),
+        };
+    };
+    const a = change(local), b = change(remote);
+    const safelyBefore = (first, second) => first.end < second.start ||
+        (first.end === second.start && first.start < first.end);
+    if (!(safelyBefore(a, b) || safelyBefore(b, a)))
+        return { kind: "conflict" };
+    const result = [...original];
+    for (const c of [a, b].sort((x, y) => y.start - x.start))
+        result.splice(c.start, c.end - c.start, ...c.insert);
+    return { kind: "merged", text: result.join("") };
+}
+export function parseKnowledgeLfsPointer(text) {
+    const match = /^version https:\/\/git-lfs.github.com\/spec\/v1\r?\noid sha256:([a-f0-9]{64})\r?\nsize (\d+)\r?\n?$/.exec(text);
+    if (!match)
+        return null;
+    const size = Number(match[2]);
+    if (!Number.isSafeInteger(size) || size < 0)
+        return null;
+    return { oid: match[1], size };
+}

package/node_modules/@oxygen/shared/dist/knowledge-vault-markdown.d.ts

@@ -0,0 +1,20 @@
+export declare const KNOWLEDGE_VAULT_MARKDOWN_MAX_BYTES = 1500000;
+export declare const KNOWLEDGE_VAULT_PATH_MAX_BYTES = 1024;
+export type KnowledgeVaultMarkdown = {
+    prefix: string;
+    body: string;
+};
+export type ParsedKnowledgeVaultMarkdown = KnowledgeVaultMarkdown & {
+    properties: Record<string, unknown>;
+    hasFrontmatter: boolean;
+    frontmatterError: string | null;
+};
+/** Paths are identities. Reject unsafe paths; never trim, lowercase or normalize them. */
+export declare function assertKnowledgeVaultPath(path: string): string;
+/** Fatal UTF-8 decoding and a roundtrip check prevent silent replacement of invalid bytes. */
+export declare function decodeKnowledgeVaultMarkdown(input: string | Uint8Array): string;
+export declare function parseKnowledgeVaultMarkdown(input: string | Uint8Array): ParsedKnowledgeVaultMarkdown;
+/** No renderer normalization, generated metadata, or implicit trailing newline. */
+export declare function renderKnowledgeVaultMarkdown(input: KnowledgeVaultMarkdown): string;
+/** Change one property without reserializing unrelated YAML or the Markdown body. */
+export declare function setKnowledgeVaultProperty(input: KnowledgeVaultMarkdown, key: string, value: unknown): KnowledgeVaultMarkdown;

package/node_modules/@oxygen/shared/dist/knowledge-vault-markdown.js

@@ -0,0 +1,155 @@
+import { isMap, parseDocument, stringify } from "yaml";
+import { OxygenError } from "./cli-result.js";
+export const KNOWLEDGE_VAULT_MARKDOWN_MAX_BYTES = 1_500_000;
+export const KNOWLEDGE_VAULT_PATH_MAX_BYTES = 1_024;
+function invalid(message) {
+    return new OxygenError("invalid_knowledge_file", message, { exitCode: 1 });
+}
+/** Paths are identities. Reject unsafe paths; never trim, lowercase or normalize them. */
+export function assertKnowledgeVaultPath(path) {
+    if (typeof path !== "string" ||
+        !path ||
+        new TextEncoder().encode(path).length > KNOWLEDGE_VAULT_PATH_MAX_BYTES ||
+        /[\x00-\x1f\x7f\\]/u.test(path) ||
+        path.startsWith("/") ||
+        /^[A-Za-z]:/.test(path) ||
+        path.split("/").some((part) => !part || part === "." || part === "..")) {
+        throw invalid("File path must be a relative path without empty, dot, parent or control-character segments.");
+    }
+    if (new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(new TextEncoder().encode(path)) !== path) {
+        throw invalid("File path must contain valid Unicode characters.");
+    }
+    return path;
+}
+/** Fatal UTF-8 decoding and a roundtrip check prevent silent replacement of invalid bytes. */
+export function decodeKnowledgeVaultMarkdown(input) {
+    const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+    if (bytes.byteLength > KNOWLEDGE_VAULT_MARKDOWN_MAX_BYTES)
+        throw invalid("Markdown file exceeds 1.5 MB.");
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        throw invalid("Markdown must contain valid UTF-8. Preserve other encodings as an attachment.");
+    }
+    if (text.includes("\0") || (typeof input === "string" && text !== input)) {
+        throw invalid("Markdown cannot contain NUL or invalid Unicode characters.");
+    }
+    return text;
+}
+function splitPrefix(text) {
+    const bom = text.startsWith("\ufeff") ? "\ufeff" : "";
+    const rest = text.slice(bom.length);
+    const open = /^---[ \t]*(?:\r\n|\n)/.exec(rest);
+    if (!open)
+        return { prefix: bom, body: rest, yaml: null, yamlOffset: bom.length };
+    const close = /^(?:---|\.\.\.)[ \t]*(?:\r\n|\n|$)/gm;
+    close.lastIndex = open[0].length;
+    const match = close.exec(rest);
+    if (!match)
+        return { prefix: bom, body: rest, yaml: null, yamlOffset: bom.length };
+    const end = match.index + match[0].length;
+    return {
+        prefix: bom + rest.slice(0, end),
+        body: rest.slice(end),
+        yaml: rest.slice(open[0].length, match.index),
+        yamlOffset: bom.length + open[0].length,
+    };
+}
+export function parseKnowledgeVaultMarkdown(input) {
+    const split = splitPrefix(decodeKnowledgeVaultMarkdown(input));
+    let properties = {};
+    let frontmatterError = null;
+    if (split.yaml !== null) {
+        try {
+            const doc = parseDocument(split.yaml, {
+                keepSourceTokens: true,
+                uniqueKeys: true,
+            });
+            if (doc.errors.length || doc.warnings.length)
+                throw new Error(doc.errors[0]?.message ?? doc.warnings[0]?.message);
+            const value = doc.toJS({ maxAliasCount: 50 });
+            if (value !== null && (typeof value !== "object" || Array.isArray(value)))
+                throw new Error("Frontmatter must be a YAML mapping.");
+            if (value)
+                properties = value;
+        }
+        catch (error) {
+            frontmatterError =
+                error instanceof Error ? error.message : "Invalid YAML frontmatter.";
+        }
+    }
+    return {
+        prefix: split.prefix,
+        body: split.body,
+        properties,
+        hasFrontmatter: split.yaml !== null,
+        frontmatterError,
+    };
+}
+/** No renderer normalization, generated metadata, or implicit trailing newline. */
+export function renderKnowledgeVaultMarkdown(input) {
+    return decodeKnowledgeVaultMarkdown(input.prefix + input.body);
+}
+/** Change one property without reserializing unrelated YAML or the Markdown body. */
+export function setKnowledgeVaultProperty(input, key, value) {
+    if (!key ||
+        /[\x00-\x1f\x7f]/u.test(key) ||
+        ["__proto__", "constructor", "prototype"].includes(key)) {
+        throw invalid("A valid frontmatter property name is required.");
+    }
+    let json;
+    try {
+        json = JSON.stringify(value);
+    }
+    catch {
+        throw invalid("Frontmatter value must be JSON-compatible.");
+    }
+    if (json === undefined)
+        throw invalid("Frontmatter value must be JSON-compatible.");
+    const full = renderKnowledgeVaultMarkdown(input);
+    const parsed = parseKnowledgeVaultMarkdown(full);
+    if (parsed.frontmatterError)
+        throw invalid("Fix invalid YAML frontmatter before editing its properties.");
+    const split = splitPrefix(full);
+    const newline = input.prefix.includes("\r\n") || input.body.includes("\r\n")
+        ? "\r\n"
+        : "\n";
+    const line = stringify({ [key]: JSON.parse(json) }).replace(/\n/g, newline);
+    if (split.yaml === null) {
+        const prefix = `${split.prefix}---${newline}${line}---${newline}`;
+        return { prefix, body: split.body };
+    }
+    const doc = parseDocument(split.yaml, {
+        keepSourceTokens: true,
+        uniqueKeys: true,
+    });
+    if (!isMap(doc.contents) && doc.contents !== null)
+        throw invalid("Frontmatter must be a YAML mapping.");
+    const pair = isMap(doc.contents)
+        ? doc.contents.items.find((entry) => String(entry.key) === key)
+        : undefined;
+    if (pair) {
+        const range = pair.value
+            ?.range;
+        if (!range)
+            throw invalid("This empty YAML value must be edited in the Markdown source.");
+        const start = split.yamlOffset + range[0];
+        const end = split.yamlOffset + range[1];
+        const old = split.prefix.slice(start, end);
+        const replacement = (split.prefix[start - 1] === ":" ? " " : "") +
+            json +
+            (split.prefix[end] === "#" ? " " : "") +
+            (old.endsWith("\n") ? newline : "");
+        return {
+            prefix: split.prefix.slice(0, start) + replacement + split.prefix.slice(end),
+            body: split.body,
+        };
+    }
+    const insertion = split.yamlOffset + split.yaml.length;
+    return {
+        prefix: split.prefix.slice(0, insertion) + line + split.prefix.slice(insertion),
+        body: split.body,
+    };
+}

package/node_modules/@oxygen/shared/dist/langfuse.d.ts

@@ -38,6 +38,8 @@ export type LlmSpanBody = {
     userId?: string | null;
 };
 export type LlmGenerationBody = LlmSpanBody & {
+    /** Persist this physical id when a later annotation must target this attempt. */
+    observationId?: string;
     model?: string | null;
     modelParameters?: Record<string, unknown>;
     completionStartTime?: Date | null;
@@ -63,9 +65,11 @@ export type LlmEventBody = {
  * because that variant requires a *string* value. Widening later stays additive.
  */
 export type LlmScoreBody = {
-    /** Deterministic id upserts; omit for a new score each call. */
+    /** Retry-safe scores need the same id, name AND timestamp on every attempt. */
     id?: string;
     traceId: string;
+    observationId?: string;
+    timestamp?: Date;
     name: string;
     value: number;
     dataType?: "BOOLEAN" | "NUMERIC";
@@ -103,6 +107,13 @@ export type LlmTracingClient = {
  */
 export declare function isLlmTracingEnabled(env?: EnvMap): boolean;
 export declare function resolveLlmTracingEnvironment(env?: EnvMap): string;
+/**
+ * The private Langfuse provider must identify its own runtime rather than
+ * inherit the process-wide OTel resource. Fly identity wins because it is
+ * injected per machine and cannot drift; a local CLI/test process is neither
+ * the web app nor the worker.
+ */
+export declare function resolveLlmTracingServiceName(env?: EnvMap): string;
 /**
  * Deterministic Langfuse trace id for an external seed (copilot turn id, agent
  * run id, AI-column run id).

package/node_modules/@oxygen/shared/dist/langfuse.js

@@ -32,7 +32,7 @@
 //   * Trace-level input/output is deprecated in v5. Overall IO goes on the ROOT
 //     observation instead; setTraceIO()/setActiveTraceIO() are deliberately not
 //     used here.
-import { createHash, randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { OXYGEN_VERSION } from "./version.js";
 import { prepareLlmPayload } from "./llm-payload.js";
 import { log } from "./log.js";
@@ -83,6 +83,23 @@ export function resolveLlmTracingEnvironment(env = process.env) {
         return flyEnv === "production" ? "production" : "development";
     return "development";
 }
+/**
+ * The private Langfuse provider must identify its own runtime rather than
+ * inherit the process-wide OTel resource. Fly identity wins because it is
+ * injected per machine and cannot drift; a local CLI/test process is neither
+ * the web app nor the worker.
+ */
+export function resolveLlmTracingServiceName(env = process.env) {
+    const flyApp = env.FLY_APP_NAME?.trim() || env.FLY_APP?.trim();
+    if (flyApp)
+        return flyApp.includes("-dev") ? "oxygen-worker-dev" : "oxygen-worker";
+    const flyEnvironment = env.FLY_ENVIRONMENT?.trim().toLowerCase();
+    if (flyEnvironment)
+        return flyEnvironment === "production" ? "oxygen-worker" : "oxygen-worker-dev";
+    if (env.VERCEL?.trim() || env.VERCEL_ENV?.trim())
+        return "oxygen-web";
+    return "oxygen-local";
+}
 /**
  * Deterministic Langfuse trace id for an external seed (copilot turn id, agent
  * run id, AI-column run id).
@@ -140,8 +157,9 @@ function createOtelEmitter(env, warn) {
     const init = () => {
         handle ??= (async () => {
             try {
-                const [{ LangfuseSpanProcessor }, { BasicTracerProvider, AlwaysOnSampler }, tracing, otel, core] = await Promise.all([
+                const [{ LangfuseSpanProcessor }, { BasicTracerProvider, AlwaysOnSampler }, { resourceFromAttributes }, tracing, otel, core] = await Promise.all([
                     import("@langfuse/otel"), import("@opentelemetry/sdk-trace-base"),
+                    import("@opentelemetry/resources"),
                     import("@langfuse/tracing"), import("@opentelemetry/api"), import("@langfuse/core"),
                 ]);
                 const processor = new LangfuseSpanProcessor({
@@ -160,6 +178,11 @@ function createOtelEmitter(env, warn) {
                 });
                 let identity;
                 const provider = new BasicTracerProvider({
+                    // This provider is deliberately isolated from the application's
+                    // global OTel pipeline, so it also needs its own explicit resource.
+                    // Never trust OTEL_SERVICE_NAME here: a cross-environment Doppler
+                    // value must not relabel prompt-bearing Langfuse observations.
+                    resource: resourceFromAttributes({ "service.name": resolveLlmTracingServiceName(env) }),
                     spanProcessors: [{
                             onStart: (span) => {
                                 // Directly pass the private parent claim to the processor. A
@@ -266,7 +289,7 @@ function createApiScorer(env, warn) {
                     username: env.LANGFUSE_PUBLIC_KEY,
                     password: env.LANGFUSE_SECRET_KEY,
                 });
-                return client.scores;
+                return client;
             }
             catch (error) {
                 warn(error, { stage: "score_init" });
@@ -281,15 +304,31 @@ function createApiScorer(env, warn) {
                 const api = await init();
                 if (!api)
                     return false;
-                await api.create(compact({
-                    id: body.id,
+                const payload = {
+                    ...(body.id ? { id: body.id } : {}),
                     traceId: body.traceId,
+                    ...(body.observationId ? { observationId: body.observationId } : {}),
                     name: body.name,
                     value: body.value,
-                    dataType: body.dataType,
-                    comment: typeof body.comment === "string" ? boundComment(body.comment) : undefined,
+                    ...(body.dataType ? { dataType: body.dataType } : {}),
+                    ...(typeof body.comment === "string" ? { comment: boundComment(body.comment) } : {}),
                     environment: resolveLlmTracingEnvironment(env),
-                }));
+                };
+                const requestOptions = { timeoutInSeconds: 5, maxRetries: 0 };
+                if (body.timestamp) {
+                    // POST /scores cannot carry a timestamp. Score ingestion remains
+                    // supported in v4 (unlike trace/observation ingestion) and preserves
+                    // the date component of the score's deduplication identity.
+                    if (!body.id || !Number.isFinite(body.timestamp.getTime()))
+                        return false;
+                    const eventId = randomUUID();
+                    const result = await api.ingestion.batch({ batch: [{
+                                type: "score-create", id: eventId, timestamp: body.timestamp.toISOString(), body: payload,
+                            }] }, requestOptions);
+                    // A 207 is transport success even if the event was rejected.
+                    return result.errors.length === 0 && result.successes.some((event) => event.id === eventId && event.status >= 200 && event.status < 300);
+                }
+                await api.scores.create(payload, requestOptions);
                 return true;
             }
             catch (error) {
@@ -398,6 +437,7 @@ export function createLlmTracingClient(env = process.env, options) {
         emitter.emit({
             kind,
             traceSeed: body.traceId,
+            ...(body.observationId ? { observationId: body.observationId } : {}),
             name: body.name,
             attributes: compact({
                 input: body.input,

package/node_modules/@oxygen/shared/dist/mailbox-import.d.ts

@@ -8,6 +8,16 @@ export type NormalizedMailboxImportRow = {
     infrastructure_platform?: "google_workspace" | "microsoft_365" | "microsoft_azure";
     tenant_id?: string;
     app_password?: string;
+    /**
+     * WHO the inbox sends as (v1.954.0 — an inbox always belongs to a sender).
+     * Non-secret identity, so it rides the same whitelist as the address: a vendor
+     * export that already knows the person spares the customer a guessed profile
+     * named from the address local part.
+     */
+    first_name?: string;
+    last_name?: string;
+    display_name?: string;
+    sender_profile_id?: string;
 };
 export type MailboxImportValidationSummary = {
     valid: true;