@deftai/directive-core 0.80.0 → 0.81.0

package/dist/product-signal/consent.js

@@ -0,0 +1,116 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { platformUserConfigDir } from "../user-config/resolve-user-md.js";
+export const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
+/** Consent record schema version (#2693 D2). */
+export const PRODUCT_SIGNAL_CONSENT_VERSION = 1;
+/** Phase-1 consent tier permitting qualitative outbound (#2693 D2). */
+export const PRODUCT_SIGNAL_CONSENT_TIER = "product-signal";
+function resolveHomeDirForConsent(options) {
+    if (options.homeDir !== undefined) {
+        return options.homeDir;
+    }
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32") {
+        const userProfile = env.USERPROFILE?.trim();
+        if (userProfile) {
+            return userProfile;
+        }
+    }
+    const home = env.HOME?.trim();
+    if (home) {
+        return home;
+    }
+    return homedir();
+}
+/** Platform-config consent path adjacent to USER.md (#2693 D2). */
+export function resolveProductSignalConsentPath(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = resolveHomeDirForConsent(options);
+    return join(platformUserConfigDir(platform, env, homeDir), PRODUCT_SIGNAL_CONSENT_FILENAME);
+}
+function parseConsentRecord(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        return null;
+    }
+    const rec = raw;
+    if (typeof rec.consentVersion !== "number" || typeof rec.grantedAt !== "string") {
+        return null;
+    }
+    if (typeof rec.tier !== "string") {
+        return null;
+    }
+    const revokedAt = typeof rec.revokedAt === "string" ? rec.revokedAt : undefined;
+    return {
+        consentVersion: rec.consentVersion,
+        grantedAt: rec.grantedAt,
+        tier: rec.tier,
+        revokedAt,
+    };
+}
+/** Read consent file; returns null when absent, invalid, or revoked. */
+export function readProductSignalConsent(options = {}) {
+    const path = resolveProductSignalConsentPath(options);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        const record = parseConsentRecord(parsed);
+        if (record === null) {
+            return null;
+        }
+        if (record.revokedAt !== undefined && record.revokedAt.trim().length > 0) {
+            return null;
+        }
+        return record;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when a non-revoked consent grant exists. */
+export function isProductSignalConsented(options = {}) {
+    return readProductSignalConsent(options) !== null;
+}
+/** Write a fresh consent grant (#2693 D17 yes path). */
+export function grantProductSignalConsent(options = {}) {
+    const now = options.now ?? new Date();
+    const record = {
+        consentVersion: PRODUCT_SIGNAL_CONSENT_VERSION,
+        grantedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+        tier: PRODUCT_SIGNAL_CONSENT_TIER,
+    };
+    const path = resolveProductSignalConsentPath(options);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+    return record;
+}
+/** Revoke consent by setting revokedAt (#2693 D2). */
+export function revokeProductSignalConsent(options = {}) {
+    const path = resolveProductSignalConsentPath(options);
+    if (!existsSync(path)) {
+        return false;
+    }
+    const now = options.now ?? new Date();
+    let existing = null;
+    try {
+        existing = parseConsentRecord(JSON.parse(readFileSync(path, "utf8")));
+    }
+    catch {
+        return false;
+    }
+    if (existing === null) {
+        return false;
+    }
+    const revoked = {
+        ...existing,
+        revokedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
+    };
+    writeFileSync(path, `${JSON.stringify(revoked, null, 2)}\n`, "utf8");
+    return true;
+}
+//# sourceMappingURL=consent.js.map

package/dist/product-signal/gates.d.ts

@@ -0,0 +1,17 @@
+export type ProductSignalOutcome = "submitted" | "dry-run" | "disabled" | "no-consent" | "no-network" | "non-interactive" | "sink-unreachable" | "sink-unauthorized" | "validation" | "error-config";
+export interface GateEvaluation {
+    readonly allowed: boolean;
+    readonly outcome: ProductSignalOutcome;
+    readonly message: string;
+}
+export interface EvaluateGatesOptions {
+    readonly projectRoot: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly requireConsent?: boolean;
+    readonly stdinIsTTY?: boolean;
+}
+/** Pre-submit gate evaluation (#2693 D11 soft-skip matrix). */
+export declare function evaluateProductSignalGates(options: EvaluateGatesOptions): GateEvaluation;
+/** Map GhRestError-like conditions to soft-skip outcomes (#2693 D18). */
+export declare function classifySinkError(stderr: string, exitCode: number): ProductSignalOutcome;
+//# sourceMappingURL=gates.d.ts.map

package/dist/product-signal/gates.js

@@ -0,0 +1,66 @@
+import { resolveProductSignal } from "../policy/product-signal.js";
+import { isProductSignalConsented } from "./consent.js";
+import { isHeadlessSession } from "./headless.js";
+/** Pre-submit gate evaluation (#2693 D11 soft-skip matrix). */
+export function evaluateProductSignalGates(options) {
+    const env = options.env ?? process.env;
+    const policy = resolveProductSignal(options.projectRoot);
+    if (!policy.enabled) {
+        return {
+            allowed: false,
+            outcome: "disabled",
+            message: "product-signal disabled (plan.policy.productSignal.enabled=false).",
+        };
+    }
+    if (env.DEFT_NO_NETWORK === "1") {
+        return {
+            allowed: false,
+            outcome: "no-network",
+            message: "product-signal skipped (DEFT_NO_NETWORK=1).",
+        };
+    }
+    if (isHeadlessSession({ env, stdinIsTTY: options.stdinIsTTY })) {
+        if (options.requireConsent !== false && !isProductSignalConsented({ env })) {
+            return {
+                allowed: false,
+                outcome: "non-interactive",
+                message: "product-signal skipped in headless/non-interactive session (no consent on file).",
+            };
+        }
+    }
+    if (options.requireConsent !== false && !isProductSignalConsented({ env })) {
+        return {
+            allowed: false,
+            outcome: "no-consent",
+            message: "product-signal requires consent (`task product-signal:consent -- --grant`).",
+        };
+    }
+    if (policy.error !== null) {
+        return {
+            allowed: false,
+            outcome: "error-config",
+            message: `product-signal policy error: ${policy.error}`,
+        };
+    }
+    return {
+        allowed: true,
+        outcome: "submitted",
+        message: "gates passed",
+    };
+}
+/** Map GhRestError-like conditions to soft-skip outcomes (#2693 D18). */
+export function classifySinkError(stderr, exitCode) {
+    const text = stderr.toLowerCase();
+    if (text.includes("401") ||
+        text.includes("403") ||
+        text.includes("404") ||
+        text.includes("not found") ||
+        text.includes("permission")) {
+        return "sink-unauthorized";
+    }
+    if (exitCode !== 0) {
+        return "sink-unreachable";
+    }
+    return "sink-unreachable";
+}
+//# sourceMappingURL=gates.js.map

package/dist/product-signal/github-private-sink-adapter.d.ts

@@ -0,0 +1,28 @@
+import { type GhRestSeams } from "../scm/gh-rest.js";
+import type { ProductSignalPayload, ProductSignalSurface } from "./payload.js";
+import type { SubmitAdapter, SubmitResult } from "./submit-adapter.js";
+export declare const PRODUCT_SIGNAL_MARKER_PREFIX = "<!-- deft:product-signal v1";
+export declare const SURFACE_LABELS: Record<ProductSignalSurface, string>;
+/** Build HTML comment marker for standing-thread lookup (#2693 D8). */
+export declare function buildThreadMarker(installId: string, actorName: string, surface: ProductSignalSurface): string;
+/** Merge labels for PATCH updates (GitHub replaces the full label set). */
+export declare function mergeIssueLabels(existing: Record<string, unknown>, next: readonly string[]): string[];
+export interface GitHubPrivateSinkAdapterOptions {
+    readonly sinkRepo: string;
+    readonly seams?: GhRestSeams;
+}
+/** Phase-1 GitHub private sink adapter (#2693 D5/D8). */
+export declare class GitHubPrivateSinkAdapter implements SubmitAdapter {
+    readonly id = "github-private-sink";
+    private readonly repo;
+    private readonly seams;
+    constructor(options: GitHubPrivateSinkAdapterOptions);
+    submit(payload: ProductSignalPayload, extras?: {
+        readonly gapText?: string | null;
+    }): Promise<SubmitResult>;
+    private submitPortrait;
+    private submitPulse;
+    /** Append a Gap: comment on the standing pulse thread (#2693 D19). */
+    appendGapCommentOnPulse(payload: ProductSignalPayload, gapText: string): SubmitResult;
+}
+//# sourceMappingURL=github-private-sink-adapter.d.ts.map

package/dist/product-signal/github-private-sink-adapter.js

@@ -0,0 +1,274 @@
+import { GhRestError, restCreateIssue, restIssueListPaginated, restPostComment, restUpdateIssue, } from "../scm/gh-rest.js";
+import { normalizeActorKey } from "./actor-name.js";
+import { classifySinkError } from "./gates.js";
+export const PRODUCT_SIGNAL_MARKER_PREFIX = "<!-- deft:product-signal v1";
+export const SURFACE_LABELS = {
+    pulse: "surface:pulse",
+    portrait: "surface:portrait",
+};
+/** Build HTML comment marker for standing-thread lookup (#2693 D8). */
+export function buildThreadMarker(installId, actorName, surface) {
+    return (`${PRODUCT_SIGNAL_MARKER_PREFIX} ` +
+        `installId=${installId} actorKey=${normalizeActorKey(actorName)} surface=${surface} -->`);
+}
+function npsLabels(nps) {
+    if (nps === null) {
+        return ["nps:none"];
+    }
+    if (nps >= 9) {
+        return ["nps:promoter"];
+    }
+    if (nps >= 7) {
+        return ["nps:passive"];
+    }
+    return ["nps:detractor"];
+}
+function directiveVersionLabel(version) {
+    const match = version.match(/^(\d+\.\d+)/);
+    const minor = match?.[1] ?? "0.0";
+    return `directive:${minor}`;
+}
+function labelNamesFromIssue(issue) {
+    const labels = issue.labels;
+    if (!Array.isArray(labels)) {
+        return [];
+    }
+    const names = [];
+    for (const label of labels) {
+        if (typeof label === "string" && label.trim().length > 0) {
+            names.push(label.trim());
+            continue;
+        }
+        if (label !== null && typeof label === "object" && !Array.isArray(label)) {
+            const name = label.name;
+            if (typeof name === "string" && name.trim().length > 0) {
+                names.push(name.trim());
+            }
+        }
+    }
+    return names;
+}
+/** Merge labels for PATCH updates (GitHub replaces the full label set). */
+export function mergeIssueLabels(existing, next) {
+    const merged = new Set(labelNamesFromIssue(existing));
+    for (const label of next) {
+        if (label.trim().length > 0) {
+            merged.add(label.trim());
+        }
+    }
+    return [...merged];
+}
+function formatPayloadBody(payload) {
+    const marker = buildThreadMarker(payload.installId, payload.actorName, payload.surface);
+    const humanLines = [];
+    if (payload.human.nps !== null) {
+        humanLines.push(`- NPS: ${payload.human.nps}`);
+    }
+    for (const answer of payload.human.answers) {
+        humanLines.push(`- **${answer.q}**: ${answer.a}`);
+    }
+    if (payload.human.freeText !== null && payload.human.freeText.trim().length > 0) {
+        humanLines.push(`- Free text: ${payload.human.freeText.trim()}`);
+    }
+    const summaryJson = payload.localSignalSummary !== null
+        ? `\n<details><summary>localSignalSummary</summary>\n\n\`\`\`json\n${JSON.stringify(payload.localSignalSummary, null, 2)}\n\`\`\`\n</details>\n`
+        : "";
+    const skillsJson = payload.skillsSummary !== null
+        ? `\n<details><summary>skillsSummary</summary>\n\n\`\`\`json\n${JSON.stringify(payload.skillsSummary, null, 2)}\n\`\`\`\n</details>\n`
+        : "";
+    return [
+        marker,
+        "",
+        `## ${payload.surface === "portrait" ? "Portrait" : "Pulse"} — ${payload.actorName}`,
+        "",
+        `- installId: \`${payload.installId}\``,
+        `- actorNameSource: ${payload.actorNameSource}`,
+        `- directive: ${payload.directiveVersion}`,
+        `- harness: ${payload.harness}${payload.harnessVersion ? ` (${payload.harnessVersion})` : ""}`,
+        `- os: ${payload.os} / shell: ${payload.shell}`,
+        `- collectedAt: ${payload.collectedAt}`,
+        "",
+        "### Human",
+        "",
+        humanLines.length > 0 ? humanLines.join("\n") : "_(no human answers)_",
+        payload.agentNotes ? `\n### Agent notes\n\n${payload.agentNotes}` : "",
+        summaryJson,
+        skillsJson,
+        "",
+        "_Submitted via product-signal (Refs #2693)._",
+        "",
+    ].join("\n");
+}
+function formatPulseComment(payload) {
+    const date = payload.collectedAt.slice(0, 10);
+    const humanLines = [];
+    if (payload.human.nps !== null) {
+        humanLines.push(`NPS ${payload.human.nps}`);
+    }
+    for (const answer of payload.human.answers) {
+        humanLines.push(`${answer.q}: ${answer.a}`);
+    }
+    if (payload.human.freeText) {
+        humanLines.push(payload.human.freeText);
+    }
+    return [`**Pulse ${date}**`, "", ...humanLines, ""].join("\n");
+}
+function findStandingIssue(repo, installId, actorName, surface, seams) {
+    const needleKey = normalizeActorKey(actorName);
+    const markerNeedle = `installId=${installId} actorKey=${needleKey} surface=${surface}`;
+    const issues = restIssueListPaginated(repo, { state: "open", labels: [SURFACE_LABELS[surface]], limit: 200 }, seams);
+    for (const issue of issues) {
+        const body = typeof issue.body === "string" ? issue.body : "";
+        if (body.includes(markerNeedle)) {
+            return issue;
+        }
+    }
+    return null;
+}
+function issueUrlFromRecord(issue) {
+    const url = issue.html_url;
+    return typeof url === "string" ? url : null;
+}
+function issueNumberFromRecord(issue) {
+    const num = issue.number;
+    return typeof num === "number" ? num : null;
+}
+/** Phase-1 GitHub private sink adapter (#2693 D5/D8). */
+export class GitHubPrivateSinkAdapter {
+    id = "github-private-sink";
+    repo;
+    seams;
+    constructor(options) {
+        this.repo = options.sinkRepo;
+        this.seams = options.seams ?? {};
+    }
+    async submit(payload, extras) {
+        try {
+            const labels = [
+                SURFACE_LABELS[payload.surface],
+                ...npsLabels(payload.human.nps),
+                directiveVersionLabel(payload.directiveVersion),
+            ];
+            let result;
+            if (payload.surface === "portrait") {
+                result = this.submitPortrait(payload, labels);
+            }
+            else {
+                result = this.submitPulse(payload, labels);
+            }
+            if (result.outcome === "submitted" &&
+                extras?.gapText !== undefined &&
+                extras.gapText !== null &&
+                extras.gapText.trim().length > 0) {
+                this.appendGapCommentOnPulse(payload, extras.gapText.trim());
+            }
+            return result;
+        }
+        catch (err) {
+            if (err instanceof GhRestError) {
+                const outcome = classifySinkError(err.stderr, err.exitCode);
+                return {
+                    outcome,
+                    message: `product-signal soft-skip (${outcome}): ${err.stderr || err.message}`,
+                };
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                outcome: "sink-unreachable",
+                message: `product-signal soft-skip (sink-unreachable): ${message}`,
+            };
+        }
+    }
+    submitPortrait(payload, labels) {
+        const body = formatPayloadBody(payload);
+        const title = `[portrait] ${payload.actorName} @ ${payload.installId.slice(0, 8)}`;
+        const existing = findStandingIssue(this.repo, payload.installId, payload.actorName, "portrait", this.seams);
+        if (existing !== null) {
+            const num = issueNumberFromRecord(existing);
+            if (num === null) {
+                return { outcome: "sink-unreachable", message: "standing portrait issue missing number" };
+            }
+            const updated = restUpdateIssue(this.repo, num, { body, labels: [...labels] }, this.seams);
+            return {
+                outcome: "submitted",
+                issueUrl: issueUrlFromRecord(updated),
+                issueNumber: issueNumberFromRecord(updated),
+                message: `portrait upserted on #${num}`,
+            };
+        }
+        const created = restCreateIssue(this.repo, title, body, labels, this.seams);
+        return {
+            outcome: "submitted",
+            issueUrl: issueUrlFromRecord(created),
+            issueNumber: issueNumberFromRecord(created),
+            message: "portrait standing issue created",
+        };
+    }
+    submitPulse(payload, labels) {
+        const existing = findStandingIssue(this.repo, payload.installId, payload.actorName, "pulse", this.seams);
+        let issueNumber;
+        let issueUrl;
+        if (existing === null) {
+            const title = `[pulse] ${payload.actorName} @ ${payload.installId.slice(0, 8)}`;
+            const body = formatPayloadBody(payload);
+            const created = restCreateIssue(this.repo, title, body, labels, this.seams);
+            issueNumber = issueNumberFromRecord(created);
+            issueUrl = issueUrlFromRecord(created);
+        }
+        else {
+            issueNumber = issueNumberFromRecord(existing);
+            issueUrl = issueUrlFromRecord(existing);
+            if (issueNumber !== null) {
+                restUpdateIssue(this.repo, issueNumber, { labels: mergeIssueLabels(existing, labels) }, this.seams);
+            }
+        }
+        if (issueNumber === null) {
+            return { outcome: "sink-unreachable", message: "pulse standing issue missing number" };
+        }
+        restPostComment(this.repo, issueNumber, formatPulseComment(payload), this.seams);
+        return {
+            outcome: "submitted",
+            issueUrl,
+            issueNumber,
+            message: `pulse comment appended on #${issueNumber}`,
+        };
+    }
+    /** Append a Gap: comment on the standing pulse thread (#2693 D19). */
+    appendGapCommentOnPulse(payload, gapText) {
+        try {
+            const existing = findStandingIssue(this.repo, payload.installId, payload.actorName, "pulse", this.seams);
+            if (existing === null) {
+                return {
+                    outcome: "sink-unreachable",
+                    message: "no standing pulse issue for gap comment",
+                };
+            }
+            const num = issueNumberFromRecord(existing);
+            if (num === null) {
+                return { outcome: "sink-unreachable", message: "pulse issue missing number" };
+            }
+            const date = payload.collectedAt.slice(0, 10);
+            const body = `**Gap ${date}**\n\nGap: ${gapText}\n`;
+            restPostComment(this.repo, num, body, this.seams);
+            restUpdateIssue(this.repo, num, { labels: mergeIssueLabels(existing, [SURFACE_LABELS.pulse, "signal:gap"]) }, this.seams);
+            return {
+                outcome: "submitted",
+                issueUrl: issueUrlFromRecord(existing),
+                issueNumber: num,
+                message: `gap comment appended on pulse #${num}`,
+            };
+        }
+        catch (err) {
+            if (err instanceof GhRestError) {
+                const outcome = classifySinkError(err.stderr, err.exitCode);
+                return {
+                    outcome,
+                    message: `gap comment soft-skip (${outcome}): ${err.stderr || err.message}`,
+                };
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            return { outcome: "sink-unreachable", message };
+        }
+    }
+}
+//# sourceMappingURL=github-private-sink-adapter.js.map

package/dist/product-signal/headless.d.ts

@@ -0,0 +1,8 @@
+/** Headless / non-interactive detection (#2693 D16). */
+export interface HeadlessDetectionOptions {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly stdinIsTTY?: boolean;
+}
+/** True when the session should fail-open without interactive prompts (#2693 D16). */
+export declare function isHeadlessSession(options?: HeadlessDetectionOptions): boolean;
+//# sourceMappingURL=headless.d.ts.map

package/dist/product-signal/headless.js

@@ -0,0 +1,32 @@
+/** Headless / non-interactive detection (#2693 D16). */
+const CI_MARKERS = [
+    "CI",
+    "CONTINUOUS_INTEGRATION",
+    "GITHUB_ACTIONS",
+    "GITLAB_CI",
+    "BUILDKITE",
+    "CIRCLECI",
+    "JENKINS_URL",
+    "TF_BUILD",
+    "CURSOR_CLOUD_AGENT",
+    "DEFT_CLOUD_AGENT",
+];
+/** True when the session should fail-open without interactive prompts (#2693 D16). */
+export function isHeadlessSession(options = {}) {
+    const env = options.env ?? process.env;
+    if (env.DEFT_HEADLESS === "1" || env.DEFT_HEADLESS === "true") {
+        return true;
+    }
+    for (const key of CI_MARKERS) {
+        const val = env[key];
+        if (val !== undefined && val !== "" && val !== "0" && val !== "false") {
+            return true;
+        }
+    }
+    const stdinIsTTY = options.stdinIsTTY ?? process.stdin.isTTY;
+    if (stdinIsTTY === false) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=headless.js.map

package/dist/product-signal/install-context.d.ts

@@ -0,0 +1,13 @@
+export type ProductSignalHarness = "cursor" | "cli" | "codex" | "opencode" | "other";
+export interface InstallContext {
+    readonly installId: string;
+    readonly directiveVersion: string;
+    readonly os: string;
+    readonly osVersion: string;
+    readonly shell: string;
+    readonly harness: ProductSignalHarness;
+    readonly harnessVersion: string | null;
+}
+/** Collect shared install context for product-signal payloads (#2693 D7). */
+export declare function collectInstallContext(projectRoot: string): InstallContext;
+//# sourceMappingURL=install-context.d.ts.map

package/dist/product-signal/install-context.js

@@ -0,0 +1,41 @@
+import { release } from "node:os";
+import { readCorePackageVersion } from "../engine-version.js";
+import { resolveInstallId } from "../events/attribution-enrichment.js";
+import { detectEnvironmentContext } from "../platform/shell-context.js";
+function detectHarness(env = process.env) {
+    const explicit = env.DEFT_HARNESS?.trim().toLowerCase();
+    if (explicit === "cursor" ||
+        explicit === "cli" ||
+        explicit === "codex" ||
+        explicit === "opencode" ||
+        explicit === "other") {
+        return explicit;
+    }
+    if (env.CURSOR_SESSION_ID || env.CURSOR_TRACE_ID) {
+        return "cursor";
+    }
+    if (env.CODEX_HOME || env.CODEX_SESSION) {
+        return "codex";
+    }
+    if (env.OPENCODE) {
+        return "opencode";
+    }
+    return "cli";
+}
+/** Collect shared install context for product-signal payloads (#2693 D7). */
+export function collectInstallContext(projectRoot) {
+    const envCtx = detectEnvironmentContext();
+    const installId = resolveInstallId(projectRoot) ?? "unknown";
+    const harness = detectHarness();
+    const harnessVersion = process.env.DEFT_HARNESS_VERSION?.trim() || process.env.CURSOR_VERSION?.trim() || null;
+    return {
+        installId,
+        directiveVersion: readCorePackageVersion(),
+        os: envCtx.hostPlatform,
+        osVersion: release(),
+        shell: envCtx.shell.name,
+        harness,
+        harnessVersion,
+    };
+}
+//# sourceMappingURL=install-context.js.map

package/dist/product-signal/local-signal-summary.d.ts

@@ -0,0 +1,7 @@
+import { type LocalSignalSummary } from "./payload.js";
+export declare const DEFAULT_LOCAL_SIGNAL_WINDOW = "30d";
+/** Assemble minimized local ledger summaries (#2693 D15). */
+export declare function assembleLocalSignalSummary(projectRoot: string, options?: {
+    window?: string;
+}): LocalSignalSummary;
+//# sourceMappingURL=local-signal-summary.d.ts.map