@deftai/directive-core 0.81.0 → 0.83.0

package/dist/pr-wait-mergeable/main.js

@@ -16,22 +16,45 @@ export function parseWaitMergeableArgs(argv) {
     let capMinutes = 60;
     const protectedValues = [];
     let emitJson = false;
+    let cascadeMode = false;
+    let requireMasterCiGreen = false;
+    let baseBranch = null;
+    const baseReturn = () => ({
+        prNumber,
+        repo,
+        capMinutes,
+        protectedValues,
+        emitJson,
+        cascadeMode,
+        requireMasterCiGreen,
+        baseBranch,
+    });
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--json") {
             emitJson = true;
         }
+        else if (arg === "--cascade") {
+            cascadeMode = true;
+        }
+        else if (arg === "--require-master-ci-green") {
+            requireMasterCiGreen = true;
+        }
+        else if (arg === "--base-branch") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...baseReturn(), error: "argument --base-branch: expected one argument" };
+            }
+            baseBranch = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-branch=")) {
+            baseBranch = arg.slice("--base-branch=".length);
+        }
         else if (arg === "--repo") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --repo: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --repo: expected one argument" };
             }
             repo = value;
             i += 1;
@@ -42,25 +65,11 @@ export function parseWaitMergeableArgs(argv) {
         else if (arg === "--cap-minutes") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --cap-minutes: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --cap-minutes: expected one argument" };
             }
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid --cap-minutes value: ${value}`,
-                };
+                return { ...baseReturn(), error: `invalid --cap-minutes value: ${value}` };
             }
             capMinutes = parsed;
             i += 1;
@@ -69,28 +78,14 @@ export function parseWaitMergeableArgs(argv) {
             const value = arg.slice("--cap-minutes=".length);
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid --cap-minutes value: ${value}`,
-                };
+                return { ...baseReturn(), error: `invalid --cap-minutes value: ${value}` };
             }
             capMinutes = parsed;
         }
         else if (arg === "--protected") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --protected: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --protected: expected one argument" };
             }
             protectedValues.push(value);
             i += 1;
@@ -99,51 +94,23 @@ export function parseWaitMergeableArgs(argv) {
             protectedValues.push(arg.slice("--protected=".length));
         }
         else if (arg?.startsWith("-")) {
-            return {
-                prNumber,
-                repo,
-                capMinutes,
-                protectedValues,
-                emitJson,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return { ...baseReturn(), error: `unrecognized arguments: ${arg}` };
         }
         else if (prNumber === null) {
             const n = Number(arg);
             if (!Number.isInteger(n)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid PR number: ${arg}`,
-                };
+                return { ...baseReturn(), error: `invalid PR number: ${arg}` };
             }
             prNumber = n;
         }
         else {
-            return {
-                prNumber,
-                repo,
-                capMinutes,
-                protectedValues,
-                emitJson,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return { ...baseReturn(), error: `unrecognized arguments: ${arg}` };
         }
     }
     if (prNumber === null) {
-        return {
-            prNumber,
-            repo,
-            capMinutes,
-            protectedValues,
-            emitJson,
-            error: "the following arguments are required: pr_number",
-        };
+        return { ...baseReturn(), error: "the following arguments are required: pr_number" };
     }
-    return { prNumber, repo, capMinutes, protectedValues, emitJson };
+    return baseReturn();
 }
 function summaryLabelForExit(exitCode) {
     switch (exitCode) {
@@ -183,6 +150,10 @@ export function runWaitMergeable(argv, options = {}) {
         protectedFn: options.protectedFn,
         monitorFn: options.monitorFn,
         mergeFn: options.mergeFn,
+        semanticGreenFn: options.semanticGreenFn,
+        cascadeMode: args.cascadeMode,
+        requireMasterCiGreen: args.requireMasterCiGreen,
+        baseBranch: args.baseBranch,
     });
     const summaryLabel = summaryLabelForExit(result.exitCode);
     process.stderr.write(`[pr_wait_mergeable] PR #${result.prNumber} repo=${result.repo} ` +

package/dist/pr-wait-mergeable/result.d.ts

@@ -1,8 +1,9 @@
 import type { WaitMergeableResult } from "./types.js";
 export declare function toResultDict(result: WaitMergeableResult): Record<string, unknown>;
-export declare function makeResult(fields: Omit<WaitMergeableResult, "monitorResult" | "protectedCheck" | "mergeStdout" | "mergeStderr"> & {
+export declare function makeResult(fields: Omit<WaitMergeableResult, "monitorResult" | "protectedCheck" | "semanticGreen" | "mergeStdout" | "mergeStderr"> & {
     readonly monitorResult?: Record<string, unknown>;
     readonly protectedCheck?: Record<string, unknown>;
+    readonly semanticGreen?: Record<string, unknown>;
     readonly mergeStdout?: string;
     readonly mergeStderr?: string;
 }): WaitMergeableResult;

package/dist/pr-wait-mergeable/result.js

@@ -11,6 +11,9 @@ export function toResultDict(result) {
     if (Object.keys(result.protectedCheck).length > 0) {
         payload.protected_check = result.protectedCheck;
     }
+    if (Object.keys(result.semanticGreen).length > 0) {
+        payload.semantic_green = result.semanticGreen;
+    }
     if (result.mergeStdout.length > 0) {
         payload.merge_stdout = result.mergeStdout;
     }
@@ -26,6 +29,7 @@ export function makeResult(fields) {
     return {
         monitorResult: fields.monitorResult ?? {},
         protectedCheck: fields.protectedCheck ?? {},
+        semanticGreen: fields.semanticGreen ?? {},
         mergeStdout: fields.mergeStdout ?? "",
         mergeStderr: fields.mergeStderr ?? "",
         prNumber: fields.prNumber,

package/dist/pr-wait-mergeable/semantic-green.d.ts

@@ -0,0 +1,27 @@
+import type { RunGhFn } from "../pr-merge-readiness/types.js";
+export interface SemanticGreenOptions {
+    /** Enable merge-cascade semantic-green checks (#2385). */
+    readonly cascadeMode?: boolean;
+    /** After a prior cascade merge, require target-branch CI green at HEAD before the next merge. */
+    readonly requireMasterCiGreen?: boolean;
+    /** Target branch for stale-base comparison (defaults to PR base.ref). */
+    readonly baseBranch?: string | null;
+    readonly runGh?: RunGhFn;
+}
+export interface SemanticGreenPayload {
+    readonly pr_base_sha: string | null;
+    readonly target_branch: string | null;
+    readonly target_head_sha: string | null;
+    readonly master_ci: Record<string, unknown>;
+}
+export interface SemanticGreenResult {
+    readonly ok: boolean;
+    readonly outcome: string | null;
+    readonly exitCode: number | null;
+    readonly error: string | null;
+    readonly payload: SemanticGreenPayload;
+}
+/** Pre-merge semantic-green gate for merge cascades (#2385). */
+export declare function evaluateSemanticGreen(prNumber: number, repo: string, options?: SemanticGreenOptions): SemanticGreenResult;
+export type SemanticGreenFn = typeof evaluateSemanticGreen;
+//# sourceMappingURL=semantic-green.d.ts.map

package/dist/pr-wait-mergeable/semantic-green.js

@@ -0,0 +1,202 @@
+import { buildCiSummaryLine, evaluateCiGate } from "../pr-merge-readiness/ci-gate.js";
+import { defaultRunGh, fetchCheckRunsRest } from "../pr-merge-readiness/gh.js";
+import { EXIT_CONFIG_ERROR, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
+function emptyPayload() {
+    return {
+        pr_base_sha: null,
+        target_branch: null,
+        target_head_sha: null,
+        master_ci: {},
+    };
+}
+function fetchPrBase(prNumber, repo, runGh) {
+    const rc = runGh(["gh", "api", `repos/${repo}/pulls/${prNumber}`]);
+    if (rc.returncode !== 0) {
+        return {
+            baseRef: null,
+            baseSha: null,
+            error: `gh api /pulls/${prNumber} failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { baseRef: null, baseSha: null, error: "empty body from gh api /pulls/<N>" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { baseRef: null, baseSha: null, error: `could not parse PR JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { baseRef: null, baseSha: null, error: "unexpected PR JSON shape (not a dict)" };
+    }
+    const base = payload.base;
+    if (base === null || typeof base !== "object" || Array.isArray(base)) {
+        return { baseRef: null, baseSha: null, error: "PR JSON missing base object" };
+    }
+    const baseRecord = base;
+    const baseRef = typeof baseRecord.ref === "string" && baseRecord.ref.length > 0 ? baseRecord.ref : null;
+    const baseSha = typeof baseRecord.sha === "string" && baseRecord.sha.length > 0 ? baseRecord.sha : null;
+    if (baseRef === null || baseSha === null) {
+        return { baseRef, baseSha, error: "PR JSON missing base.ref or base.sha" };
+    }
+    return { baseRef, baseSha, error: null };
+}
+function fetchBranchHeadSha(repo, branch, runGh) {
+    const encoded = branch.split("/").map(encodeURIComponent).join("/");
+    const rc = runGh(["gh", "api", `repos/${repo}/git/ref/heads/${encoded}`]);
+    if (rc.returncode !== 0) {
+        return {
+            sha: null,
+            error: `gh api /git/ref/heads/${branch} failed: ${rc.stderr.trim()}`,
+        };
+    }
+    if (!rc.stdout.trim()) {
+        return { sha: null, error: `empty body from gh api /git/ref/heads/${branch}` };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(rc.stdout);
+    }
+    catch (exc) {
+        const message = exc instanceof Error ? exc.message : String(exc);
+        return { sha: null, error: `could not parse branch ref JSON: ${message}` };
+    }
+    if (payload === null || typeof payload !== "object" || Array.isArray(payload)) {
+        return { sha: null, error: "unexpected branch ref JSON shape (not a dict)" };
+    }
+    const object = payload.object;
+    if (object === null || typeof object !== "object" || Array.isArray(object)) {
+        return { sha: null, error: "branch ref JSON missing object.sha" };
+    }
+    const sha = object.sha;
+    if (typeof sha !== "string" || sha.length === 0) {
+        return { sha: null, error: "branch ref JSON missing object.sha" };
+    }
+    return { sha, error: null };
+}
+function evaluateTargetBranchCi(repo, headSha, runGh) {
+    const check = fetchCheckRunsRest(headSha, repo, runGh);
+    if (check.error.length > 0) {
+        return {
+            ok: false,
+            error: "Required CI check-runs on target branch HEAD could not be fetched; " +
+                `fail closed (#2385). ${check.error}`,
+            masterCi: { ready_state: "blocked", error: check.error },
+        };
+    }
+    const ciResult = evaluateCiGate(check.checkRuns);
+    const masterCi = {
+        ...ciResult.summary,
+        summary_line: buildCiSummaryLine(ciResult.summary),
+    };
+    if (ciResult.summary.ready_state !== "ready") {
+        const detail = ciResult.failures.length > 0
+            ? ciResult.failures.join(" ")
+            : `target branch CI ready_state=${ciResult.summary.ready_state}`;
+        return {
+            ok: false,
+            error: "Target branch CI is not green at current HEAD; block cascade merge until master is green (#2385). " +
+                detail,
+            masterCi,
+        };
+    }
+    return { ok: true, error: null, masterCi };
+}
+/** Pre-merge semantic-green gate for merge cascades (#2385). */
+export function evaluateSemanticGreen(prNumber, repo, options = {}) {
+    if (options.cascadeMode !== true) {
+        return { ok: true, outcome: null, exitCode: null, error: null, payload: emptyPayload() };
+    }
+    const runGh = options.runGh ?? defaultRunGh;
+    const prBase = fetchPrBase(prNumber, repo, runGh);
+    if (prBase.error !== null) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: prBase.error,
+            payload: {
+                ...emptyPayload(),
+                pr_base_sha: prBase.baseSha,
+                target_branch: prBase.baseRef,
+            },
+        };
+    }
+    const targetBranch = options.baseBranch ?? prBase.baseRef;
+    if (targetBranch === null || targetBranch.length === 0) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: "Could not resolve target branch for semantic-green gate (--base-branch or PR base.ref).",
+            payload: {
+                pr_base_sha: prBase.baseSha,
+                target_branch: null,
+                target_head_sha: null,
+                master_ci: {},
+            },
+        };
+    }
+    const branchHead = fetchBranchHeadSha(repo, targetBranch, runGh);
+    if (branchHead.error !== null) {
+        return {
+            ok: false,
+            outcome: "config-error",
+            exitCode: EXIT_CONFIG_ERROR,
+            error: branchHead.error,
+            payload: {
+                pr_base_sha: prBase.baseSha,
+                target_branch: targetBranch,
+                target_head_sha: null,
+                master_ci: {},
+            },
+        };
+    }
+    const payload = {
+        pr_base_sha: prBase.baseSha,
+        target_branch: targetBranch,
+        target_head_sha: branchHead.sha,
+        master_ci: {},
+    };
+    if (prBase.baseSha !== branchHead.sha) {
+        return {
+            ok: false,
+            outcome: "semantic-stale-base",
+            exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+            error: "PR base SHA is behind the current target branch HEAD (merge-tree-clean but semantically stale). " +
+                `Rebase/update-branch onto ${targetBranch} at ${branchHead.sha} and wait for fresh green CI before cascade merge (#2385). ` +
+                `pr_base=${prBase.baseSha} target_head=${branchHead.sha}`,
+            payload,
+        };
+    }
+    if (options.requireMasterCiGreen === true) {
+        const ci = evaluateTargetBranchCi(repo, branchHead.sha, runGh);
+        if (!ci.ok) {
+            return {
+                ok: false,
+                outcome: "master-ci-not-green",
+                exitCode: EXIT_TIMEOUT_OR_ESCALATION,
+                error: ci.error,
+                payload: {
+                    ...payload,
+                    master_ci: ci.masterCi,
+                },
+            };
+        }
+        return {
+            ok: true,
+            outcome: null,
+            exitCode: null,
+            error: null,
+            payload: {
+                ...payload,
+                master_ci: ci.masterCi,
+            },
+        };
+    }
+    return { ok: true, outcome: null, exitCode: null, error: null, payload };
+}
+//# sourceMappingURL=semantic-green.js.map

package/dist/pr-wait-mergeable/types.d.ts

@@ -5,6 +5,7 @@ export interface WaitMergeableResult {
     readonly exitCode: number;
     readonly monitorResult: Record<string, unknown>;
     readonly protectedCheck: Record<string, unknown>;
+    readonly semanticGreen: Record<string, unknown>;
     readonly mergeStdout: string;
     readonly mergeStderr: string;
     readonly error: string | null;

package/dist/pr-watch/constants.d.ts

@@ -39,10 +39,10 @@ export declare const DEFAULT_POLL_SECONDS = 90;
  */
 export declare const WATCH_HELP: string;
 /**
- * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
- * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
- * a Greptile review that never re-reviews the new HEAD from silently eating the
- * whole 30-minute budget (#1039 STALL terminal).
+ * Consecutive polls where the CLEAN gate is wedged on HEAD (!has_blocking &&
+ * !is_clean with a holdout other than sha_match) before STALL (#1039). Stale-SHA
+ * reads (sha_match holdout) do NOT advance this counter — re-review in flight
+ * waits until max-wait cap (#2313 / #1259 INCOMPLETE_BUT_RATED).
  */
 export declare const DEFAULT_STALL_THRESHOLD = 3;
 /**

package/dist/pr-watch/constants.js

@@ -61,10 +61,10 @@ export const WATCH_HELP = "usage: task pr:watch -- <pr_number> [options]\n" +
     "  1  NEW_P0_P1   Blocking findings on the current (SHA-matched) review\n" +
     "  2  ERRORED | STALL | TIMEOUT | CI_BLOCKED | RUNNER_CAPACITY_STALL | config / usage error\n";
 /**
- * Consecutive polls with a review PRESENT but stuck on a stale (non-HEAD)
- * commit before the loop surfaces STALL instead of waiting the full cap. Keeps
- * a Greptile review that never re-reviews the new HEAD from silently eating the
- * whole 30-minute budget (#1039 STALL terminal).
+ * Consecutive polls where the CLEAN gate is wedged on HEAD (!has_blocking &&
+ * !is_clean with a holdout other than sha_match) before STALL (#1039). Stale-SHA
+ * reads (sha_match holdout) do NOT advance this counter — re-review in flight
+ * waits until max-wait cap (#2313 / #1259 INCOMPLETE_BUT_RATED).
  */
 export const DEFAULT_STALL_THRESHOLD = 3;
 /**

package/dist/pr-watch/watch.js

@@ -99,9 +99,11 @@ export function watch(prNumber, repo, options = {}) {
         if (!oneShot && ciBlockedStreak >= DEFAULT_CI_BLOCKED_THRESHOLD) {
             return build(VERDICT_CI_BLOCKED, EXIT_TERMINAL_ERROR, probe, poll);
         }
-        // Stall = a review IS present but stuck on a non-HEAD commit; surface it
-        // rather than burning the whole cap waiting for a re-review that isn't coming.
-        if (probe.found && !probe.shaMatch) {
+        // STALL (#1039): wedged CLEAN-gate on HEAD — !has_blocking && !is_clean for N
+        // consecutive polls with a holdout OTHER than sha_match. Stale-SHA reads
+        // (clean_gate_holdout=sha_match) are INCOMPLETE for HEAD per #1259 / #2313 —
+        // keep polling until cap, not early STALL while re-review is in flight.
+        if (!probe.hasBlocking && !probe.isClean && probe.cleanGateHoldout !== "sha_match") {
             stallStreak += 1;
         }
         else {

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

@@ -1,12 +1,14 @@
 export declare const PRODUCT_SIGNAL_CONSENT_FILENAME = "product-signal-consent.json";
-/** Consent record schema version (#2693 D2). */
-export declare const PRODUCT_SIGNAL_CONSENT_VERSION = 1;
+/** Consent record schema version (#2693 D2, #2767 v2 sink binding). */
+export declare const PRODUCT_SIGNAL_CONSENT_VERSION = 2;
 /** Phase-1 consent tier permitting qualitative outbound (#2693 D2). */
 export declare const PRODUCT_SIGNAL_CONSENT_TIER = "product-signal";
 export interface ProductSignalConsentRecord {
     readonly consentVersion: number;
     readonly grantedAt: string;
     readonly tier: string;
+    /** Normalized owner/repo sink authorized by v2 consent (#2767). */
+    readonly sinkRepo?: string;
     readonly revokedAt?: string;
 }
 export interface ResolveConsentPathOptions {
@@ -14,16 +16,31 @@ export interface ResolveConsentPathOptions {
     readonly env?: NodeJS.ProcessEnv;
     readonly homeDir?: string;
 }
+export interface SinkAuthorizationResult {
+    readonly authorized: boolean;
+    readonly configuredSink: string;
+    readonly consentedSink: string | null;
+    readonly sinksMatch: boolean;
+    readonly message: string;
+}
 /** Platform-config consent path adjacent to USER.md (#2693 D2). */
 export declare function resolveProductSignalConsentPath(options?: ResolveConsentPathOptions): string;
+/** Normalize sinkRepo to lowercase owner/repo (#2767). */
+export declare function normalizeProductSignalSinkRepo(raw: string): string;
+/** Resolve the sink authorized by a consent record (#2767). */
+export declare function resolveConsentedProductSignalSink(consent: ProductSignalConsentRecord | null): string | null;
+/** Authorize configured sink against install consent (#2767). */
+export declare function authorizeProductSignalSink(configuredSink: string, consent: ProductSignalConsentRecord | null): SinkAuthorizationResult;
 /** Read consent file; returns null when absent, invalid, or revoked. */
 export declare function readProductSignalConsent(options?: ResolveConsentPathOptions): ProductSignalConsentRecord | null;
 /** True when a non-revoked consent grant exists. */
 export declare function isProductSignalConsented(options?: ResolveConsentPathOptions): boolean;
 export interface WriteConsentOptions extends ResolveConsentPathOptions {
     readonly now?: Date;
+    /** Normalized sink to bind into v2 consent (#2767). Defaults to baked-in sink. */
+    readonly sinkRepo?: string;
 }
-/** Write a fresh consent grant (#2693 D17 yes path). */
+/** Write a fresh consent grant (#2693 D17 yes path, #2767 v2 sink binding). */
 export declare function grantProductSignalConsent(options?: WriteConsentOptions): ProductSignalConsentRecord;
 /** Revoke consent by setting revokedAt (#2693 D2). */
 export declare function revokeProductSignalConsent(options?: WriteConsentOptions): boolean;

package/dist/product-signal/consent.js

@@ -1,10 +1,13 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { DEFAULT_PRODUCT_SIGNAL_SINK_REPO } from "../policy/product-signal.js";
 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;
+/** Consent record schema version (#2693 D2, #2767 v2 sink binding). */
+export const PRODUCT_SIGNAL_CONSENT_VERSION = 2;
+/** Legacy consent schema — authorizes default sink only (#2767). */
+const PRODUCT_SIGNAL_CONSENT_VERSION_V1 = 1;
 /** Phase-1 consent tier permitting qualitative outbound (#2693 D2). */
 export const PRODUCT_SIGNAL_CONSENT_TIER = "product-signal";
 function resolveHomeDirForConsent(options) {
@@ -32,25 +35,76 @@ export function resolveProductSignalConsentPath(options = {}) {
     const homeDir = resolveHomeDirForConsent(options);
     return join(platformUserConfigDir(platform, env, homeDir), PRODUCT_SIGNAL_CONSENT_FILENAME);
 }
+/** Normalize sinkRepo to lowercase owner/repo (#2767). */
+export function normalizeProductSignalSinkRepo(raw) {
+    const sink = raw.trim().replace(/^https?:\/\/github\.com\//i, "");
+    return sink.replace(/\/+$/, "").toLowerCase();
+}
 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") {
+    if (typeof rec.consentVersion !== "number" ||
+        typeof rec.grantedAt !== "string" ||
+        typeof rec.tier !== "string") {
         return null;
     }
-    if (typeof rec.tier !== "string") {
+    const revokedAt = typeof rec.revokedAt === "string" ? rec.revokedAt : undefined;
+    let sinkRepo;
+    if (rec.consentVersion >= PRODUCT_SIGNAL_CONSENT_VERSION) {
+        if (typeof rec.sinkRepo !== "string" || rec.sinkRepo.trim().length === 0) {
+            return null;
+        }
+        sinkRepo = normalizeProductSignalSinkRepo(rec.sinkRepo);
+        if (sinkRepo.length === 0) {
+            return null;
+        }
+    }
+    else if (rec.consentVersion !== PRODUCT_SIGNAL_CONSENT_VERSION_V1) {
         return null;
     }
-    const revokedAt = typeof rec.revokedAt === "string" ? rec.revokedAt : undefined;
     return {
         consentVersion: rec.consentVersion,
         grantedAt: rec.grantedAt,
         tier: rec.tier,
+        sinkRepo,
         revokedAt,
     };
 }
+/** Resolve the sink authorized by a consent record (#2767). */
+export function resolveConsentedProductSignalSink(consent) {
+    if (consent === null) {
+        return null;
+    }
+    if (consent.consentVersion >= PRODUCT_SIGNAL_CONSENT_VERSION) {
+        return consent.sinkRepo ?? null;
+    }
+    if (consent.consentVersion === PRODUCT_SIGNAL_CONSENT_VERSION_V1) {
+        return normalizeProductSignalSinkRepo(DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
+    }
+    return null;
+}
+/** Authorize configured sink against install consent (#2767). */
+export function authorizeProductSignalSink(configuredSink, consent) {
+    const configured = normalizeProductSignalSinkRepo(configuredSink);
+    const consented = resolveConsentedProductSignalSink(consent);
+    const sinksMatch = consented !== null && configured === consented;
+    let message = "sink authorized";
+    if (!sinksMatch) {
+        message =
+            consented === null
+                ? "product-signal requires consent (`task product-signal:consent -- --grant`)."
+                : `product-signal skipped (sink-unconsented): configured sink=${configured} does not match consented sink=${consented}. Re-run \`task product-signal:consent -- --grant\` after confirming the destination.`;
+    }
+    return {
+        authorized: sinksMatch,
+        configuredSink: configured,
+        consentedSink: consented,
+        sinksMatch,
+        message,
+    };
+}
 /** Read consent file; returns null when absent, invalid, or revoked. */
 export function readProductSignalConsent(options = {}) {
     const path = resolveProductSignalConsentPath(options);
@@ -76,13 +130,16 @@ export function readProductSignalConsent(options = {}) {
 export function isProductSignalConsented(options = {}) {
     return readProductSignalConsent(options) !== null;
 }
-/** Write a fresh consent grant (#2693 D17 yes path). */
+/** Write a fresh consent grant (#2693 D17 yes path, #2767 v2 sink binding). */
 export function grantProductSignalConsent(options = {}) {
     const now = options.now ?? new Date();
+    const normalizedSink = normalizeProductSignalSinkRepo((options.sinkRepo ?? DEFAULT_PRODUCT_SIGNAL_SINK_REPO).trim());
+    const sinkRepo = normalizedSink || normalizeProductSignalSinkRepo(DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
     const record = {
         consentVersion: PRODUCT_SIGNAL_CONSENT_VERSION,
         grantedAt: now.toISOString().replace(/\.\d{3}Z$/, "Z"),
         tier: PRODUCT_SIGNAL_CONSENT_TIER,
+        sinkRepo,
     };
     const path = resolveProductSignalConsentPath(options);
     mkdirSync(dirname(path), { recursive: true });

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

@@ -1,4 +1,4 @@
-export type ProductSignalOutcome = "submitted" | "dry-run" | "disabled" | "no-consent" | "no-network" | "non-interactive" | "sink-unreachable" | "sink-unauthorized" | "validation" | "error-config";
+export type ProductSignalOutcome = "submitted" | "dry-run" | "disabled" | "no-consent" | "no-network" | "non-interactive" | "sink-unconsented" | "sink-unreachable" | "sink-unauthorized" | "validation" | "error-config";
 export interface GateEvaluation {
     readonly allowed: boolean;
     readonly outcome: ProductSignalOutcome;