@deftai/directive-core 0.79.4 → 0.81.0

package/dist/pr-watch/probe.js

@@ -15,6 +15,8 @@ function errorProbe(headSha, message) {
         errored: false,
         ciFailures: 0,
         ciFailedChecks: [],
+        ciReadyState: null,
+        ciCapacityStalledChecks: [],
         terminalCheckRun: false,
         isClean: false,
         cleanGateHoldout: null,
@@ -63,6 +65,8 @@ export function probeOnce(prNumber, repoArg, runGh = defaultRunGh) {
     // still owns the hard CI gate via pr:merge-ready (#796).
     let ciFailures = 0;
     let ciFailedChecks = [];
+    let ciReadyState = null;
+    let ciCapacityStalledChecks = [];
     let terminalCheckRun = true;
     if (repo !== null) {
         const check = fetchCheckRunsRest(headSha, repo, runGh);
@@ -70,6 +74,8 @@ export function probeOnce(prNumber, repoArg, runGh = defaultRunGh) {
             const ci = evaluateCiGate(check.checkRuns, {});
             ciFailedChecks = ci.summary.failed_required;
             ciFailures = ciFailedChecks.length;
+            ciReadyState = ci.summary.ready_state;
+            ciCapacityStalledChecks = ci.summary.capacity_stalled_required;
             terminalCheckRun = ci.summary.pending_required.length === 0;
         }
     }
@@ -95,6 +101,8 @@ export function probeOnce(prNumber, repoArg, runGh = defaultRunGh) {
         errored,
         ciFailures,
         ciFailedChecks,
+        ciReadyState,
+        ciCapacityStalledChecks,
         terminalCheckRun,
         isClean,
         cleanGateHoldout,

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

@@ -15,6 +15,13 @@ export interface WatchProbe {
     readonly ciFailures: number;
     /** Failed required check identities (name + conclusion), when CI was probed. */
     readonly ciFailedChecks: readonly string[];
+    /**
+     * CI gate ready_state from evaluateCiGate (#2169 / #2672).
+     * Includes `runner_capacity_stall` distinct from `not_ready_yet`.
+     */
+    readonly ciReadyState: string | null;
+    /** Required checks classified as capacity-stalled (#2672). */
+    readonly ciCapacityStalledChecks: readonly string[];
     /** All required CI check-runs have a terminal conclusion (none pending). */
     readonly terminalCheckRun: boolean;
     readonly isClean: boolean;

package/dist/pr-watch/watch.js

@@ -1,5 +1,5 @@
 import { defaultRunGh } from "../pr-merge-readiness/gh.js";
-import { DEFAULT_CI_BLOCKED_THRESHOLD, DEFAULT_MAX_WAIT_MINUTES, DEFAULT_POLL_SECONDS, DEFAULT_STALL_THRESHOLD, EXIT_CLEAN, EXIT_NEW_P0_P1, EXIT_TERMINAL_ERROR, VERDICT_CI_BLOCKED, VERDICT_CLEAN, VERDICT_CONFIG, VERDICT_ERRORED, VERDICT_NEW_P0_P1, VERDICT_PENDING, VERDICT_STALL, VERDICT_TIMEOUT, } from "./constants.js";
+import { DEFAULT_CI_BLOCKED_THRESHOLD, DEFAULT_MAX_WAIT_MINUTES, DEFAULT_POLL_SECONDS, DEFAULT_STALL_THRESHOLD, EXIT_CLEAN, EXIT_NEW_P0_P1, EXIT_TERMINAL_ERROR, VERDICT_CI_BLOCKED, VERDICT_CLEAN, VERDICT_CONFIG, VERDICT_ERRORED, VERDICT_NEW_P0_P1, VERDICT_PENDING, VERDICT_RUNNER_CAPACITY_STALL, VERDICT_STALL, VERDICT_TIMEOUT, } from "./constants.js";
 import { probeOnce } from "./probe.js";
 const systemMonotonicClock = {
     now() {
@@ -80,6 +80,11 @@ export function watch(prNumber, repo, options = {}) {
         if (probe.errored) {
             return build(VERDICT_ERRORED, EXIT_TERMINAL_ERROR, probe, poll);
         }
+        // #2672: capacity stall is distinct from ordinary not_ready_yet — surface
+        // immediately (exit 2) so agents wait for auto-failover instead of --skip-ci.
+        if (probe.ciReadyState === "runner_capacity_stall") {
+            return build(VERDICT_RUNNER_CAPACITY_STALL, EXIT_TERMINAL_ERROR, probe, poll);
+        }
         // #2688: Greptile side satisfied on HEAD but CI red — fail loud toward a
         // fix loop instead of burning max-wait-minutes on idle Greptile polls.
         if (probe.cleanGateHoldout === "ci_failures") {
@@ -128,6 +133,8 @@ export function watch(prNumber, repo, options = {}) {
         errored: false,
         ciFailures: 0,
         ciFailedChecks: [],
+        ciReadyState: null,
+        ciCapacityStalledChecks: [],
         terminalCheckRun: false,
         isClean: false,
         cleanGateHoldout: null,

package/dist/product-signal/actor-name.d.ts

@@ -0,0 +1,18 @@
+import { type RunGhApiFn } from "../scm/gh-rest.js";
+export type ActorNameSource = "user-md" | "gh-login" | "unnamed";
+export interface ResolvedActorName {
+    readonly actorName: string;
+    readonly actorNameSource: ActorNameSource;
+    readonly displayName: string;
+}
+/** Normalize for thread-key matching (#2693 D8). */
+export declare function normalizeActorKey(name: string): string;
+/** Parse addressing-name from USER.md Personal section (#2693 D8). */
+export declare function parseAddressingNameFromUserMd(text: string): string | null;
+export interface ResolveActorNameOptions {
+    readonly projectRoot?: string;
+    readonly runGhApiFn?: RunGhApiFn;
+}
+/** Resolve actorName with USER.md -> gh-login -> unnamed precedence (#2693 D8). */
+export declare function resolveActorName(options?: ResolveActorNameOptions): ResolvedActorName;
+//# sourceMappingURL=actor-name.d.ts.map

package/dist/product-signal/actor-name.js

@@ -0,0 +1,94 @@
+import { readFileSync } from "node:fs";
+import { runGhApi } from "../scm/gh-rest.js";
+import { resolveUserMdPath } from "../user-config/resolve-user-md.js";
+/** Normalize for thread-key matching (#2693 D8). */
+export function normalizeActorKey(name) {
+    return name.trim().replace(/\s+/g, " ").toLowerCase();
+}
+/** Parse addressing-name from USER.md Personal section (#2693 D8). */
+export function parseAddressingNameFromUserMd(text) {
+    const lines = text.split(/\r?\n/);
+    let inPersonal = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (/^##\s+personal\b/i.test(trimmed)) {
+            inPersonal = true;
+            continue;
+        }
+        if (inPersonal && /^##\s+/.test(trimmed)) {
+            break;
+        }
+        const nameMatch = trimmed.match(/^(?:-\s*)?(?:\*\*)?Name(?:\*\*)?\s*:\s*(.+)$/i) ??
+            trimmed.match(/^(?:-\s*)?(?:\*\*)?addressing-name(?:\*\*)?\s*:\s*(.+)$/i);
+        if (nameMatch?.[1] !== undefined) {
+            const value = nameMatch[1].replace(/\*\*/g, "").trim();
+            if (value.length > 0) {
+                return value;
+            }
+        }
+        if (!inPersonal) {
+            const topMatch = trimmed.match(/^(?:\*\*)?Name(?:\*\*)?\s*:\s*(.+)$/i);
+            if (topMatch?.[1] !== undefined) {
+                const value = topMatch[1].replace(/\*\*/g, "").trim();
+                if (value.length > 0) {
+                    return value;
+                }
+            }
+        }
+    }
+    return null;
+}
+function readGhLogin(runGhApiFn) {
+    try {
+        const result = (runGhApiFn ?? runGhApi)(["user"], { timeout: 15 });
+        if (result.returncode !== 0) {
+            return null;
+        }
+        const parsed = JSON.parse(result.stdout.trim());
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const login = parsed.login;
+            if (typeof login === "string" && login.trim().length > 0) {
+                return login.trim();
+            }
+        }
+    }
+    catch {
+        // best-effort
+    }
+    return null;
+}
+/** Resolve actorName with USER.md -> gh-login -> unnamed precedence (#2693 D8). */
+export function resolveActorName(options = {}) {
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const userMd = resolveUserMdPath({ projectRoot });
+    if (userMd.found) {
+        try {
+            const text = readFileSync(userMd.path, "utf8");
+            const fromUser = parseAddressingNameFromUserMd(text);
+            if (fromUser !== null) {
+                return {
+                    actorName: fromUser,
+                    actorNameSource: "user-md",
+                    displayName: fromUser,
+                };
+            }
+        }
+        catch {
+            // fall through
+        }
+    }
+    const ghLogin = readGhLogin(options.runGhApiFn);
+    if (ghLogin !== null) {
+        return {
+            actorName: ghLogin,
+            actorNameSource: "gh-login",
+            displayName: ghLogin,
+        };
+    }
+    return {
+        actorName: "unnamed",
+        actorNameSource: "unnamed",
+        displayName: "unnamed",
+    };
+}
+//# sourceMappingURL=actor-name.js.map

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

@@ -0,0 +1,30 @@
+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;
+/** 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;
+    readonly revokedAt?: string;
+}
+export interface ResolveConsentPathOptions {
+    readonly platform?: NodeJS.Platform;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly homeDir?: string;
+}
+/** Platform-config consent path adjacent to USER.md (#2693 D2). */
+export declare function resolveProductSignalConsentPath(options?: ResolveConsentPathOptions): string;
+/** 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;
+}
+/** Write a fresh consent grant (#2693 D17 yes path). */
+export declare function grantProductSignalConsent(options?: WriteConsentOptions): ProductSignalConsentRecord;
+/** Revoke consent by setting revokedAt (#2693 D2). */
+export declare function revokeProductSignalConsent(options?: WriteConsentOptions): boolean;
+//# sourceMappingURL=consent.d.ts.map

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