@deftai/directive-core 0.70.0 → 0.71.1

package/dist/value/adoption-registry.js

@@ -0,0 +1,214 @@
+import { isValueFeedbackPathAllowed, } from "../policy/value-feedback.js";
+/** Conservative thresholds — adoption nudges fire only above these bars (#1709). */
+export const ADOPTION_THRESHOLDS = {
+    smallWorkMaxFiles: 2,
+    planningMinFiles: 4,
+    costMinFiles: 3,
+    largeMultiFileMinFiles: 5,
+    largeMultiFileMinModules: 2,
+    swarmMinFiles: 8,
+    swarmMinModules: 3,
+    glossaryMinFiles: 6,
+    lessonsMinFiles: 5,
+};
+export const ADOPTION_SIGNAL_CLASS = "adoption";
+const CAPABILITY_CATALOG = [
+    {
+        id: "planning",
+        label: "Planning",
+        description: "Structured spec interview or speckit planning before implementation.",
+        usageSignals: ["command:/deft:directive:run:interview", "command:/deft:directive:run:speckit"],
+        nudgeHint: "Consider `/deft:directive:run:interview` or `/deft:directive:run:speckit` before a multi-file build.",
+    },
+    {
+        id: "cost",
+        label: "Cost awareness",
+        description: "Capacity/cost phase before committing to a build.",
+        usageSignals: ["command:task capacity:show"],
+        nudgeHint: "Run `task capacity:show` before a build to surface allocation targets.",
+    },
+    {
+        id: "decompose",
+        label: "Decompose",
+        description: "Split large multi-file work into reviewable PRs.",
+        usageSignals: ["command:split-to-prs"],
+        nudgeHint: "Large multi-file work may benefit from split-to-prs decomposition.",
+    },
+    {
+        id: "swarm",
+        label: "Swarm",
+        description: "Parallel agent dispatch for disjoint multi-story cohorts.",
+        usageSignals: ["command:task swarm:launch"],
+        nudgeHint: "Disjoint multi-story work may benefit from `task swarm:launch`.",
+    },
+    {
+        id: "pre-pr",
+        label: "Pre-PR loop",
+        description: "Iterative pre-PR quality loop before opening a pull request.",
+        usageSignals: ["skill:deft-directive-pre-pr"],
+        nudgeHint: "Run the deft-directive-pre-pr skill before opening a PR.",
+    },
+    {
+        id: "debug",
+        label: "Debug mode",
+        description: "Systematic debug workflow for failures and regressions.",
+        usageSignals: ["skill:debug-mode"],
+        nudgeHint: "Switch to debug mode when chasing a failure systematically.",
+    },
+    {
+        id: "glossary",
+        label: "Glossary",
+        description: "Project glossary for unfamiliar domain terms.",
+        usageSignals: ["command:/deft:glossary"],
+        nudgeHint: "Consult `/deft:glossary` when domain terms are ambiguous.",
+    },
+    {
+        id: "lessons",
+        label: "Lessons packs",
+        description: "Prior-art slices from directive content packs.",
+        usageSignals: ["command:deft packs:slice"],
+        nudgeHint: "Load a lessons pack slice before improvising on a novel problem.",
+    },
+];
+function usedSet(ctx) {
+    return new Set(ctx.usedCapabilities);
+}
+function verdict(applicable, reason) {
+    return { applicable, reason };
+}
+const APPLICABILITY_RULES = {
+    planning(ctx) {
+        if (ctx.isPrOpening) {
+            return verdict(false, "at PR-open boundary — planning phase is past");
+        }
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.planningMinFiles) {
+            return verdict(false, "scope below planning threshold");
+        }
+        return verdict(true, "multi-file scope without a planning pass");
+    },
+    cost(ctx) {
+        if (!ctx.isBuildIntent) {
+            return verdict(false, "not a build-intent session");
+        }
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.costMinFiles) {
+            return verdict(false, "build scope below cost threshold");
+        }
+        return verdict(true, "build intent without a cost phase");
+    },
+    decompose(ctx) {
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.largeMultiFileMinFiles) {
+            return verdict(false, "file count below large multi-file threshold");
+        }
+        if (ctx.distinctModuleGlobs < ADOPTION_THRESHOLDS.largeMultiFileMinModules) {
+            return verdict(false, "work is not parallelizable across modules");
+        }
+        return verdict(true, "large multi-file parallelizable work");
+    },
+    swarm(ctx) {
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.swarmMinFiles) {
+            return verdict(false, "file count below swarm threshold");
+        }
+        if (ctx.distinctModuleGlobs < ADOPTION_THRESHOLDS.swarmMinModules) {
+            return verdict(false, "insufficient module breadth for swarm cohort");
+        }
+        return verdict(true, "broad parallelizable cohort scope");
+    },
+    "pre-pr"(ctx) {
+        if (!ctx.isPrOpening) {
+            return verdict(false, "not at PR-open boundary");
+        }
+        return verdict(true, "PR opening without pre-PR loop");
+    },
+    debug(_ctx) {
+        return verdict(false, "debug nudges require an explicit failure signal");
+    },
+    glossary(ctx) {
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.glossaryMinFiles) {
+            return verdict(false, "scope below glossary threshold");
+        }
+        return verdict(true, "broad unfamiliar scope");
+    },
+    lessons(ctx) {
+        if (ctx.filesTouched < ADOPTION_THRESHOLDS.lessonsMinFiles) {
+            return verdict(false, "scope below lessons threshold");
+        }
+        return verdict(true, "novel multi-file scope");
+    },
+};
+/** Return the full capability catalog (#1709-adoption-registry-a1). */
+function listCapabilities() {
+    return CAPABILITY_CATALOG;
+}
+/** Lookup a single catalog entry by id. */
+function getCapability(id) {
+    return CAPABILITY_CATALOG.find((entry) => entry.id === id);
+}
+/** Event name for the attribution ledger (`adoption:<capability>`). */
+export function formatAdoptionEventName(id) {
+    return `${ADOPTION_SIGNAL_CLASS}:${id}`;
+}
+/** True when work is too small for any adoption nudge (#1709-adoption-registry-a3). */
+export function isWorkTooSmallForAdoptionNudges(ctx) {
+    return ctx.filesTouched <= ADOPTION_THRESHOLDS.smallWorkMaxFiles;
+}
+/** Evaluate whether a capability's conservative heuristic applies to the work snapshot. */
+export function evaluateApplicability(id, ctx) {
+    if (isWorkTooSmallForAdoptionNudges(ctx)) {
+        return verdict(false, "small work — adoption nudges suppressed");
+    }
+    return APPLICABILITY_RULES[id](ctx);
+}
+function buildAdoptionSignal(id, ctx, applicability) {
+    const record = getCapability(id);
+    if (record === undefined) {
+        return null;
+    }
+    return {
+        signalClass: ADOPTION_SIGNAL_CLASS,
+        event: formatAdoptionEventName(record.id),
+        capabilityId: record.id,
+        message: record.nudgeHint,
+        evidence: {
+            filesTouched: ctx.filesTouched,
+            distinctModuleGlobs: ctx.distinctModuleGlobs,
+            usageSignals: record.usageSignals,
+            applicabilityReason: applicability.reason,
+        },
+    };
+}
+/**
+ * Detect applicable-but-unused capabilities (#1709-adoption-registry-a2).
+ * Does not consult the value-feedback policy — use `detectApplicableButUnusedGated`.
+ */
+export function detectApplicableButUnused(ctx) {
+    if (isWorkTooSmallForAdoptionNudges(ctx)) {
+        return [];
+    }
+    const used = usedSet(ctx);
+    const signals = [];
+    for (const record of listCapabilities()) {
+        if (used.has(record.id)) {
+            continue;
+        }
+        const applicability = evaluateApplicability(record.id, ctx);
+        if (!applicability.applicable) {
+            continue;
+        }
+        const signal = buildAdoptionSignal(record.id, ctx, applicability);
+        if (signal !== null) {
+            signals.push(signal);
+        }
+    }
+    return signals;
+}
+/**
+ * Policy-gated adoption detection — returns signals only when value feedback
+ * is enabled and the emitEvents path is allowed (#1709 opt-in gate).
+ */
+export function detectApplicableButUnusedGated(ctx, policy) {
+    if (!isValueFeedbackPathAllowed("emitEvents", policy)) {
+        return [];
+    }
+    return detectApplicableButUnused(ctx);
+}
+//# sourceMappingURL=adoption-registry.js.map

package/dist/value/feedback-file.d.ts

@@ -0,0 +1,67 @@
+import { type GhRestSeams } from "../scm/gh-rest.js";
+export declare const DEFAULT_UPSTREAM_REPO = "deftai/directive";
+export declare const FRAMEWORK_GAP_TITLE_PREFIX = "[framework-gap]";
+export type FeedbackFileOutcome = "draft" | "filed" | "skipped-maintainer" | "blocked-policy" | "blocked-duplicate" | "blocked-no-confirm" | "error-bad-args" | "error-config" | "error-network";
+export interface FeedbackGapInput {
+    readonly summary: string;
+    readonly context?: string;
+    readonly expected?: string;
+    readonly actual?: string;
+    readonly sessionNotes?: string;
+}
+export interface FeedbackFileOptions extends FeedbackGapInput {
+    readonly projectRoot?: string | null;
+    readonly repo?: string;
+    readonly confirm?: boolean;
+    readonly dryRun?: boolean;
+    readonly json?: boolean;
+    readonly seams?: GhRestSeams;
+}
+export interface FeedbackFileResult {
+    readonly outcome: FeedbackFileOutcome;
+    readonly exitCode: 0 | 1 | 2;
+    readonly title: string;
+    readonly body: string;
+    readonly repo: string;
+    readonly issueUrl?: string | null;
+    readonly duplicateUrl?: string | null;
+    readonly message: string;
+}
+/** True when the resolved project root is the directive maintainer source checkout. */
+export declare function isMaintainerFrameworkRepo(projectRoot: string): boolean;
+/** Normalize a title for duplicate comparison (#1709). */
+export declare function normalizeForDedup(title: string): string;
+/** Build the upstream issue title for a framework-gap report. */
+export declare function buildFrameworkGapTitle(summary: string): string;
+/** Build the structured framework-gap issue body. */
+export declare function buildFrameworkGapBody(input: FeedbackGapInput): string;
+export interface DuplicateMatch {
+    readonly url: string;
+    readonly title: string;
+}
+/** Search open upstream issues for a normalized title match. */
+export declare function findDuplicateIssue(repo: string, title: string, seams?: GhRestSeams): DuplicateMatch | null;
+/** Core feedback:file workflow (#1709 gap escalation). */
+export declare function runFeedbackFile(options: FeedbackFileOptions): FeedbackFileResult;
+export interface FeedbackFileCliArgs {
+    summary?: string;
+    context?: string;
+    expected?: string;
+    actual?: string;
+    sessionNotes?: string;
+    confirm?: boolean;
+    dryRun?: boolean;
+    json?: boolean;
+    repo?: string;
+    projectRoot?: string;
+    error?: string;
+}
+/** Parse argv for feedback:file. */
+export declare function parseFeedbackFileArgs(argv: readonly string[]): FeedbackFileCliArgs;
+/** CLI entry for feedback:file. */
+export declare function feedbackFileMain(argv: readonly string[]): number;
+/** CLI module entrypoint for dispatch (#1709). */
+export declare function mainEntry(argv?: string[]): number;
+/** Convenience probe used in tests for project-root sentinel presence. */
+export declare function projectRootLooksLikeConsumer(projectRoot: string): boolean;
+//# sourceMappingURL=feedback-file.d.ts.map

package/dist/value/feedback-file.js

@@ -0,0 +1,353 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { isFrameworkRepoRoot } from "../check/orchestrator.js";
+import { isValueFeedbackPathAllowed, resolveValueFeedback } from "../policy/value-feedback.js";
+import { GhRestError, restCreateIssue, restIssueListPaginated, } from "../scm/gh-rest.js";
+import { resolveProjectRoot } from "../scope/project-context.js";
+export const DEFAULT_UPSTREAM_REPO = "deftai/directive";
+export const FRAMEWORK_GAP_TITLE_PREFIX = "[framework-gap]";
+function sanitizeOneLine(value) {
+    return value.replace(/\r?\n/g, " ").trim();
+}
+function sectionOrPlaceholder(value, placeholder) {
+    const trimmed = value?.trim() ?? "";
+    return trimmed.length > 0 ? trimmed : placeholder;
+}
+/** True when the resolved project root is the directive maintainer source checkout. */
+export function isMaintainerFrameworkRepo(projectRoot) {
+    return isFrameworkRepoRoot(resolve(projectRoot));
+}
+/** Normalize a title for duplicate comparison (#1709). */
+export function normalizeForDedup(title) {
+    return title
+        .trim()
+        .replace(/^\[framework-gap\]\s*/i, "")
+        .toLowerCase()
+        .replace(/[^\p{L}\p{N}]+/gu, " ")
+        .trim();
+}
+/** Build the upstream issue title for a framework-gap report. */
+export function buildFrameworkGapTitle(summary) {
+    const clean = sanitizeOneLine(summary);
+    if (clean.toLowerCase().startsWith(FRAMEWORK_GAP_TITLE_PREFIX.toLowerCase())) {
+        return clean;
+    }
+    return `${FRAMEWORK_GAP_TITLE_PREFIX} ${clean}`;
+}
+/** Build the structured framework-gap issue body. */
+export function buildFrameworkGapBody(input) {
+    const summary = sanitizeOneLine(input.summary);
+    const lines = [
+        "## Summary",
+        "",
+        summary,
+        "",
+        "## Context",
+        "",
+        sectionOrPlaceholder(input.context, "_(not provided)_"),
+        "",
+        "## Expected behavior",
+        "",
+        sectionOrPlaceholder(input.expected, "_(not provided)_"),
+        "",
+        "## Actual behavior / gap",
+        "",
+        sectionOrPlaceholder(input.actual, summary),
+        "",
+        "## Session notes",
+        "",
+        sectionOrPlaceholder(input.sessionNotes, "_(not provided)_"),
+        "",
+        "---",
+        "_Filed via `task feedback:file` from a directive consumer project (Refs #1709 value-feedback gap escalation)._",
+        "",
+    ];
+    return lines.join("\n");
+}
+/** Search open upstream issues for a normalized title match. */
+export function findDuplicateIssue(repo, title, seams = {}) {
+    const needle = normalizeForDedup(title);
+    if (needle.length === 0) {
+        return null;
+    }
+    const issues = restIssueListPaginated(repo, { state: "open", limit: 100, excludePulls: true }, seams);
+    for (const issue of issues) {
+        const issueTitle = typeof issue.title === "string" ? issue.title : "";
+        if (normalizeForDedup(issueTitle) === needle) {
+            const url = typeof issue.html_url === "string" ? issue.html_url : "";
+            if (url.length > 0) {
+                return { url, title: issueTitle };
+            }
+        }
+    }
+    return null;
+}
+function resolveRepo(options) {
+    const explicit = options.repo?.trim();
+    return explicit && explicit.length > 0 ? explicit : DEFAULT_UPSTREAM_REPO;
+}
+function isOffline() {
+    return process.env.DEFT_NO_NETWORK === "1";
+}
+function networkErrorMessage(prefix, err) {
+    const detail = err instanceof GhRestError ? err.message : String(err);
+    return `[deft feedback] ${prefix}: ${detail}\n`;
+}
+function buildConfirmationPrompt(title, body) {
+    return ("Draft framework-gap issue (not filed yet):\n\n" +
+        `Title: ${title}\n\n` +
+        `${body}\n` +
+        "Re-run with --confirm to file this issue upstream after reviewing the draft.\n");
+}
+/** Core feedback:file workflow (#1709 gap escalation). */
+export function runFeedbackFile(options) {
+    const summary = sanitizeOneLine(options.summary);
+    if (summary.length === 0) {
+        return {
+            outcome: "error-bad-args",
+            exitCode: 2,
+            title: "",
+            body: "",
+            repo: resolveRepo(options),
+            message: "Error: summary is required (pass --summary or a positional argument).\n",
+        };
+    }
+    const projectRootRaw = resolveProjectRoot(options.projectRoot ?? undefined);
+    if (projectRootRaw === null) {
+        return {
+            outcome: "error-config",
+            exitCode: 2,
+            title: buildFrameworkGapTitle(summary),
+            body: buildFrameworkGapBody(options),
+            repo: resolveRepo(options),
+            message: "Error: could not resolve project root. Pass --project-root or run from a directive consumer repo.\n",
+        };
+    }
+    const projectRoot = resolve(projectRootRaw);
+    const repo = resolveRepo(options);
+    const title = buildFrameworkGapTitle(summary);
+    const body = buildFrameworkGapBody(options);
+    if (isMaintainerFrameworkRepo(projectRoot)) {
+        return {
+            outcome: "skipped-maintainer",
+            exitCode: 0,
+            title,
+            body,
+            repo,
+            message: "[deft feedback] Skipped: maintainer framework repo detected; gap escalation targets consumer projects only.\n",
+        };
+    }
+    const policy = resolveValueFeedback(projectRoot);
+    if (!isValueFeedbackPathAllowed("upstreamPrompt", policy)) {
+        return {
+            outcome: "blocked-policy",
+            exitCode: 1,
+            title,
+            body,
+            repo,
+            message: "[deft feedback] Blocked: plan.policy.valueFeedback upstreamPrompt is OFF. " +
+                "Enable with `task policy:enable-value-feedback -- --confirm` and set upstreamPrompt, " +
+                "or inspect via `task policy:show --field=valueFeedback`.\n",
+        };
+    }
+    const offline = isOffline();
+    const dryRun = options.dryRun ?? false;
+    const seams = options.seams ?? {};
+    let dedupSkippedNote = "";
+    if (!offline) {
+        try {
+            const duplicate = findDuplicateIssue(repo, title, seams);
+            if (duplicate !== null) {
+                return {
+                    outcome: "blocked-duplicate",
+                    exitCode: 1,
+                    title,
+                    body,
+                    repo,
+                    duplicateUrl: duplicate.url,
+                    message: `[deft feedback] Duplicate detected: open issue ${duplicate.url} ` +
+                        `("${duplicate.title}") matches this report.\n`,
+                };
+            }
+        }
+        catch (err) {
+            return {
+                outcome: "error-network",
+                exitCode: 2,
+                title,
+                body,
+                repo,
+                message: networkErrorMessage("Duplicate search failed", err),
+            };
+        }
+    }
+    else {
+        dedupSkippedNote = "[deft feedback] Note: duplicate detection skipped (DEFT_NO_NETWORK=1).\n\n";
+    }
+    if (!options.confirm) {
+        return {
+            outcome: "draft",
+            exitCode: 1,
+            title,
+            body,
+            repo,
+            message: `${dedupSkippedNote}${buildConfirmationPrompt(title, body)}`,
+        };
+    }
+    if (dryRun || offline) {
+        return {
+            outcome: "draft",
+            exitCode: 0,
+            title,
+            body,
+            repo,
+            message: `${dedupSkippedNote}[deft feedback] Dry run: would file upstream issue in ${repo}.\n` +
+                `${buildConfirmationPrompt(title, body)}`,
+        };
+    }
+    try {
+        const created = restCreateIssue(repo, title, body, [], seams);
+        const issueUrl = typeof created.html_url === "string" && created.html_url.length > 0 ? created.html_url : null;
+        const number = created.number;
+        const urlLine = issueUrl ??
+            (typeof number === "number" ? `https://github.com/${repo}/issues/${number}` : null);
+        return {
+            outcome: "filed",
+            exitCode: 0,
+            title,
+            body,
+            repo,
+            issueUrl: urlLine,
+            message: urlLine !== null
+                ? `[deft feedback] Filed upstream issue: ${urlLine}\n`
+                : "[deft feedback] Issue filed upstream (URL unavailable in API response).\n",
+        };
+    }
+    catch (err) {
+        return {
+            outcome: "error-network",
+            exitCode: 2,
+            title,
+            body,
+            repo,
+            message: networkErrorMessage("Upstream filing failed", err),
+        };
+    }
+}
+/** Parse argv for feedback:file. */
+export function parseFeedbackFileArgs(argv) {
+    const out = {};
+    const positionals = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--confirm")
+            out.confirm = true;
+        else if (arg === "--dry-run")
+            out.dryRun = true;
+        else if (arg === "--json")
+            out.json = true;
+        else if (arg === "--summary") {
+            out.summary = argv[++i];
+        }
+        else if (arg?.startsWith("--summary=")) {
+            out.summary = arg.slice("--summary=".length);
+        }
+        else if (arg === "--context") {
+            out.context = argv[++i];
+        }
+        else if (arg?.startsWith("--context=")) {
+            out.context = arg.slice("--context=".length);
+        }
+        else if (arg === "--expected") {
+            out.expected = argv[++i];
+        }
+        else if (arg?.startsWith("--expected=")) {
+            out.expected = arg.slice("--expected=".length);
+        }
+        else if (arg === "--actual") {
+            out.actual = argv[++i];
+        }
+        else if (arg?.startsWith("--actual=")) {
+            out.actual = arg.slice("--actual=".length);
+        }
+        else if (arg === "--notes" || arg === "--session-notes") {
+            out.sessionNotes = argv[++i];
+        }
+        else if (arg?.startsWith("--notes=")) {
+            out.sessionNotes = arg.slice("--notes=".length);
+        }
+        else if (arg?.startsWith("--session-notes=")) {
+            out.sessionNotes = arg.slice("--session-notes=".length);
+        }
+        else if (arg === "--repo") {
+            out.repo = argv[++i];
+        }
+        else if (arg?.startsWith("--repo=")) {
+            out.repo = arg.slice("--repo=".length);
+        }
+        else if (arg === "--project-root") {
+            out.projectRoot = argv[++i];
+        }
+        else if (arg?.startsWith("--project-root=")) {
+            out.projectRoot = arg.slice("--project-root=".length);
+        }
+        else if (arg.startsWith("-")) {
+            return { ...out, error: `unrecognized argument: ${arg}` };
+        }
+        else {
+            positionals.push(arg);
+        }
+    }
+    if ((out.summary === undefined || out.summary.trim().length === 0) && positionals.length > 0) {
+        out.summary = positionals.join(" ");
+    }
+    return out;
+}
+/** CLI entry for feedback:file. */
+export function feedbackFileMain(argv) {
+    const args = parseFeedbackFileArgs(argv);
+    if (args.error !== undefined) {
+        process.stderr.write(`feedback:file: ${args.error}\n`);
+        return 2;
+    }
+    const result = runFeedbackFile({
+        summary: args.summary ?? "",
+        context: args.context,
+        expected: args.expected,
+        actual: args.actual,
+        sessionNotes: args.sessionNotes,
+        confirm: args.confirm,
+        dryRun: args.dryRun,
+        json: args.json,
+        repo: args.repo,
+        projectRoot: args.projectRoot,
+    });
+    if (args.json) {
+        process.stdout.write(`${JSON.stringify({
+            outcome: result.outcome,
+            exit_code: result.exitCode,
+            title: result.title,
+            body: result.body,
+            repo: result.repo,
+            issue_url: result.issueUrl ?? null,
+            duplicate_url: result.duplicateUrl ?? null,
+            message: result.message.trim(),
+        }, null, 2)}\n`);
+    }
+    else {
+        process.stdout.write(result.message);
+    }
+    return result.exitCode;
+}
+/** CLI module entrypoint for dispatch (#1709). */
+export function mainEntry(argv = process.argv.slice(2)) {
+    return feedbackFileMain(argv);
+}
+/** Convenience probe used in tests for project-root sentinel presence. */
+export function projectRootLooksLikeConsumer(projectRoot) {
+    const root = resolve(projectRoot);
+    return (existsSync(resolve(root, "xbrief")) ||
+        existsSync(resolve(root, "vbrief")) ||
+        existsSync(resolve(root, ".deft")));
+}
+//# sourceMappingURL=feedback-file.js.map

package/dist/value/friction-emit.d.ts

@@ -0,0 +1,10 @@
+import { type ValueFeedbackResolved } from "../policy/value-feedback.js";
+export interface FrictionEmitOptions {
+    readonly logPath?: string | null;
+    readonly policyOverride?: ValueFeedbackResolved;
+}
+/** Record friction signals for each contradictory gate detected by eval:health (#2339). */
+export declare function recordFrictionFromContradictoryGates(projectRoot: string, options?: FrictionEmitOptions): number;
+/** Session/work-boundary friction probe alias (#2339). */
+export declare function probeFrictionAtWorkBoundary(projectRoot: string, options?: FrictionEmitOptions): number;
+//# sourceMappingURL=friction-emit.d.ts.map

package/dist/value/friction-emit.js

@@ -0,0 +1,24 @@
+import { detectContradictoryGates } from "../eval/health.js";
+import { recordFrictionSignal } from "../events/attribution-ledger.js";
+import { isValueFeedbackPathAllowed, resolveValueFeedback, } from "../policy/value-feedback.js";
+/** Record friction signals for each contradictory gate detected by eval:health (#2339). */
+export function recordFrictionFromContradictoryGates(projectRoot, options = {}) {
+    const policy = options.policyOverride ?? resolveValueFeedback(projectRoot);
+    if (!isValueFeedbackPathAllowed("emitEvents", policy)) {
+        return 0;
+    }
+    const contradictions = detectContradictoryGates(projectRoot);
+    let recorded = 0;
+    for (const contradiction of contradictions) {
+        const record = recordFrictionSignal(projectRoot, "eval:health", `${contradiction.id}: ${contradiction.summary}`, { logPath: options.logPath, policyOverride: policy });
+        if (record !== null) {
+            recorded += 1;
+        }
+    }
+    return recorded;
+}
+/** Session/work-boundary friction probe alias (#2339). */
+export function probeFrictionAtWorkBoundary(projectRoot, options = {}) {
+    return recordFrictionFromContradictoryGates(projectRoot, options);
+}
+//# sourceMappingURL=friction-emit.js.map