@oxygen-agent/cli 1.936.1 → 1.982.3

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

@@ -2,28 +2,35 @@
  * Knowledge bootstrap — the once-per-workspace, automatic company research pass.
  *
  * WHAT IT IS. Exactly once in a workspace's life, OXYGEN researches the customer's
- * OWN company from the domain we already resolved at org creation
- * (control-DB `organizations.iconDomain`, `iconStatus = 'ok'`), then fills the typed
- * company profile (`ox_context.company_profile`) and writes one cited wiki page.
- * A founder who signs up should not face an empty Knowledge Graph and have to type
- * their own positioning back at us; every grounded AI action downstream (message
- * drafts, AI columns, agent runs) reads that profile, so an empty one degrades the
- * whole product's first hour.
+ * OWN company from the domain the creator typed when the workspace was created
+ * (control-DB `organizations.iconDomain`), then fills the typed company profile
+ * (`ox_context.company_profile`) and writes one cited wiki page. A founder who
+ * signs up should not face an empty Knowledge Graph and have to type their own
+ * positioning back at us; every grounded AI action downstream (message drafts, AI
+ * columns, agent runs) reads that profile, so an empty one degrades the whole
+ * product's first hour.
  *
  * WHY THIS IS NOT A VIOLATION OF THE PAID-ACTIONS RULE. `CLAUDE.md` says never run
  * paid provider actions unless the user explicitly asks. This slice is a deliberate,
- * founder-approved exception: signup IS the standing authorization, the same way an
- * armed table-webhook auto-run configuration is scoped standing permission for the
- * columns it queues. The exception is defensible ONLY because every one of the
- * following properties holds. They are load-bearing — do not drop one for
+ * founder-approved exception: naming the company at workspace creation IS the
+ * standing authorization, the same way an armed table-webhook auto-run
+ * configuration is scoped standing permission for the columns it queues — and
+ * since 2026-09-11 the pass is OXYGEN-funded, so it never draws down the
+ * customer's balance at all. The exception is defensible ONLY because every one of
+ * the following properties holds. They are load-bearing — do not drop one for
  * convenience, and if you remove one, the exception no longer stands:
  *
  *   1. CAPPED      — `KNOWLEDGE_BOOTSTRAP_MAX_CREDITS` is a hard ceiling on the whole
  *                    pass, with `KNOWLEDGE_BOOTSTRAP_ENRICHMENT_MAX_CREDITS` a tighter
- *                    sub-ceiling on the provider (external-money) half.
- *   2. CONSENTED   — it runs only for a workspace whose own domain we already derived
- *                    at signup; a personal-email signup is `skipped_personal_email`
- *                    upstream and never reaches here, so we never research a stranger.
+ *                    sub-ceiling on the provider (external-money) half. The cap bounds
+ *                    OXYGEN's own money now, and it is the same number.
+ *   2. AUTHORIZED  — it runs only for a workspace whose creator typed the company
+ *                    website into the REQUIRED field at workspace creation; that
+ *                    entry is recorded as `knowledge_bootstrap_consent` (source
+ *                    `workspace_creation`) and read FAIL-CLOSED, so a workspace that
+ *                    predates the field is never researched and a personal-email
+ *                    signup with no website never reaches the worker. We never
+ *                    research a stranger.
  *   3. JOURNALLED  — the marker below records status, timing, run id, credits and the
  *                    domain in `knowledge_state.watermarks`; the URLs read land as
  *                    immutable `page_sources` rows plus an `ingest` knowledge_log
@@ -36,33 +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 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), so the
- *                                pass can never eat a founder's trial.
- *
- *   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. */
@@ -127,6 +115,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;
@@ -164,9 +155,11 @@ export type KnowledgeBootstrapMarker = {
     linkedin_url?: string | null;
 };
 /**
- * Control-DB `organizations.metadata` key carrying the workspace's recorded consent
- * to the automatic research pass. Written once at signup by the setup surface; read
- * by the worker cycle before anything is spent.
+ * Control-DB `organizations.metadata` key carrying the workspace's recorded
+ * authorization for the automatic research pass. Written once, when the creator
+ * names the company website at workspace creation (`source: "workspace_creation"`;
+ * rows written by the retired `/setup` checkbox carry `source: "signup"` and stay
+ * valid); read by the worker cycle before anything is spent.
  *
  * It lives in shared, not in either caller, so the writer and the reader cannot
  * drift onto two different key names — a silent drift there would either deny every
@@ -176,9 +169,15 @@ 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;
     /** ISO timestamp consent was recorded. Must parse; a marker that does not is not consent. */
     granted_at: string;
-    /** Where it came from, e.g. `signup`. Informational. */
+    /**
+     * Where it came from: `workspace_creation` (the required website field on the
+     * create-workspace screen) or the retired `signup` checkbox. Informational.
+     */
     source: string | null;
     /** Clerk user who accepted, when the surface knows. Informational. */
     granted_by_clerk_user_id: string | null;
@@ -227,6 +226,14 @@ export declare const KNOWLEDGE_BOOTSTRAP_LINKEDIN_METADATA_KEY = "company_linked
  * dead and the workspace is recoverable through the product.
  */
 export declare const KNOWLEDGE_BOOTSTRAP_STUCK_AFTER_MS: number;
+/**
+ * Idempotency-key prefix for the ledger row that hands an automatic pass's
+ * credits back to the workspace (property 7 above). The key is
+ * `${prefix}:${run_id}`, so one pass is covered exactly once no matter how many
+ * times the worker revisits the outcome, and a `--force` re-run — a different
+ * run — is covered only if it was itself automatic.
+ */
+export declare const KNOWLEDGE_BOOTSTRAP_COVERAGE_IDEMPOTENCY_PREFIX = "knowledge_bootstrap_coverage";
 /**
  * The one wiki page a bootstrap authors. A stable slug is what makes a re-armed pass
  * REVISE the note rather than litter the wiki with `company-research-2`.
@@ -238,13 +245,14 @@ export declare const KNOWLEDGE_BOOTSTRAP_STUCK_AFTER_MS: number;
  */
 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"];
 /**