@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/brand/review/format-json.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildJsonReport = void 0;
+const outcomes_1 = require("./outcomes");
+/**
+ * Aggregated JSON payload for a batch review run. Order matches the
+ * input order; `kind: "error"` entries preserve the per-file failure
+ * message so consumers don't have to cross-reference exit codes.
+ *
+ * `raw` server fields from each `BrandReviewResult` are intentionally
+ * dropped here — they're useful for ad-hoc inspection but bloat the
+ * payload and aren't part of the stable contract.
+ */
+const buildJsonReport = (outcomes, threshold) => ({
+    schemaVersion: 1,
+    threshold,
+    summary: (0, outcomes_1.summarizeOutcomes)(outcomes, threshold),
+    results: outcomes.map((outcome) => {
+        if (outcome.kind === "error") {
+            return { kind: "error", label: outcome.label, message: outcome.message };
+        }
+        return {
+            kind: "ok",
+            label: outcome.label,
+            overallScore: outcome.result.overallScore,
+            sectionResults: outcome.result.sectionResults.map((section) => ({
+                section: section.section,
+                field: section.field,
+                score: section.score,
+                explanation: section.explanation,
+                suggestions: section.suggestions,
+            })),
+        };
+    }),
+});
+exports.buildJsonReport = buildJsonReport;

package/dist/brand/review/format-sarif.d.ts

@@ -0,0 +1,64 @@
+import type { BrandReviewScore } from "../api/types";
+import { type ReviewOutcome } from "./outcomes";
+/**
+ * Minimal SARIF 2.1.0 representation for a batch brand review.
+ * GitHub's SARIF uploader (`github/codeql-action/upload-sarif`) tolerates
+ * extra fields and missing optional ones, so the shape here keeps to
+ * the fields that drive PR annotations: `ruleId`, `level`, `message`,
+ * and a `physicalLocation` pointing at the source file.
+ *
+ * Threshold filtering: if `threshold` is provided, only section
+ * results whose score is strictly less than the threshold become
+ * SARIF entries. When unset, scores of 4 and 5 are omitted (well-
+ * aligned content shouldn't fill PRs with noise) — scores 1–3 are
+ * always emitted as findings.
+ *
+ * Per-file errors (API failures) are emitted as a synthetic
+ * `brand/api-error` rule so consumers don't have to cross-reference
+ * the SARIF run with the CLI exit log.
+ */
+export interface SarifReport {
+    version: "2.1.0";
+    $schema: string;
+    runs: SarifRun[];
+}
+interface SarifRun {
+    tool: {
+        driver: SarifDriver;
+    };
+    results: SarifResult[];
+}
+interface SarifDriver {
+    name: string;
+    version: string;
+    informationUri?: string;
+    rules: SarifRule[];
+}
+interface SarifRule {
+    id: string;
+    shortDescription: {
+        text: string;
+    };
+    fullDescription?: {
+        text: string;
+    };
+    help?: {
+        text: string;
+    };
+}
+interface SarifResult {
+    ruleId: string;
+    level: "error" | "warning" | "note";
+    message: {
+        text: string;
+    };
+    locations: Array<{
+        physicalLocation: {
+            artifactLocation: {
+                uri: string;
+            };
+        };
+    }>;
+}
+export declare const buildSarifReport: (outcomes: readonly ReviewOutcome[], threshold: BrandReviewScore | undefined, driverVersion: string) => SarifReport;
+export {};

package/dist/brand/review/format-sarif.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSarifReport = void 0;
+const outcomes_1 = require("./outcomes");
+const DRIVER_NAME = "scai-brand-review";
+const DRIVER_INFO_URI = "https://github.com/sitecore-studio-labs/sitecoreai-cli";
+const SARIF_SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json";
+const sectionRuleId = (section) => {
+    const base = section.section.replace(/\s+/g, "-").toLowerCase();
+    const field = section.field ? `/${section.field.replace(/\s+/g, "-").toLowerCase()}` : "";
+    return `brand/${base}${field}`;
+};
+const sectionMessage = (section, label) => {
+    const base = `[${label}] ${section.section}${section.field ? ` / ${section.field}` : ""}: score ${section.score}/5`;
+    const explanation = section.explanation ? ` — ${section.explanation}` : "";
+    const suggestions = section.suggestions && section.suggestions.length > 0
+        ? `\nSuggestions:\n  - ${section.suggestions.join("\n  - ")}`
+        : "";
+    return `${base}${explanation}${suggestions}`;
+};
+const shouldEmit = (score, threshold) => {
+    if (threshold !== undefined) {
+        return score < threshold;
+    }
+    return score <= 3;
+};
+const buildSarifReport = (outcomes, threshold, driverVersion) => {
+    const results = [];
+    const ruleMap = new Map();
+    const addRule = (id, shortText) => {
+        if (!ruleMap.has(id)) {
+            ruleMap.set(id, { id, shortDescription: { text: shortText } });
+        }
+    };
+    for (const outcome of outcomes) {
+        if (outcome.kind === "error") {
+            addRule("brand/api-error", "Brand Review API call failed for this file");
+            results.push({
+                ruleId: "brand/api-error",
+                level: "error",
+                message: { text: outcome.message },
+                locations: [{ physicalLocation: { artifactLocation: { uri: outcome.label } } }],
+            });
+            continue;
+        }
+        for (const section of outcome.result.sectionResults) {
+            if (!shouldEmit(section.score, threshold))
+                continue;
+            const ruleId = sectionRuleId(section);
+            addRule(ruleId, `Brand compliance: ${section.section}${section.field ? ` / ${section.field}` : ""}`);
+            results.push({
+                ruleId,
+                level: (0, outcomes_1.scoreToSarifLevel)(section.score),
+                message: { text: sectionMessage(section, outcome.label) },
+                locations: [{ physicalLocation: { artifactLocation: { uri: outcome.label } } }],
+            });
+        }
+    }
+    return {
+        version: "2.1.0",
+        $schema: SARIF_SCHEMA,
+        runs: [
+            {
+                tool: {
+                    driver: {
+                        name: DRIVER_NAME,
+                        version: driverVersion,
+                        informationUri: DRIVER_INFO_URI,
+                        rules: Array.from(ruleMap.values()),
+                    },
+                },
+                results,
+            },
+        ],
+    };
+};
+exports.buildSarifReport = buildSarifReport;

package/dist/brand/review/format-text.d.ts

@@ -0,0 +1,24 @@
+import type { BrandReviewScore } from "../api/types";
+import { type OutcomeSummary, type ReviewOutcome } from "./outcomes";
+/**
+ * Compact, human-readable row for one outcome — emitted as each file
+ * completes so operators see progress on long batch runs. The CLI
+ * pipes this through its `Logger` so respects `--quiet` / `--json`.
+ *
+ *   ok    content/about.md          4/5   [Tone:4 Context:5]
+ *   FAIL  content/landing.md        2/5   [Tone:2 Context:3 Voice:1]
+ *   ERROR content/broken.md         (API error: token expired)
+ */
+export declare const formatTextRow: (outcome: ReviewOutcome, threshold: BrandReviewScore | undefined) => string;
+/**
+ * End-of-run summary line. One verdict the operator can scan; the
+ * detail rows above contextualize.
+ */
+export declare const formatTextSummary: (summary: OutcomeSummary, threshold: BrandReviewScore | undefined) => string;
+/**
+ * Build a multi-line text report for non-streaming callers (e.g.
+ * `--output report.txt`). The CLI normally streams rows as files
+ * complete, but a fully-buffered report is useful for tests and
+ * artifact uploads.
+ */
+export declare const buildTextReport: (outcomes: readonly ReviewOutcome[], threshold: BrandReviewScore | undefined) => string;

package/dist/brand/review/format-text.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTextReport = exports.formatTextSummary = exports.formatTextRow = void 0;
+const outcomes_1 = require("./outcomes");
+/**
+ * Compact, human-readable row for one outcome — emitted as each file
+ * completes so operators see progress on long batch runs. The CLI
+ * pipes this through its `Logger` so respects `--quiet` / `--json`.
+ *
+ *   ok    content/about.md          4/5   [Tone:4 Context:5]
+ *   FAIL  content/landing.md        2/5   [Tone:2 Context:3 Voice:1]
+ *   ERROR content/broken.md         (API error: token expired)
+ */
+const formatTextRow = (outcome, threshold) => {
+    if (outcome.kind === "error") {
+        return `ERROR ${outcome.label}  (${outcome.message})`;
+    }
+    const score = outcome.result.overallScore;
+    const status = threshold !== undefined && score < threshold ? "FAIL " : "ok   ";
+    const sections = outcome.result.sectionResults
+        .map((section) => `${section.section.split(" ")[0]}:${section.score}`)
+        .join(" ");
+    const sectionsBlock = sections ? `  [${sections}]` : "";
+    return `${status}${outcome.label}  ${score}/5${sectionsBlock}`;
+};
+exports.formatTextRow = formatTextRow;
+/**
+ * End-of-run summary line. One verdict the operator can scan; the
+ * detail rows above contextualize.
+ */
+const formatTextSummary = (summary, threshold) => {
+    const parts = [];
+    parts.push(`${summary.total} file(s)`);
+    parts.push(`${summary.passed} pass`);
+    if (threshold !== undefined) {
+        parts.push(`${summary.failed} below threshold ${threshold}`);
+    }
+    if (summary.errored > 0) {
+        parts.push(`${summary.errored} error(s)`);
+    }
+    if (summary.lowestScore !== undefined) {
+        parts.push(`lowest score: ${summary.lowestScore}/5`);
+    }
+    return parts.join("  ·  ");
+};
+exports.formatTextSummary = formatTextSummary;
+/**
+ * Build a multi-line text report for non-streaming callers (e.g.
+ * `--output report.txt`). The CLI normally streams rows as files
+ * complete, but a fully-buffered report is useful for tests and
+ * artifact uploads.
+ */
+const buildTextReport = (outcomes, threshold) => {
+    const lines = outcomes.map((outcome) => (0, exports.formatTextRow)(outcome, threshold));
+    const summary = (0, outcomes_1.summarizeOutcomes)(outcomes, threshold);
+    lines.push("");
+    lines.push((0, exports.formatTextSummary)(summary, threshold));
+    return lines.join("\n");
+};
+exports.buildTextReport = buildTextReport;

package/dist/brand/review/generate.d.ts

@@ -0,0 +1,37 @@
+import { type BrandApiClientOptions } from "../api/client";
+import { type BrandReviewInput, type BrandReviewResult, type BrandReviewScore, type BrandReviewSectionResult, type BrandReviewSelector } from "../api/types";
+import type { components as BrandReviewComponents } from "../api/schema.brand-review";
+type RawSectionReview = BrandReviewComponents["schemas"]["SectionReview"];
+type RawFieldReview = BrandReviewComponents["schemas"]["FieldReview"];
+export interface GenerateBrandReviewOptions {
+    client: BrandApiClientOptions;
+    input: BrandReviewInput;
+    selector: BrandReviewSelector;
+    signal?: AbortSignal;
+}
+/**
+ * Conservative overall-score aggregation. The API does NOT return a
+ * top-level overall score; scai derives one as the minimum across
+ * every section + field score so a CI threshold gate reacts to the
+ * worst finding rather than the average (which would hide outliers).
+ * Empty responses default to 5 (no findings → max alignment).
+ */
+declare const aggregateOverall: (sectionResults: readonly BrandReviewSectionResult[]) => BrandReviewScore;
+/**
+ * Generate a Brand Review for the given content against a brand kit.
+ *
+ * Wraps `POST /api/skills/v1/brandreview/generate`. Sync (~5s); no
+ * batching server-side. The CLI's `scai brand review --glob` is a
+ * client-side fan-out over this primitive (`runBrandReview` in
+ * `src/brand/tasks/review.ts`).
+ *
+ * Selector quirks worth knowing:
+ *   - `brandKitId` is sent as `brandkitId` (lowercase 'k') over the
+ *     wire — the API uses the lowercase spelling.
+ *   - `sections` are objects with UUID `sectionId` + optional
+ *     `fieldIds`, not section name strings. Name → UUID lookup lands
+ *     when the Brand Management read primitives ship.
+ */
+export declare const generateBrandReview: (options: GenerateBrandReviewOptions) => Promise<BrandReviewResult>;
+export { aggregateOverall as _aggregateOverall };
+export type { RawSectionReview, RawFieldReview };

package/dist/brand/review/generate.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._aggregateOverall = exports.generateBrandReview = void 0;
+const client_1 = require("../api/client");
+const types_1 = require("../api/types");
+const clampScore = (value) => {
+    if (typeof value !== "number" || Number.isNaN(value)) {
+        return 1;
+    }
+    const rounded = Math.round(value);
+    if (rounded <= 1)
+        return 1;
+    if (rounded >= 5)
+        return 5;
+    return rounded;
+};
+/**
+ * Build the API's `input` map from scai's caller-facing input shape.
+ *
+ * The Brand Review API documents a `{ content: "raw text" }` shape
+ * for plain text, but the real server crashes with a 500 KeyError on
+ * `'name'` when given a bare string — verified empirically against a
+ * Sitecore tenant 2026-05-14. Every working example in the OpenAPI
+ * spec uses the `ExtractableFile` shape (document, image, files[]),
+ * all of which carry a `name` field. So scai sends text via the same
+ * shape: an `ExtractableFile` with `type: "document"`, `mimeType:
+ * "text/plain"`, and a base64-encoded data URL carrying the content.
+ * The caller's `label` becomes the file name.
+ *
+ * Callers can still layer arbitrary additional `input.*` keys via
+ * `input.extra` for advanced cases (real file references, images,
+ * etc.) without going through this wrapper.
+ */
+const buildApiInput = (input) => {
+    const result = { ...(input.extra ?? {}) };
+    if (input.text !== undefined) {
+        const base64 = Buffer.from(input.text, "utf8").toString("base64");
+        // Use the `document` key — every working example in the OpenAPI
+        // spec puts an ExtractableFile under `document`, `image`, or
+        // `files`. The `content` key only appears in the bare-text
+        // example, which the server crashes on (500 'name'). Pick a key
+        // the server is known to accept.
+        result.document = {
+            name: input.label ?? "input.txt",
+            type: "document",
+            mimeType: "text/plain",
+            url: `data:text/plain;base64,${base64}`,
+            // Required per the OpenAPI spec even though the docs claim it
+            // defaults to "auto" — generated type has no `?`. Server 500s
+            // with `'name'` when this field is absent (the error is
+            // misleading; it's not actually about the name field).
+            detail: "auto",
+        };
+    }
+    return result;
+};
+/**
+ * Flatten the API's `{ reviews: [{ sectionId, score, fields: [...] }] }`
+ * into scai's `BrandReviewSectionResult[]`. Section-level entries
+ * come first, then field-level entries within each section. The
+ * field-level rows carry their own scores so formatters (SARIF
+ * especially) can drive per-field findings without consumers
+ * walking the nested structure.
+ *
+ * The API exposes a singular `suggestion` string per section/field;
+ * we wrap it in an array for forward compatibility with the
+ * documented "improvement suggestions" plural — once Sitecore makes
+ * that a list, no breaking change on scai's side.
+ */
+const flattenSectionReview = (review) => {
+    const rows = [];
+    rows.push({
+        section: review.sectionId ?? "(unknown)",
+        score: clampScore(review.score),
+        explanation: review.reason,
+        suggestions: review.suggestion ? [review.suggestion] : undefined,
+    });
+    for (const field of review.fields ?? []) {
+        rows.push({
+            section: review.sectionId ?? "(unknown)",
+            field: field.fieldId,
+            score: clampScore(field.score),
+            explanation: field.reason,
+            suggestions: field.suggestion ? [field.suggestion] : undefined,
+        });
+    }
+    return rows;
+};
+/**
+ * Conservative overall-score aggregation. The API does NOT return a
+ * top-level overall score; scai derives one as the minimum across
+ * every section + field score so a CI threshold gate reacts to the
+ * worst finding rather than the average (which would hide outliers).
+ * Empty responses default to 5 (no findings → max alignment).
+ */
+const aggregateOverall = (sectionResults) => {
+    if (sectionResults.length === 0)
+        return 5;
+    let lowest = 5;
+    for (const row of sectionResults) {
+        if (row.score < lowest) {
+            lowest = row.score;
+        }
+    }
+    return lowest;
+};
+exports._aggregateOverall = aggregateOverall;
+/**
+ * Generate a Brand Review for the given content against a brand kit.
+ *
+ * Wraps `POST /api/skills/v1/brandreview/generate`. Sync (~5s); no
+ * batching server-side. The CLI's `scai brand review --glob` is a
+ * client-side fan-out over this primitive (`runBrandReview` in
+ * `src/brand/tasks/review.ts`).
+ *
+ * Selector quirks worth knowing:
+ *   - `brandKitId` is sent as `brandkitId` (lowercase 'k') over the
+ *     wire — the API uses the lowercase spelling.
+ *   - `sections` are objects with UUID `sectionId` + optional
+ *     `fieldIds`, not section name strings. Name → UUID lookup lands
+ *     when the Brand Management read primitives ship.
+ */
+const generateBrandReview = async (options) => {
+    const body = {
+        brandkitId: options.selector.brandKitId,
+        input: buildApiInput(options.input),
+        sections: options.selector.sections?.length ? options.selector.sections : undefined,
+    };
+    const response = await (0, client_1.requestBrandApi)(options.client, {
+        basePath: types_1.BRAND_REVIEW_BASE_PATH,
+        path: "/api/skills/v1/brandreview/generate",
+        method: "POST",
+        body,
+        signal: options.signal,
+    });
+    const sectionResults = [];
+    for (const review of response.reviews ?? []) {
+        sectionResults.push(...flattenSectionReview(review));
+    }
+    return {
+        overallScore: aggregateOverall(sectionResults),
+        sectionResults,
+        raw: response,
+    };
+};
+exports.generateBrandReview = generateBrandReview;

package/dist/brand/review/outcomes.d.ts

@@ -0,0 +1,43 @@
+import type { BrandReviewResult, BrandReviewScore } from "../api/types";
+/**
+ * One file's outcome from a batch review run. Per-item independence
+ * is important — a single API failure must not lose the results of
+ * peer files in the batch (see `failFast` for opt-in stop-on-error).
+ */
+export type ReviewOutcome = {
+    kind: "ok";
+    /** Caller-supplied label (file path for CLI, free-form for SDK). */
+    label: string;
+    result: BrandReviewResult;
+} | {
+    kind: "error";
+    label: string;
+    /** Human-readable message; full ScaiError fields are preserved on `cause`. */
+    message: string;
+    cause?: unknown;
+};
+/**
+ * Map a 1–5 score to a SARIF severity level. The breakpoints map to
+ * the documented brand-compliance domain:
+ *
+ *   1, 2  → error    (poor alignment; CI gate fail by default)
+ *   3     → warning  (acceptable but suggests improvement)
+ *   4, 5  → note     (well-aligned; emitted only for traceability)
+ */
+export declare const scoreToSarifLevel: (score: BrandReviewScore) => "error" | "warning" | "note";
+/** Per-outcome summary used by every formatter for traversal. */
+export interface OutcomeSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    errored: number;
+    belowThreshold: number;
+    lowestScore?: BrandReviewScore;
+}
+/**
+ * Compute the summary statistics over a batch. `threshold` is the
+ * 1–5 minimum acceptable score; an undefined threshold disables the
+ * `belowThreshold` count (it stays 0). Per-API errors are counted
+ * separately from scoring.
+ */
+export declare const summarizeOutcomes: (outcomes: readonly ReviewOutcome[], threshold?: BrandReviewScore) => OutcomeSummary;

package/dist/brand/review/outcomes.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeOutcomes = exports.scoreToSarifLevel = void 0;
+/**
+ * Map a 1–5 score to a SARIF severity level. The breakpoints map to
+ * the documented brand-compliance domain:
+ *
+ *   1, 2  → error    (poor alignment; CI gate fail by default)
+ *   3     → warning  (acceptable but suggests improvement)
+ *   4, 5  → note     (well-aligned; emitted only for traceability)
+ */
+const scoreToSarifLevel = (score) => {
+    if (score <= 2)
+        return "error";
+    if (score === 3)
+        return "warning";
+    return "note";
+};
+exports.scoreToSarifLevel = scoreToSarifLevel;
+/**
+ * Compute the summary statistics over a batch. `threshold` is the
+ * 1–5 minimum acceptable score; an undefined threshold disables the
+ * `belowThreshold` count (it stays 0). Per-API errors are counted
+ * separately from scoring.
+ */
+const summarizeOutcomes = (outcomes, threshold) => {
+    let passed = 0;
+    let failed = 0;
+    let errored = 0;
+    let belowThreshold = 0;
+    let lowestScore;
+    for (const outcome of outcomes) {
+        if (outcome.kind === "error") {
+            errored += 1;
+            continue;
+        }
+        const score = outcome.result.overallScore;
+        if (lowestScore === undefined || score < lowestScore) {
+            lowestScore = score;
+        }
+        if (threshold !== undefined && score < threshold) {
+            belowThreshold += 1;
+            failed += 1;
+        }
+        else {
+            passed += 1;
+        }
+    }
+    return {
+        total: outcomes.length,
+        passed,
+        failed,
+        errored,
+        belowThreshold,
+        lowestScore,
+    };
+};
+exports.summarizeOutcomes = summarizeOutcomes;

package/dist/brand/seed.d.ts

@@ -0,0 +1,81 @@
+import type { BrandApiClientOptions } from "./api/client";
+import { type BrandKitSectionSummary } from "./kits/sections";
+import { type UploadDocumentSource, type UploadedDocument } from "./documents/upload";
+import type { BrandKitSummary } from "./kits/list";
+/**
+ * Stage labels emitted via `onProgress`. Useful for callers that
+ * surface progress (CLI streaming output, MCP progress events).
+ */
+export type SeedStage = "createKit" | "uploadDocument" | "publishKit" | "runIngestion" | "runEnrichment" | "pollSections" | "done";
+export interface SeedProgressEvent {
+    stage: SeedStage;
+    /** Wall-clock elapsed seconds since seed start. */
+    elapsedSec: number;
+    message: string;
+    /** Populated when sections exist. */
+    sectionCount?: number;
+}
+export interface SeedBrandKitOptions {
+    client: BrandApiClientOptions;
+    /** Display name + brand name for the new kit. */
+    name: string;
+    /**
+     * Single source PDF. Must be a publicly reachable URL — Sitecore
+     * fetches it server-side. Optional when `documents` is provided;
+     * exactly one of `source` / `documents` must be set.
+     */
+    source?: UploadDocumentSource | {
+        url: string;
+    };
+    /**
+     * Multiple source documents — uploaded before a single ingestion +
+     * enrichment pass. Takes precedence over `source` when non-empty.
+     */
+    documents?: {
+        url: string;
+        title?: string;
+        summary?: string;
+    }[];
+    /** Optional kit metadata. */
+    description?: string;
+    industry?: string;
+    /** Document metadata for the single-`source` path. */
+    documentTitle?: string;
+    documentSummary?: string;
+    /** Poll interval for the sections endpoint, seconds. Default 15. */
+    pollIntervalSec?: number;
+    /** Hard timeout for waiting on sections to appear, seconds. Default 900. */
+    timeoutSec?: number;
+    /** Callback for stage transitions + polling ticks. */
+    onProgress?: (event: SeedProgressEvent) => void;
+    signal?: AbortSignal;
+}
+export interface SeedBrandKitResult {
+    kit: BrandKitSummary;
+    document: UploadedDocument;
+    sections: BrandKitSectionSummary[];
+    /** Total wall-clock seconds spent. */
+    elapsedSec: number;
+}
+/**
+ * The headline composite — drive a brand kit from "doesn't exist" to
+ * "has populated sections and is ready for Brand Review" in one call.
+ *
+ * Sequence (see [[project-scai-brand-kit-seed-recipe]]):
+ *
+ *   1. createBrandKit          → draft kit
+ *   2. uploadDocument          → doc attached (status: pending)
+ *   3. publishBrandKit         → kit status: published (required!)
+ *   4. runBrandIngestionPipeline (chunks the doc)
+ *   5. runEnrichSectionsPipeline  (populates sections from chunks)
+ *   6. poll listBrandKitSections until the count goes from 0 to >0
+ *   7. return kit + doc + section list
+ *
+ * The `doc.status` going to `failed` mid-flight is misleading and
+ * NOT a real error — sections still populate via enrichment, so the
+ * composite ignores that signal and only cares about section count.
+ *
+ * Cost note: this triggers two paid AI pipeline runs. Each run takes
+ * ~5 min wall-clock. Don't loop this without consent.
+ */
+export declare const seedBrandKit: (options: SeedBrandKitOptions) => Promise<SeedBrandKitResult>;