@oxygen-agent/cli 1.948.1 → 1.987.20

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

@@ -27,6 +27,7 @@ export * from "./crm-activity-events.js";
 export * from "./column-types.js";
 export * from "./copilot-errors.js";
 export * from "./copilot-journeys.js";
+export * from "./copilot-playbooks.js";
 export * from "./copilot-plan.js";
 export * from "./credit-guidance.js";
 export * from "./directory.js";
@@ -47,6 +48,7 @@ export * from "./knowledge-constants.js";
 export * from "./knowledge-bootstrap.js";
 export * from "./knowledge-links.js";
 export * from "./knowledge-markdown.js";
+export * from "./knowledge-vault-markdown.js";
 export * from "./knowledge-seed-content.js";
 export * from "./langfuse.js";
 export * from "./llm-usage.js";
@@ -155,3 +157,6 @@ export function isVersionLess(a, b) {
     return compareSemver(a, b) < 0;
 }
 export * from "./ugc.js";
+export * from "./ugc-amplification-identity.js";
+export * from "./knowledge-repository.js";
+export * from "./knowledge-bases.js";

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

@@ -0,0 +1,74 @@
+export type KnowledgeBaseViewType = "table" | "cards" | "kanban";
+export type KnowledgeBaseFilter = string | {
+    and?: KnowledgeBaseFilter[];
+    or?: KnowledgeBaseFilter[];
+    not?: KnowledgeBaseFilter[];
+};
+export type KnowledgeBaseIssue = {
+    code: "invalid_base" | "unsupported_filter" | "unsupported_view" | "invalid_view";
+    message: string;
+    expression?: string;
+    view?: string;
+};
+export type KnowledgeBaseProperty = {
+    displayName?: string;
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseView = {
+    type: string;
+    name: string;
+    groupBy?: {
+        property: string;
+        direction: "ASC" | "DESC";
+    };
+    order: string[];
+    boardColumns: string[];
+    cardTitleProperty?: string;
+    sort: Array<{
+        property: string;
+        direction: "ASC" | "DESC";
+    }>;
+    filters?: KnowledgeBaseFilter;
+    columnColors: Record<string, string>;
+    wipLimits: Record<string, number>;
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseDefinition = {
+    path: string;
+    name: string;
+    filters?: KnowledgeBaseFilter;
+    properties: Record<string, KnowledgeBaseProperty>;
+    views: KnowledgeBaseView[];
+    raw: Record<string, unknown>;
+};
+export type KnowledgeBaseFile = {
+    id: string;
+    path: string;
+    body?: string;
+    properties: Record<string, unknown>;
+    revision: number;
+};
+export type KnowledgeBaseParseResult = {
+    definition: KnowledgeBaseDefinition | null;
+    issues: KnowledgeBaseIssue[];
+};
+export type KnowledgeBaseEvaluation = {
+    files: KnowledgeBaseFile[];
+    issues: KnowledgeBaseIssue[];
+};
+export type KnowledgeBaseGroup = {
+    key: string;
+    title: string;
+    files: KnowledgeBaseFile[];
+};
+export declare function parseKnowledgeBase(path: string, source: string): KnowledgeBaseParseResult;
+export declare function knowledgeBasePropertyKey(property: string): string;
+export declare function knowledgeBasePropertyValue(file: KnowledgeBaseFile, property: string): unknown;
+export declare function knowledgeBasePropertyText(file: KnowledgeBaseFile, property: string): string;
+export declare function evaluateKnowledgeBaseView(definition: KnowledgeBaseDefinition, view: KnowledgeBaseView, files: readonly KnowledgeBaseFile[]): KnowledgeBaseEvaluation;
+export declare function knowledgeBaseGroups(view: KnowledgeBaseView, files: readonly KnowledgeBaseFile[], configuredColumns?: readonly string[]): KnowledgeBaseGroup[];
+export declare function knowledgeBaseDisplayName(definition: KnowledgeBaseDefinition, property: string): string;
+export declare function knowledgeBaseCardTitle(file: KnowledgeBaseFile, view: KnowledgeBaseView): string;
+export declare function parseBaseBoardColumnOrder(value: unknown): Record<string, string[]>;
+/** Resolve Base Board's `<folder>::<view>::<property>` lane order, with view-name shorthand for API callers. */
+export declare function resolveBaseBoardColumnOrder(definition: KnowledgeBaseDefinition, view: KnowledgeBaseView, configured: Readonly<Record<string, readonly string[]>>): string[];

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

@@ -0,0 +1,456 @@
+import { parseDocument } from "yaml";
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function strings(value) {
+    return Array.isArray(value)
+        ? value
+            .filter((item) => typeof item === "string" && item.trim().length > 0)
+            .map((item) => item.trim())
+        : [];
+}
+function direction(value) {
+    return typeof value === "string" && value.toUpperCase() === "DESC"
+        ? "DESC"
+        : "ASC";
+}
+function filterNode(value, issues, location) {
+    if (typeof value === "string")
+        return value;
+    const source = record(value);
+    if (!source) {
+        if (value !== undefined)
+            issues.push({
+                code: "unsupported_filter",
+                message: `${location} is preserved but has an unsupported filter shape.`,
+            });
+        return undefined;
+    }
+    const result = {};
+    const knownKeys = new Set(["and", "or", "not"]);
+    for (const key of Object.keys(source)) {
+        if (!knownKeys.has(key))
+            issues.push({
+                code: "unsupported_filter",
+                message: `${location}.${key} is preserved but is not supported.`,
+            });
+    }
+    for (const key of ["and", "or", "not"]) {
+        if (source[key] === undefined)
+            continue;
+        if (!Array.isArray(source[key])) {
+            issues.push({
+                code: "unsupported_filter",
+                message: `${location}.${key} must be a list.`,
+            });
+            continue;
+        }
+        const children = source[key].flatMap((child) => {
+            const parsed = filterNode(child, issues, `${location}.${key}`);
+            return parsed === undefined ? [] : [parsed];
+        });
+        result[key] = children;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function mapRecord(value, map) {
+    const source = record(value);
+    if (!source)
+        return {};
+    return Object.fromEntries(Object.entries(source).flatMap(([key, item]) => {
+        const mapped = map(key, item);
+        return mapped === null ? [] : [[key, mapped]];
+    }));
+}
+function parseView(value, index, issues) {
+    const source = record(value);
+    if (!source) {
+        issues.push({
+            code: "invalid_view",
+            message: `View ${index + 1} is not an object.`,
+        });
+        return null;
+    }
+    const type = stringValue(source.type) ?? "table";
+    const name = stringValue(source.name) ?? `View ${index + 1}`;
+    if (!["table", "cards", "kanban"].includes(type)) {
+        issues.push({
+            code: "unsupported_view",
+            message: `The ${type} view type is preserved but cannot be rendered.`,
+            view: name,
+        });
+    }
+    const group = record(source.groupBy);
+    const groupProperty = stringValue(group?.property);
+    const view = {
+        type,
+        name,
+        order: strings(source.order),
+        boardColumns: strings(source.boardColumns),
+        sort: Array.isArray(source.sort)
+            ? source.sort.flatMap((item) => {
+                const sort = record(item);
+                const property = stringValue(sort?.property);
+                return property
+                    ? [{ property, direction: direction(sort?.direction) }]
+                    : [];
+            })
+            : [],
+        columnColors: mapRecord(source.columnColors, (_key, item) => typeof item === "string" ? item : null),
+        wipLimits: mapRecord(source.wipLimits, (_key, item) => typeof item === "number" && Number.isFinite(item) ? item : null),
+        raw: source,
+    };
+    if (groupProperty)
+        view.groupBy = {
+            property: groupProperty,
+            direction: direction(group?.direction),
+        };
+    const cardTitleProperty = stringValue(source.cardTitleProperty);
+    if (cardTitleProperty)
+        view.cardTitleProperty = cardTitleProperty;
+    const filters = filterNode(source.filters, issues, `${name}.filters`);
+    if (filters)
+        view.filters = filters;
+    return view;
+}
+export function parseKnowledgeBase(path, source) {
+    const document = parseDocument(source, { customTags: [] });
+    if (document.errors.length > 0) {
+        return {
+            definition: null,
+            issues: document.errors.map((error) => ({
+                code: "invalid_base",
+                message: error.message,
+            })),
+        };
+    }
+    let parsed;
+    try {
+        parsed = document.toJS({ maxAliasCount: 0 });
+    }
+    catch (error) {
+        return {
+            definition: null,
+            issues: [
+                {
+                    code: "invalid_base",
+                    message: error instanceof Error
+                        ? error.message
+                        : "The base document could not be decoded.",
+                },
+            ],
+        };
+    }
+    const root = record(parsed);
+    if (!root)
+        return {
+            definition: null,
+            issues: [
+                {
+                    code: "invalid_base",
+                    message: "The base document must be a YAML object.",
+                },
+            ],
+        };
+    const issues = [];
+    const views = Array.isArray(root.views)
+        ? root.views.flatMap((value, index) => {
+            const view = parseView(value, index, issues);
+            return view ? [view] : [];
+        })
+        : [];
+    const properties = mapRecord(root.properties, (_key, item) => {
+        const raw = record(item) ?? {};
+        const displayName = stringValue(raw.displayName);
+        return { ...(displayName ? { displayName } : {}), raw };
+    });
+    const name = path
+        .split("/")
+        .pop()
+        ?.replace(/\.base$/i, "") || path;
+    const definition = {
+        path,
+        name,
+        properties,
+        views,
+        raw: root,
+    };
+    const filters = filterNode(root.filters, issues, `${name}.filters`);
+    if (filters)
+        definition.filters = filters;
+    return { definition, issues };
+}
+export function knowledgeBasePropertyKey(property) {
+    return property.startsWith("note.") ? property.slice(5) : property;
+}
+function fileName(path) {
+    const name = path.split("/").pop() ?? path;
+    return name.replace(/\.[^.]+$/, "");
+}
+export function knowledgeBasePropertyValue(file, property) {
+    if (property === "file.name")
+        return fileName(file.path);
+    if (property === "file.path")
+        return file.path;
+    if (property === "file.ext")
+        return file.path.includes(".")
+            ? (file.path.split(".").pop()?.toLowerCase() ?? "")
+            : "";
+    return file.properties[knowledgeBasePropertyKey(property)];
+}
+export function knowledgeBasePropertyText(file, property) {
+    const value = knowledgeBasePropertyValue(file, property);
+    if (value == null)
+        return "";
+    if (Array.isArray(value))
+        return value.map(String).join(", ");
+    if (typeof value === "object")
+        return JSON.stringify(value);
+    return String(value);
+}
+function isEmpty(value) {
+    return (value == null ||
+        value === "" ||
+        (Array.isArray(value) && value.length === 0));
+}
+function equals(left, right) {
+    if (Array.isArray(left))
+        return left.some((item) => String(item) === right);
+    return String(left ?? "") === right;
+}
+function compare(left, right) {
+    if (typeof left === "number" && typeof right === "number")
+        return left - right;
+    const leftNumber = typeof left === "string" && left.trim() ? Number(left) : Number.NaN;
+    const rightNumber = typeof right === "string" && right.trim() ? Number(right) : Number.NaN;
+    if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber))
+        return leftNumber - rightNumber;
+    return String(left ?? "").localeCompare(String(right ?? ""), undefined, {
+        numeric: true,
+        sensitivity: "base",
+    });
+}
+function evaluatePredicate(expression, file) {
+    let match;
+    if ((match = /^file\.inFolder\(\s*"([^"]*)"\s*\)$/.exec(expression))) {
+        const folder = (match[1] ?? "").replace(/^\/+|\/+$/g, "");
+        return { matches: file.path.startsWith(`${folder}/`), supported: true };
+    }
+    if ((match = /^([\w.]+)\.(isEmpty|isNotEmpty)\(\)$/.exec(expression))) {
+        const empty = isEmpty(knowledgeBasePropertyValue(file, match[1] ?? ""));
+        return {
+            matches: match[2] === "isEmpty" ? empty : !empty,
+            supported: true,
+        };
+    }
+    if ((match = /^([\w.]+)\.contains\(\s*"([^"]*)"\s*\)$/.exec(expression))) {
+        const value = knowledgeBasePropertyValue(file, match[1] ?? "");
+        const needle = match[2] ?? "";
+        return {
+            matches: Array.isArray(value)
+                ? value.some((item) => String(item).includes(needle))
+                : String(value ?? "").includes(needle),
+            supported: true,
+        };
+    }
+    if ((match =
+        /^([\w.]+)\s*(==|!=|>=|<=|>|<)\s*(?:"([^"]*)"|(-?\d+(?:\.\d+)?))$/.exec(expression))) {
+        const value = knowledgeBasePropertyValue(file, match[1] ?? "");
+        const operand = match[3] ?? match[4] ?? "";
+        const operator = match[2];
+        if (operator === "==" || operator === "!=") {
+            const equal = equals(value, operand);
+            return { matches: operator === "==" ? equal : !equal, supported: true };
+        }
+        const numeric = Number(value);
+        const expected = Number(operand);
+        const matches = Number.isFinite(numeric) &&
+            Number.isFinite(expected) &&
+            (operator === ">="
+                ? numeric >= expected
+                : operator === "<="
+                    ? numeric <= expected
+                    : operator === ">"
+                        ? numeric > expected
+                        : numeric < expected);
+        return { matches, supported: true };
+    }
+    return { matches: true, supported: false };
+}
+function evaluateFilter(node, file, unsupported) {
+    if (node === undefined)
+        return true;
+    if (typeof node === "string") {
+        const result = evaluatePredicate(node.trim(), file);
+        if (!result.supported)
+            unsupported.add(node);
+        return result.matches;
+    }
+    if (node.and)
+        return node.and
+            .map((child) => evaluateFilter(child, file, unsupported))
+            .every(Boolean);
+    if (node.or)
+        return node.or
+            .map((child) => evaluateFilter(child, file, unsupported))
+            .some(Boolean);
+    if (node.not)
+        return !node.not
+            .map((child) => evaluateFilter(child, file, unsupported))
+            .every(Boolean);
+    return true;
+}
+function collectUnsupportedFilters(node, unsupported) {
+    if (node === undefined)
+        return;
+    if (typeof node === "string") {
+        if (!evaluatePredicate(node.trim(), {
+            id: "",
+            path: "",
+            properties: {},
+            revision: 0,
+        }).supported)
+            unsupported.add(node);
+        return;
+    }
+    for (const child of [
+        ...(node.and ?? []),
+        ...(node.or ?? []),
+        ...(node.not ?? []),
+    ]) {
+        collectUnsupportedFilters(child, unsupported);
+    }
+}
+function stableSort(files, sort, includeKanbanOrder) {
+    const rules = includeKanbanOrder
+        ? [{ property: "kanban_order", direction: "ASC" }, ...sort]
+        : sort;
+    return files
+        .map((file, index) => ({ file, index }))
+        .sort((left, right) => {
+        for (const rule of rules) {
+            const compared = compare(knowledgeBasePropertyValue(left.file, rule.property), knowledgeBasePropertyValue(right.file, rule.property));
+            if (compared !== 0)
+                return rule.direction === "DESC" ? -compared : compared;
+        }
+        return left.index - right.index;
+    })
+        .map(({ file }) => file);
+}
+export function evaluateKnowledgeBaseView(definition, view, files) {
+    const unsupported = new Set();
+    collectUnsupportedFilters(definition.filters, unsupported);
+    collectUnsupportedFilters(view.filters, unsupported);
+    const matched = files.filter((file) => evaluateFilter(definition.filters, file, unsupported) &&
+        evaluateFilter(view.filters, file, unsupported));
+    return {
+        files: stableSort(matched, view.sort, view.type === "kanban"),
+        issues: [...unsupported].map((expression) => ({
+            code: "unsupported_filter",
+            message: `This filter is preserved but is not supported: ${expression}`,
+            expression,
+            view: view.name,
+        })),
+    };
+}
+export function knowledgeBaseGroups(view, files, configuredColumns = []) {
+    const property = view.groupBy?.property;
+    if (!property)
+        return [{ key: "__all", title: view.name, files: [...files] }];
+    const groupDirection = view.groupBy?.direction ?? "ASC";
+    const discovered = [
+        ...new Set(files
+            .map((file) => knowledgeBasePropertyText(file, property).trim())
+            .filter(Boolean)),
+    ];
+    const ordered = configuredColumns.length > 0
+        ? [...configuredColumns]
+        : view.boardColumns.length > 0
+            ? [...view.boardColumns]
+            : discovered.sort((left, right) => left.localeCompare(right));
+    const configured = new Set(ordered.map((value) => value.toLowerCase()));
+    ordered.push(...discovered
+        .filter((value) => !configured.has(value.toLowerCase()))
+        .sort((left, right) => left.localeCompare(right)));
+    if (groupDirection === "DESC")
+        ordered.reverse();
+    const noValueLabels = new Set(["(no value)", "(none)", "(empty)"]);
+    const groups = ordered.map((value) => {
+        const isNoValue = noValueLabels.has(value.toLowerCase());
+        return {
+            key: isNoValue ? "__empty" : value,
+            title: value,
+            files: files.filter((file) => {
+                const current = knowledgeBasePropertyText(file, property).trim();
+                return isNoValue
+                    ? !current
+                    : current.toLowerCase() === value.toLowerCase();
+            }),
+        };
+    });
+    const known = new Set(ordered
+        .filter((value) => !noValueLabels.has(value.toLowerCase()))
+        .map((value) => value.toLowerCase()));
+    const hasEmptyColumn = ordered.some((value) => noValueLabels.has(value.toLowerCase()));
+    const unmatched = files.filter((file) => {
+        const current = knowledgeBasePropertyText(file, property).trim();
+        return current ? !known.has(current.toLowerCase()) : !hasEmptyColumn;
+    });
+    if (unmatched.length > 0)
+        groups.push({
+            key: "__empty",
+            title: `(No ${knowledgeBasePropertyKey(property)})`,
+            files: unmatched,
+        });
+    return groups;
+}
+export function knowledgeBaseDisplayName(definition, property) {
+    const key = knowledgeBasePropertyKey(property);
+    return (definition.properties[property]?.displayName ??
+        definition.properties[`note.${key}`]?.displayName ??
+        definition.properties[key]?.displayName ??
+        (property === "file.name" ? "Title" : key));
+}
+export function knowledgeBaseCardTitle(file, view) {
+    return (knowledgeBasePropertyText(file, view.cardTitleProperty ?? "file.name") ||
+        fileName(file.path));
+}
+export function parseBaseBoardColumnOrder(value) {
+    const root = record(value);
+    const configs = record(root?.columnConfigs);
+    if (!configs)
+        return {};
+    return mapRecord(configs, (_key, item) => {
+        const columns = strings(record(item)?.columns);
+        return columns.length > 0 ? columns : null;
+    });
+}
+function inFolderExpressions(node) {
+    if (node === undefined)
+        return [];
+    if (typeof node === "string") {
+        const match = /^file\.inFolder\(\s*"([^"]*)"\s*\)$/.exec(node.trim());
+        return match?.[1] ? [match[1].replace(/^\/+|\/+$/g, "")] : [];
+    }
+    return [...(node.and ?? []), ...(node.or ?? []), ...(node.not ?? [])].flatMap(inFolderExpressions);
+}
+/** Resolve Base Board's `<folder>::<view>::<property>` lane order, with view-name shorthand for API callers. */
+export function resolveBaseBoardColumnOrder(definition, view, configured) {
+    const property = knowledgeBasePropertyKey(view.groupBy?.property ?? "status");
+    const direct = configured[view.name];
+    if (direct)
+        return [...direct];
+    for (const folder of inFolderExpressions(definition.filters)) {
+        const exact = configured[`${folder}::${view.name}::${property}`];
+        if (exact)
+            return [...exact];
+    }
+    const suffix = `::${view.name}::${property}`;
+    const candidates = Object.entries(configured).filter(([key]) => key.endsWith(suffix));
+    return candidates.length === 1 ? [...candidates[0][1]] : [];
+}

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

@@ -43,42 +43,14 @@
  *                    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 type { HostedAiLevel } from "./hosted-ai.js";
 /** Hard ceiling on managed credits ONE workspace bootstrap may spend, all phases. */
@@ -101,6 +73,19 @@ export declare const KNOWLEDGE_BOOTSTRAP_SYNTHESIS_TIER: HostedAiLevel;
  * it is a quality/latency knob, and the credit ceilings above remain the money guard.
  */
 export declare 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 declare const KNOWLEDGE_BOOTSTRAP_PROVIDER_TIMEOUT_MS = 45000;
 /** Fleet-wide kill switch, matching OXYGEN_KNOWLEDGE_RETRIEVAL/AUTO_SOURCES_DISABLED. */
 export declare const KNOWLEDGE_BOOTSTRAP_DISABLED_ENV_VAR = "OXYGEN_KNOWLEDGE_BOOTSTRAP_DISABLED";
 /**
@@ -143,6 +128,9 @@ export declare function isKnowledgeBootstrapStatus(value: unknown): value is Kno
  * same thing.
  */
 export type KnowledgeBootstrapMarker = {
+    /** Versioned claims can recover a crash before the first dispatch checkpoint.
+     * Absence identifies legacy attempts whose dispatch history is unknown. */
+    execution_version?: 1;
     status: KnowledgeBootstrapStatus;
     /** ISO timestamp the claim was won. */
     started_at: string | null;
@@ -194,6 +182,11 @@ export type KnowledgeBootstrapMarker = {
 export declare const KNOWLEDGE_BOOTSTRAP_CONSENT_METADATA_KEY = "knowledge_bootstrap_consent";
 /** The recorded consent, exactly as stored under the key above. */
 export type KnowledgeBootstrapConsent = {
+    /** New workspace creation may authorize bounded creator-profile research. */
+    scope?: "company_and_creator";
+    domain?: string;
+    /** Canonical `/in/` profile supplied by this exact creator; never company evidence. */
+    creator_linkedin_url?: string;
     /** ISO timestamp consent was recorded. Must parse; a marker that does not is not consent. */
     granted_at: string;
     /**
@@ -267,13 +260,14 @@ export declare const KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX = "knowledg
  */
 export declare 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 declare const KNOWLEDGE_BOOTSTRAP_PROFILE_SECTIONS: readonly ["company", "offering", "icp", "market"];
 /**