@indigoai-us/hq-cli 5.128.0 → 5.130.0

package/dist/lib/report-publish.d.ts

@@ -0,0 +1,173 @@
+/** Mirrors the deploy skill's static-report guardrails. */
+export declare const REPORT_SOURCE_MAX_BYTES: number;
+export declare const REPORT_BUNDLE_MAX_BYTES: number;
+export declare const REPORT_SOURCE_MAX_FILES = 100;
+export declare const REPORT_CSP = "default-src 'none'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; connect-src 'none'; frame-src 'none'; form-action 'none'";
+export type ReportLastRun = {
+    at: string;
+    status: "running" | "succeeded" | "failed";
+    reason?: string;
+    version?: string;
+};
+export type ReportSchedule = {
+    kind: "daily" | "weekly" | "manual";
+    time: string;
+    timezone: string;
+    weekday?: number;
+};
+export type ChannelReport = {
+    reportId: string;
+    channelId: string;
+    companyUid?: string;
+    createdBy: string;
+    ownerAgentUid: string;
+    deploySlug: string;
+    state: "draft-pending" | "draft-ready" | "live" | "decommissioned";
+    instructions: string;
+    revision: number;
+    deployAppId?: string;
+    url?: string;
+    draft?: {
+        url: string;
+        appId: string;
+        generatedAt: string;
+        note?: string;
+    };
+    lastRun?: ReportLastRun;
+    jobId?: string;
+    jobState?: "pending" | "adopted" | "failed";
+    jobStateReason?: string;
+    schedule?: ReportSchedule;
+};
+export type ReportPatch = Partial<Pick<ChannelReport, "deployAppId" | "url" | "state" | "lastRun">> & {
+    previewImage?: string;
+    previewTitle?: string;
+    jobState?: "pending" | "adopted" | "failed";
+    jobStateReason?: string | null;
+    /** Null clears the live draft pointer or the adopted job id. */
+    draft?: ChannelReport["draft"] | null;
+    jobId?: string | null;
+};
+export type DeployOrgContext = {
+    headers: Record<string, string>;
+    org?: string;
+};
+export type StaticFile = {
+    path: string;
+    content: string;
+    encoding?: "utf8" | "base64";
+};
+export type ReportSource = {
+    files: StaticFile[];
+    previewTitle?: string;
+    previewImage?: string;
+};
+export type DeployAccessPolicy = {
+    mode: "company" | "selected" | "password" | "public";
+    companyUid: string;
+    users: Array<{
+        id: string;
+    }>;
+    groups: Array<{
+        id: string;
+    }>;
+    password?: string;
+};
+export type ReportDeployment = {
+    appId: string;
+    url: string;
+    deployId: string;
+};
+export interface ReportPublishDependencies {
+    patch(report: ChannelReport, patch: ReportPatch): Promise<ChannelReport>;
+    deploy(input: {
+        slug: string;
+        files: StaticFile[];
+        access: DeployAccessPolicy;
+    }): Promise<ReportDeployment>;
+    now(): string;
+    /** Owner DM for a failed run. Omitted by callers that only record lastRun. */
+    notifyOwner?(notice: {
+        to: string;
+        body: string;
+    }): Promise<void>;
+}
+/**
+ * Plain owner DM after a failed run. Suppressed for the publish lock
+ * ("already running") so a second run does not page the owner.
+ */
+export declare function ownerFailureNotice(input: {
+    code?: string | null;
+    reason: string;
+    reportUrl?: string | null;
+    ownerPersonUid: string;
+}): {
+    to: string;
+    body: string;
+} | null;
+export interface ReportAdoptDependencies {
+    createJob(input: {
+        prompt: string;
+        schedule: {
+            kind: "recurring";
+            cron: string;
+            timezone: string;
+        };
+        context: {
+            reportId: string;
+            channelId: string;
+        };
+    }): Promise<{
+        jobId: string;
+    }>;
+    cancelJob(jobId: string): Promise<void>;
+    patch(report: ChannelReport, patch: ReportPatch): Promise<ChannelReport>;
+}
+export declare class ReportPublishError extends Error {
+    readonly code: "already-running" | "source-invalid" | "deploy-failed" | "job-failed";
+    constructor(message: string, code?: "already-running" | "source-invalid" | "deploy-failed" | "job-failed");
+}
+/** A deliberately boring, token-safe failure reason stored on the report. */
+export declare function plainFailureReason(error: unknown): string;
+export declare function injectReportCsp(html: string): string;
+/** Read a deployable static report and inject its non-negotiable CSP. */
+export declare function loadReportSource(directory: string): ReportSource;
+/** Access policy defaults deliberately keep personal reports owner-only. */
+export declare function defaultAccessPolicy(report: ChannelReport): DeployAccessPolicy;
+export declare function reportDeploySlug(report: ChannelReport, draft: boolean): string;
+/** Source folder convention: `<bot workerDir>/reports/<reportId>/`. */
+export declare function conventionReportDir(reportId: string, workerDir?: string): string;
+/** Company deploys send X-Org-Slug; personal-channel reports have no company to gate on. */
+export declare function deployOrgContext(report: ChannelReport, companySlug?: string): DeployOrgContext;
+/**
+ * EventBridge Scheduler cron for the agent jobs API.
+ * Daily uses `?` on the weekday field; weekly pins the weekday and `?` on the day-of-month.
+ */
+export declare function reportJobCron(schedule: ReportSchedule): string | null;
+/** Job prompt is the stored update-report runbook with this report id filled in. */
+export declare function reportJobPrompt(reportId: string): string;
+/**
+ * Install, replace, or delete this bot's own scheduled job for a report.
+ * Jobs-API failures are recorded as jobState=failed with a plain reason.
+ */
+export declare function adoptReport(report: ChannelReport, deps: ReportAdoptDependencies): Promise<ChannelReport>;
+/**
+ * Lock, deploy, then persist a report run. Every known failure after lock
+ * acquisition writes a terminal lastRun so the 15-minute server TTL is a
+ * crash-only fallback rather than normal control flow.
+ */
+export declare function publishReport(report: ChannelReport, directory: string, draft: boolean, deps: ReportPublishDependencies): Promise<ChannelReport>;
+type BuiltTarball = {
+    bytes: Buffer;
+    sha256: string;
+    sizeBytes: number;
+};
+/** hq-deploy static payload format: index.html stays at the archive root. */
+export declare function buildReportTarball(files: StaticFile[]): BuiltTarball;
+/** Isolated test helper for creating a compliant report source. */
+export declare function makeReportFixture(html: string): {
+    directory: string;
+    cleanup: () => void;
+};
+export {};
+//# sourceMappingURL=report-publish.d.ts.map

package/dist/lib/report-publish.js

@@ -0,0 +1,381 @@
+/**
+ * Channel report publishing primitives.
+ *
+ * This module deliberately stops at the hq-deploy HTTP API. Report pages are
+ * uploaded only to its short-lived presigned URL; the CLI never receives AWS
+ * credentials and never talks to S3 directly.
+ */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { gzipSync } from "node:zlib";
+import { loadUpdateReportRunbook } from "./report-templates.js";
+/** Mirrors the deploy skill's static-report guardrails. */
+export const REPORT_SOURCE_MAX_BYTES = 25 * 1024 * 1024;
+export const REPORT_BUNDLE_MAX_BYTES = 10 * 1024 * 1024;
+export const REPORT_SOURCE_MAX_FILES = 100;
+export const REPORT_CSP = "default-src 'none'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; connect-src 'none'; frame-src 'none'; form-action 'none'";
+/**
+ * Plain owner DM after a failed run. Suppressed for the publish lock
+ * ("already running") so a second run does not page the owner.
+ */
+export function ownerFailureNotice(input) {
+    if (input.code === "already-running")
+        return null;
+    const to = input.ownerPersonUid.trim();
+    if (!to)
+        return null;
+    const reason = input.reason.replace(/\s+/g, " ").trim();
+    const link = (input.reportUrl ?? "").trim();
+    return { to, body: link ? `${reason} ${link}` : reason };
+}
+export class ReportPublishError extends Error {
+    code;
+    constructor(message, code = "deploy-failed") {
+        super(message);
+        this.code = code;
+        this.name = "ReportPublishError";
+    }
+}
+/** A deliberately boring, token-safe failure reason stored on the report. */
+export function plainFailureReason(error) {
+    if (error instanceof ReportPublishError) {
+        if (error.code === "source-invalid" || error.code === "job-failed")
+            return error.message.slice(0, 240);
+        if (error.code === "already-running")
+            return "already running";
+    }
+    return "Report publish failed. Check the report source and deploy service, then try again.";
+}
+function textOf(file) {
+    return file.encoding === "base64" ? Buffer.from(file.content, "base64") : Buffer.from(file.content, "utf8");
+}
+function isExternalUrl(value) {
+    return /^(?:https?:)?\/\//i.test(value.trim());
+}
+function cspMetaPresent(html) {
+    return /<meta\b[^>]*http-equiv\s*=\s*(?:"content-security-policy"|'content-security-policy'|content-security-policy)[^>]*>/i.test(html);
+}
+function externalScriptPresent(html) {
+    const tags = html.match(/<script\b[^>]*>/gi) ?? [];
+    return tags.some((tag) => {
+        const src = /\bsrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(tag);
+        return !!src && isExternalUrl(src[1] ?? src[2] ?? src[3] ?? "");
+    });
+}
+function crossOriginFetchPresent(html) {
+    // The static report convention permits only same-origin relative requests.
+    // Scan literals rather than attempting to execute untrusted report JS.
+    const calls = html.match(/\bfetch\s*\(\s*(?:"[^"]*"|'[^']*'|`[^`]*`)/gi) ?? [];
+    return calls.some((call) => /\bfetch\s*\(\s*(?:["'`]\s*(?:https?:)?\/\/)/i.test(call));
+}
+function activeContentBeforePolicy(html) {
+    // Meta CSP only applies to content parsed after the tag. Anything that can
+    // load or navigate before that tag is rejected, not merely moved.
+    return /<script/i.test(html)
+        || /<link/i.test(html)
+        || /<iframe/i.test(html)
+        || /<object/i.test(html)
+        || /<meta\b[^>]*http-equiv\s*=\s*(?:"refresh"|'refresh'|refresh\b)/i.test(html);
+}
+export function injectReportCsp(html) {
+    if (cspMetaPresent(html)) {
+        throw new ReportPublishError("Report index.html already declares a Content-Security-Policy.", "source-invalid");
+    }
+    if (externalScriptPresent(html)) {
+        throw new ReportPublishError("Report index.html references an external script.", "source-invalid");
+    }
+    if (crossOriginFetchPresent(html)) {
+        throw new ReportPublishError("Report index.html fetches another origin.", "source-invalid");
+    }
+    const meta = `<meta http-equiv="Content-Security-Policy" content="${REPORT_CSP}">`;
+    const headOpen = /<head\b[^>]*>/i.exec(html);
+    if (headOpen?.index !== undefined) {
+        const at = headOpen.index + headOpen[0].length;
+        if (activeContentBeforePolicy(html.slice(0, at))) {
+            throw new ReportPublishError("Report index.html has active content before the Content-Security-Policy.", "source-invalid");
+        }
+        return `${html.slice(0, at)}${meta}${html.slice(at)}`;
+    }
+    const htmlOpen = /<html\b[^>]*>/i.exec(html);
+    if (htmlOpen?.index !== undefined) {
+        const at = htmlOpen.index + htmlOpen[0].length;
+        if (activeContentBeforePolicy(html.slice(0, at))) {
+            throw new ReportPublishError("Report index.html has active content before the Content-Security-Policy.", "source-invalid");
+        }
+        return `${html.slice(0, at)}<head>${meta}</head>${html.slice(at)}`;
+    }
+    return `<!doctype html><html><head>${meta}</head><body>${html}</body></html>`;
+}
+function safeRelativeFile(root, absolute) {
+    const relative = path.relative(root, absolute).split(path.sep).join("/");
+    if (!relative || relative.startsWith("../") || path.isAbsolute(relative)) {
+        throw new ReportPublishError("Report source contains a path outside its directory.", "source-invalid");
+    }
+    return relative;
+}
+function readTree(root, cursor = root, found = [], total = { bytes: 0 }) {
+    for (const entry of fs.readdirSync(cursor, { withFileTypes: true })) {
+        if (entry.name === ".DS_Store" || entry.name === ".git")
+            continue;
+        const absolute = path.join(cursor, entry.name);
+        if (entry.isSymbolicLink())
+            throw new ReportPublishError("Report source cannot include symlinks.", "source-invalid");
+        if (entry.isDirectory()) {
+            readTree(root, absolute, found, total);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (found.length >= REPORT_SOURCE_MAX_FILES) {
+            throw new ReportPublishError(`Report source exceeds ${REPORT_SOURCE_MAX_FILES} files.`, "source-invalid");
+        }
+        const bytes = fs.readFileSync(absolute);
+        total.bytes += bytes.byteLength;
+        if (total.bytes > REPORT_SOURCE_MAX_BYTES) {
+            throw new ReportPublishError("Report source exceeds the 25 MB staging limit.", "source-invalid");
+        }
+        found.push({ path: safeRelativeFile(root, absolute), content: bytes.toString("base64"), encoding: "base64" });
+    }
+    return found;
+}
+function htmlTitle(html) {
+    const match = /<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+    const title = match?.[1]?.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+    return title || undefined;
+}
+function localPreviewImage(html) {
+    const meta = /<meta\b[^>]*(?:property|name)\s*=\s*(?:"og:image"|'og:image'|og:image)[^>]*content\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(html)
+        ?? /<meta\b[^>]*content\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))[^>]*(?:property|name)\s*=\s*(?:"og:image"|'og:image'|og:image)/i.exec(html);
+    const value = meta?.[1] ?? meta?.[2] ?? meta?.[3];
+    return value && !isExternalUrl(value) ? value : undefined;
+}
+/** Read a deployable static report and inject its non-negotiable CSP. */
+export function loadReportSource(directory) {
+    const root = path.resolve(directory);
+    let stat;
+    try {
+        stat = fs.statSync(root);
+    }
+    catch {
+        throw new ReportPublishError("Report source directory does not exist.", "source-invalid");
+    }
+    if (!stat.isDirectory())
+        throw new ReportPublishError("Report source must be a directory.", "source-invalid");
+    const files = readTree(root);
+    const index = files.find((file) => file.path === "index.html");
+    if (!index)
+        throw new ReportPublishError("Report source must include index.html at its root.", "source-invalid");
+    const rawHtml = textOf(index).toString("utf8");
+    const protectedHtml = injectReportCsp(rawHtml);
+    index.content = protectedHtml;
+    index.encoding = "utf8";
+    return { files, previewTitle: htmlTitle(protectedHtml), previewImage: localPreviewImage(protectedHtml) };
+}
+/** Access policy defaults deliberately keep personal reports owner-only. */
+export function defaultAccessPolicy(report) {
+    if (report.companyUid) {
+        return { mode: "company", companyUid: report.companyUid, users: [], groups: [] };
+    }
+    return { mode: "selected", companyUid: "personal", users: [{ id: report.createdBy }], groups: [] };
+}
+export function reportDeploySlug(report, draft) {
+    return draft ? `${report.deploySlug}-draft` : report.deploySlug;
+}
+/** Source folder convention: `<bot workerDir>/reports/<reportId>/`. */
+export function conventionReportDir(reportId, workerDir = process.env.HQ_BOT_WORKER_DIR ?? process.cwd()) {
+    return path.join(workerDir, "reports", reportId);
+}
+/** Company deploys send X-Org-Slug; personal-channel reports have no company to gate on. */
+export function deployOrgContext(report, companySlug) {
+    if (!report.companyUid) {
+        return { headers: { "X-HQ-Deploy-Scope": "personal" } };
+    }
+    if (!companySlug) {
+        throw new ReportPublishError("Could not resolve the report's company for deploy.");
+    }
+    return { headers: { "X-Org-Slug": companySlug }, org: companySlug };
+}
+/**
+ * EventBridge Scheduler cron for the agent jobs API.
+ * Daily uses `?` on the weekday field; weekly pins the weekday and `?` on the day-of-month.
+ */
+export function reportJobCron(schedule) {
+    if (schedule.kind === "manual")
+        return null;
+    const [hour, minute] = schedule.time.split(":");
+    if (!hour || !minute)
+        throw new ReportPublishError("Report schedule is invalid.", "source-invalid");
+    if (schedule.kind === "daily")
+        return `cron(${minute} ${hour} * * ? *)`;
+    if (schedule.weekday === undefined)
+        throw new ReportPublishError("Report schedule is invalid.", "source-invalid");
+    return `cron(${minute} ${hour} ? * ${schedule.weekday} *)`;
+}
+/** Job prompt is the stored update-report runbook with this report id filled in. */
+export function reportJobPrompt(reportId) {
+    return loadUpdateReportRunbook().split("<reportId>").join(reportId);
+}
+/**
+ * Install, replace, or delete this bot's own scheduled job for a report.
+ * Jobs-API failures are recorded as jobState=failed with a plain reason.
+ */
+export async function adoptReport(report, deps) {
+    const schedule = report.schedule;
+    if (!schedule) {
+        await deps.patch(report, {
+            jobState: "failed",
+            jobStateReason: "Report schedule is missing.",
+        });
+        throw new ReportPublishError("Report schedule is missing.", "source-invalid");
+    }
+    try {
+        if (report.jobId)
+            await deps.cancelJob(report.jobId);
+        const cron = reportJobCron(schedule);
+        if (!cron) {
+            return deps.patch(report, { jobId: null, jobState: "adopted", jobStateReason: null });
+        }
+        const created = await deps.createJob({
+            prompt: reportJobPrompt(report.reportId),
+            schedule: { kind: "recurring", cron, timezone: schedule.timezone },
+            context: { reportId: report.reportId, channelId: report.channelId },
+        });
+        return deps.patch(report, { jobId: created.jobId, jobState: "adopted", jobStateReason: null });
+    }
+    catch (error) {
+        const wrapped = error instanceof ReportPublishError ? error : new ReportPublishError("Could not install the report job.", "job-failed");
+        try {
+            await deps.patch(report, { jobState: "failed", jobStateReason: plainFailureReason(wrapped) });
+        }
+        catch {
+            // The jobs-API failure is the one the operator needs; TTL/retry covers a
+            // missing jobState write.
+        }
+        throw wrapped;
+    }
+}
+/**
+ * Lock, deploy, then persist a report run. Every known failure after lock
+ * acquisition writes a terminal lastRun so the 15-minute server TTL is a
+ * crash-only fallback rather than normal control flow.
+ */
+export async function publishReport(report, directory, draft, deps) {
+    const startedAt = deps.now();
+    let locked = false;
+    try {
+        try {
+            await deps.patch(report, { lastRun: { at: startedAt, status: "running" } });
+            locked = true;
+        }
+        catch (error) {
+            if (error instanceof ReportPublishError && error.code === "already-running")
+                throw error;
+            throw new ReportPublishError("Could not take the report run lock.");
+        }
+        const source = loadReportSource(directory);
+        const deployment = await deps.deploy({
+            slug: reportDeploySlug(report, draft),
+            files: source.files,
+            access: defaultAccessPolicy(report),
+        });
+        const completedAt = deps.now();
+        const patch = {
+            lastRun: { at: completedAt, status: "succeeded", version: deployment.deployId },
+            ...(source.previewTitle ? { previewTitle: source.previewTitle } : {}),
+            ...(source.previewImage ? { previewImage: source.previewImage } : {}),
+        };
+        if (draft) {
+            patch.state = "draft-ready";
+            patch.draft = { url: deployment.url, appId: deployment.appId, generatedAt: completedAt };
+        }
+        else {
+            patch.state = "live";
+            patch.url = deployment.url;
+            patch.deployAppId = deployment.appId;
+        }
+        return await deps.patch(report, patch);
+    }
+    catch (error) {
+        if (locked) {
+            const reason = plainFailureReason(error);
+            try {
+                await deps.patch(report, {
+                    lastRun: { at: deps.now(), status: "failed", reason },
+                });
+            }
+            catch {
+                // The original failure is more actionable. The server's lock TTL is the
+                // intended recovery path for an unavailable status PATCH.
+            }
+            const notice = ownerFailureNotice({
+                code: error instanceof ReportPublishError ? error.code : undefined,
+                reason,
+                reportUrl: report.url,
+                ownerPersonUid: report.createdBy,
+            });
+            if (notice && deps.notifyOwner) {
+                try {
+                    await deps.notifyOwner(notice);
+                }
+                catch {
+                    // The failed lastRun is the durable record. A missed DM does not
+                    // replace that error.
+                }
+            }
+        }
+        if (error instanceof ReportPublishError)
+            throw error;
+        throw new ReportPublishError(plainFailureReason(error));
+    }
+}
+/** hq-deploy static payload format: index.html stays at the archive root. */
+export function buildReportTarball(files) {
+    const chunks = [];
+    for (const file of files) {
+        const bytes = textOf(file);
+        chunks.push(tarHeader(file.path, bytes.byteLength), bytes);
+        const padding = bytes.byteLength % 512;
+        if (padding)
+            chunks.push(Buffer.alloc(512 - padding));
+    }
+    chunks.push(Buffer.alloc(1024));
+    const bytes = gzipSync(Buffer.concat(chunks));
+    if (bytes.byteLength > REPORT_BUNDLE_MAX_BYTES) {
+        throw new ReportPublishError("Report bundle exceeds the 10 MB deploy limit.", "source-invalid");
+    }
+    return { bytes, sizeBytes: bytes.byteLength, sha256: createHash("sha256").update(bytes).digest("hex") };
+}
+function tarHeader(filePath, size) {
+    if (!filePath || filePath.startsWith("/") || filePath.includes("..")) {
+        throw new ReportPublishError("Report source contains an unsafe archive path.", "source-invalid");
+    }
+    const header = Buffer.alloc(512, 0);
+    if (Buffer.byteLength(filePath, "utf8") > 100)
+        throw new ReportPublishError("Report source path is too long for deploy.", "source-invalid");
+    header.write(filePath, 0, 100, "utf8");
+    writeOctal(header, 0o644, 100, 8);
+    writeOctal(header, size, 124, 12);
+    writeOctal(header, Math.floor(Date.now() / 1000), 136, 12);
+    header.fill(0x20, 148, 156);
+    header.write("0", 156, 1);
+    header.write("ustar\0", 257, 6, "binary");
+    header.write("00", 263, 2);
+    let sum = 0;
+    for (const byte of header)
+        sum += byte;
+    writeOctal(header, sum, 148, 8);
+    return header;
+}
+function writeOctal(buffer, value, offset, length) {
+    buffer.write(value.toString(8).padStart(length - 1, "0").slice(-length + 1), offset, length - 1, "ascii");
+    buffer[offset + length - 1] = 0;
+}
+/** Isolated test helper for creating a compliant report source. */
+export function makeReportFixture(html) {
+    const directory = fs.mkdtempSync(path.join(os.tmpdir(), "hq-report-test-"));
+    fs.writeFileSync(path.join(directory, "index.html"), html);
+    return { directory, cleanup: () => fs.rmSync(directory, { recursive: true, force: true }) };
+}
+//# sourceMappingURL=report-publish.js.map

package/dist/lib/report-run.d.ts

@@ -0,0 +1,61 @@
+export type DigestTask = {
+    title: string;
+    project: string;
+    channelHref?: string;
+    open?: boolean;
+};
+export type DigestSignal = {
+    kind: string;
+    text: string;
+};
+export type FocusItem = {
+    title: string;
+    project: string;
+    reason: string;
+};
+export type ReportRunRecord = {
+    generatedAt: string;
+    inputs: {
+        template: string;
+        tasks: string[];
+        signals: string[];
+        projects: string[];
+    };
+    counts: {
+        tasks: number;
+        projects: number;
+        signals: number;
+        focus: number;
+    };
+};
+export type DigestPage = {
+    indexHtml: string;
+    data: {
+        template: "daily-digest";
+        person: string;
+        projects: {
+            name: string;
+            count: number;
+            href: string;
+        }[];
+        signals: {
+            kind: string;
+            text: string;
+        }[];
+        focus: FocusItem[];
+    };
+    reportRun: ReportRunRecord;
+};
+export declare function escapeReportText(value: string): string;
+/** Map a structured inbox prompt onto the one hq report verb it may call. */
+export declare function reportLaneCommand(kind: string): "adopt" | "publish" | "decommission" | null;
+export declare function safeChannelHref(value: string | undefined, name: string): string;
+export declare function renderDailyDigest(input: {
+    person: string;
+    tasks: DigestTask[];
+    signals: DigestSignal[];
+    operatorInstructions: string;
+    generatedAt?: string;
+}): DigestPage;
+export declare function writeDigestPage(directory: string, page: DigestPage): void;
+//# sourceMappingURL=report-run.d.ts.map