@deftai/directive-core 0.80.0 → 0.81.0

package/dist/doctor/checks.d.ts

@@ -39,6 +39,12 @@ export declare const STALE_VBRIEF_CORE_SCHEMA_REL: string;
  * `directive update` instead. Advisory only (exit-exempt).
  */
 export declare function checkStaleXbriefSchemaDeposit(projectRoot: string, seams?: CheckSeams): CheckResult;
+/**
+ * #2591: advisory hint when a TypeScript project pins bare `typescript@7` alongside
+ * typescript-eslint without the `@typescript/typescript6` alias. Exit-exempt (like
+ * gitignore-coverage) — adoption guidance, not a broken install.
+ */
+export declare function checkTypescript7SideBySide(projectRoot: string, seams?: CheckSeams): CheckResult;
 /**
  * #2206: check that the consumer `.gitignore` carries the canonical Deft baseline
  * entries. Advisory (exit-exempt) because missing entries are an adoption risk, not

package/dist/doctor/checks.js

@@ -523,6 +523,142 @@ export function checkStaleXbriefSchemaDeposit(projectRoot, seams = {}) {
         },
     };
 }
+const TS7_SIDE_BY_SIDE_CHECK = "typescript-7-side-by-side";
+function depKeyIsTypescriptEslint(key) {
+    return key === "typescript-eslint" || key.startsWith("@typescript-eslint/");
+}
+function depKeysIncludeTypescriptEslint(keys) {
+    return keys.some(depKeyIsTypescriptEslint);
+}
+function depKeysIncludeEslint(keys) {
+    return keys.includes("eslint");
+}
+function typescriptValueIs7Bound(value) {
+    const v = value.trim();
+    if (!v || v.includes("@typescript/typescript6")) {
+        return false;
+    }
+    if (/npm:typescript@(?:[\^~>=<]*|\d*)7/i.test(v)) {
+        return true;
+    }
+    if (/^[\^~>=<]*7(?:\.\d|$)/.test(v)) {
+        return true;
+    }
+    if (/^7\.\d/.test(v)) {
+        return true;
+    }
+    return false;
+}
+function resolveTypescriptDepValue(deps, devDeps) {
+    if (typeof devDeps.typescript === "string") {
+        return devDeps.typescript;
+    }
+    if (typeof deps.typescript === "string") {
+        return deps.typescript;
+    }
+    return null;
+}
+/**
+ * #2591: advisory hint when a TypeScript project pins bare `typescript@7` alongside
+ * typescript-eslint without the `@typescript/typescript6` alias. Exit-exempt (like
+ * gitignore-coverage) — adoption guidance, not a broken install.
+ */
+export function checkTypescript7SideBySide(projectRoot, seams = {}) {
+    const packageJsonPath = join(projectRoot, "package.json");
+    const text = readText(packageJsonPath, seams);
+    if (text === null) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "skip",
+            detail: "package.json not found; nothing to inspect for TypeScript side-by-side layout.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "skip",
+            detail: "package.json is unreadable; skipping TypeScript side-by-side check.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "skip",
+            detail: "package.json has no dependency sections; skipping TypeScript side-by-side check.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    const record = parsed;
+    const deps = typeof record.dependencies === "object" && record.dependencies !== null
+        ? record.dependencies
+        : {};
+    const devDeps = typeof record.devDependencies === "object" && record.devDependencies !== null
+        ? record.devDependencies
+        : {};
+    const depKeys = [...Object.keys(deps), ...Object.keys(devDeps)];
+    if (depKeys.length === 0) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "skip",
+            detail: "package.json has no dependency sections; skipping TypeScript side-by-side check.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    if (!depKeysIncludeTypescriptEslint(depKeys)) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "pass",
+            detail: "No typescript-eslint packages declared; TypeScript 7 side-by-side alias not required.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    if (!depKeysIncludeEslint(depKeys)) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "pass",
+            detail: "eslint is not declared; TypeScript 7 side-by-side alias not required.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    const typescriptValue = resolveTypescriptDepValue(deps, devDeps);
+    if (typescriptValue === null) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "pass",
+            detail: "No typescript dependency declared; TypeScript 7 side-by-side alias not required.",
+            data: { package_json_path: packageJsonPath },
+        };
+    }
+    if (!typescriptValueIs7Bound(typescriptValue)) {
+        return {
+            name: TS7_SIDE_BY_SIDE_CHECK,
+            status: "pass",
+            detail: "typescript is not pinned to 7.x (or uses the @typescript/typescript6 alias); side-by-side layout not required.",
+            data: {
+                package_json_path: packageJsonPath,
+                typescript: typescriptValue,
+            },
+        };
+    }
+    return {
+        name: TS7_SIDE_BY_SIDE_CHECK,
+        status: "fail",
+        detail: "typescript resolves to 7.x without the @typescript/typescript6 alias while typescript-eslint and eslint are present. " +
+            "Until TS 7.1, use the side-by-side alias pattern in languages/typescript.md § TypeScript 7 side-by-side (pre-7.1) " +
+            "(Cartograph #111: keep typescript on npm:@typescript/typescript6 and install TS 7 under @typescript/native).",
+        data: {
+            package_json_path: packageJsonPath,
+            typescript: typescriptValue,
+            suggested_fix: "languages/typescript.md#typescript-7-side-by-side-pre-71",
+        },
+    };
+}
 /**
  * #2206: check that the consumer `.gitignore` carries the canonical Deft baseline
  * entries. Advisory (exit-exempt) because missing entries are an adoption risk, not
@@ -580,6 +716,7 @@ export function deriveExitCode(checks, errors) {
         "manifest-version-reportable",
         "gitignore-coverage",
         "stale-xbrief-schema-deposit",
+        "typescript-7-side-by-side",
     ]);
     if (errors.length > 0 || checks.some((c) => c.status === "error")) {
         return 2;
@@ -621,6 +758,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
         checks.push(checkCanonicalVendoredNpmSignpost(projectRoot, seams));
         checks.push(checkStaleXbriefSchemaDeposit(projectRoot, seams));
         checks.push(checkGitignoreCoverage(projectRoot, seams));
+        checks.push(checkTypescript7SideBySide(projectRoot, seams));
         return {
             projectRoot,
             installRoot: null,
@@ -638,6 +776,7 @@ export function runChecksImpl(projectRoot, seams = {}) {
     checks.push(checkCanonicalVendoredNpmSignpost(projectRoot, seams));
     checks.push(checkStaleXbriefSchemaDeposit(projectRoot, seams));
     checks.push(checkGitignoreCoverage(projectRoot, seams));
+    checks.push(checkTypescript7SideBySide(projectRoot, seams));
     return {
         projectRoot,
         installRoot,

package/dist/doctor/main.js

@@ -424,7 +424,8 @@ function runInstallIntegrityChecks(projectRoot, sink, addFinding, seams) {
                 name === "canonical-vendored-npm-signpost" ||
                 name === "manifest-version-reportable" ||
                 name === "gitignore-coverage" ||
-                name === "stale-xbrief-schema-deposit") &&
+                name === "stale-xbrief-schema-deposit" ||
+                name === "typescript-7-side-by-side") &&
                 status === "fail") {
                 sink.warn(`${name}: ${detail}`);
                 addFinding({

package/dist/policy/index.d.ts

@@ -5,6 +5,7 @@ export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
+export * from "./product-signal.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";

package/dist/policy/index.js

@@ -1,4 +1,5 @@
 import { readPlanPolicy } from "./plan-extensions.js";
+import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
 import { FIELD_RUNTIME_AUTHORITY, FIELD_RUNTIME_AUTHORITY_CLI_ALIAS, inspectRuntimeAuthority, } from "./runtime-authority.js";
 import { FIELD_STALENESS_TICKLER, FIELD_STALENESS_TICKLER_CLI_ALIAS, inspectStalenessTickler, } from "./staleness-tickler.js";
@@ -11,6 +12,7 @@ export * from "./decisions.js";
 export * from "./disclosure.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
+export * from "./product-signal.js";
 export * from "./resolve.js";
 export * from "./runtime-authority.js";
 export * from "./staleness-tickler.js";
@@ -220,6 +222,15 @@ function inspectSwarmSubagentBackend(data) {
         source: "default-on-error",
     };
 }
+function inspectProductSignalField(data, projectRoot) {
+    const field = inspectProductSignal(data, projectRoot);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 function inspectValueFeedbackField(data, projectRoot) {
     const field = inspectValueFeedback(data, projectRoot);
     return {
@@ -261,6 +272,7 @@ const REGISTERED_POLICIES = [
     inspectSwarmSubagentBackend,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
+    inspectProductSignalField,
     inspectValueFeedbackField,
 ];
 /** Walk registered inspectors and return one row per field (#1148). */
@@ -272,11 +284,13 @@ export function inspectAllPolicies(projectRoot) {
 export function inspectOnePolicy(name, projectRoot) {
     const normalized = name === FIELD_VALUE_FEEDBACK_CLI_ALIAS
         ? FIELD_VALUE_FEEDBACK
-        : name === FIELD_STALENESS_TICKLER_CLI_ALIAS
-            ? FIELD_STALENESS_TICKLER
-            : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
-                ? FIELD_RUNTIME_AUTHORITY
-                : name;
+        : name === FIELD_PRODUCT_SIGNAL_CLI_ALIAS
+            ? FIELD_PRODUCT_SIGNAL
+            : name === FIELD_STALENESS_TICKLER_CLI_ALIAS
+                ? FIELD_STALENESS_TICKLER
+                : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
+                    ? FIELD_RUNTIME_AUTHORITY
+                    : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

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

@@ -0,0 +1,45 @@
+/** Canonical registered policy field name (#2693). */
+export declare const FIELD_PRODUCT_SIGNAL = "plan.policy.productSignal";
+/** Short alias for `policy:show --field=productSignal`. */
+export declare const FIELD_PRODUCT_SIGNAL_CLI_ALIAS = "productSignal";
+export declare const DEFAULT_PRODUCT_SIGNAL_ENABLED = false;
+/** Baked-in default private sink (#2693 D6). */
+export declare const DEFAULT_PRODUCT_SIGNAL_SINK_REPO = "deftai/product-signal";
+export interface ProductSignalConfig {
+    readonly enabled: boolean;
+    readonly sinkRepo: string;
+}
+export type ProductSignalSource = "typed" | "default" | "default-on-error";
+export interface ProductSignalResolved extends ProductSignalConfig {
+    readonly source: ProductSignalSource;
+    readonly error: string | null;
+}
+export declare const PRODUCT_SIGNAL_CAPABILITY_COST_DISCLOSURE: string;
+/** Validate a `plan.policy.productSignal` payload. */
+export declare function validateProductSignal(value: unknown): string[];
+/** Resolve `plan.policy.productSignal` from PROJECT-DEFINITION (#2693). */
+export declare function resolveProductSignal(projectRoot: string): ProductSignalResolved;
+/** Human-readable status line for CLI surfaces. */
+export declare function formatProductSignalStatusLine(policy: ProductSignalResolved): string;
+export interface ProductSignalPolicyField {
+    readonly name: typeof FIELD_PRODUCT_SIGNAL;
+    readonly current: ProductSignalConfig;
+    readonly default: ProductSignalConfig;
+    readonly source: string;
+}
+/** Inspector row for `policy:show --field=productSignal`. */
+export declare function inspectProductSignal(data: Record<string, unknown> | null, projectRoot?: string): ProductSignalPolicyField;
+export interface EnableProductSignalOptions {
+    readonly confirm: boolean;
+    readonly actor?: string;
+    readonly note?: string;
+    readonly sinkRepo?: string;
+}
+export interface EnableProductSignalResult {
+    readonly exitCode: 0 | 1 | 2;
+    readonly stdout: string;
+    readonly changed: boolean;
+}
+/** Persist `productSignal.enabled=true` after capability-cost disclosure (#2693). */
+export declare function enableProductSignal(projectRoot: string, options: EnableProductSignalOptions): EnableProductSignalResult;
+//# sourceMappingURL=product-signal.d.ts.map

package/dist/policy/product-signal.js

@@ -0,0 +1,210 @@
+import { readFileSync } from "node:fs";
+import { atomicWriteProjectDefinition, projectDefinitionMutationLock, } from "../vbrief-build/project-definition-io.js";
+import { migrateLegacyPolicyKey, PLAN_POLICY_KEY, readPlanPolicy } from "./plan-extensions.js";
+import { policyColonInvocation } from "./policy-invocation.js";
+import { appendAuditLog, loadProjectDefinition, projectDefinitionPath } from "./resolve.js";
+/** Canonical registered policy field name (#2693). */
+export const FIELD_PRODUCT_SIGNAL = "plan.policy.productSignal";
+/** Short alias for `policy:show --field=productSignal`. */
+export const FIELD_PRODUCT_SIGNAL_CLI_ALIAS = "productSignal";
+export const DEFAULT_PRODUCT_SIGNAL_ENABLED = false;
+/** Baked-in default private sink (#2693 D6). */
+export const DEFAULT_PRODUCT_SIGNAL_SINK_REPO = "deftai/product-signal";
+export const PRODUCT_SIGNAL_CAPABILITY_COST_DISCLOSURE = "\u26a0 Capability-cost disclosure -- enabling product signal opts into " +
+    "consented qualitative check-ins that may submit minimized local summaries " +
+    "to a private GitHub sink when you also grant install-level consent.\n" +
+    "  \u2022 Default OFF; no ambient consent nag while disabled.\n" +
+    "  \u2022 Outbound requires enable + recorded consent (`product-signal:consent`).\n" +
+    "  \u2022 Payloads include install context and windowed value/health/helped summaries " +
+    "(not raw ledgers or chat).\n" +
+    "  \u2022 Inspect: `" +
+    policyColonInvocation("show", " --field=productSignal") +
+    "` and `task product-signal:status`.\n" +
+    "  \u2022 Reversible: set `enabled: false` or revoke consent.\n" +
+    "  \u2022 Changes are recorded to meta/policy-changes.log for auditability.";
+function defaultResolved(source, error = null) {
+    return {
+        enabled: DEFAULT_PRODUCT_SIGNAL_ENABLED,
+        sinkRepo: DEFAULT_PRODUCT_SIGNAL_SINK_REPO,
+        source,
+        error,
+    };
+}
+/** Validate a `plan.policy.productSignal` payload. */
+export function validateProductSignal(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_PRODUCT_SIGNAL} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    if ("enabled" in rec && typeof rec.enabled !== "boolean") {
+        errors.push(`${FIELD_PRODUCT_SIGNAL}.enabled must be a boolean`);
+    }
+    if ("sinkRepo" in rec && typeof rec.sinkRepo !== "string") {
+        errors.push(`${FIELD_PRODUCT_SIGNAL}.sinkRepo must be a string`);
+    }
+    return errors;
+}
+function resolveFromPolicyBlock(raw) {
+    const errors = validateProductSignal(raw);
+    if (errors.length > 0) {
+        return defaultResolved("default-on-error", errors[0] ?? "invalid productSignal block");
+    }
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return defaultResolved("default");
+    }
+    const block = raw;
+    const enabled = typeof block.enabled === "boolean" ? block.enabled : DEFAULT_PRODUCT_SIGNAL_ENABLED;
+    const sinkRepo = typeof block.sinkRepo === "string" && block.sinkRepo.trim().length > 0
+        ? block.sinkRepo.trim()
+        : DEFAULT_PRODUCT_SIGNAL_SINK_REPO;
+    return {
+        enabled,
+        sinkRepo,
+        source: "typed",
+        error: null,
+    };
+}
+/** Resolve `plan.policy.productSignal` from PROJECT-DEFINITION (#2693). */
+export function resolveProductSignal(projectRoot) {
+    const [data, err] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return defaultResolved("default-on-error", err);
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("productSignal" in policyBlock)) {
+        return defaultResolved("default");
+    }
+    return resolveFromPolicyBlock(policyBlock.productSignal);
+}
+/** Human-readable status line for CLI surfaces. */
+export function formatProductSignalStatusLine(policy) {
+    return (`[deft policy] productSignal enabled=${String(policy.enabled)} ` +
+        `sinkRepo=${policy.sinkRepo}.`);
+}
+function fieldFromResolved(resolved) {
+    return {
+        name: FIELD_PRODUCT_SIGNAL,
+        current: {
+            enabled: resolved.enabled,
+            sinkRepo: resolved.sinkRepo,
+        },
+        default: {
+            enabled: DEFAULT_PRODUCT_SIGNAL_ENABLED,
+            sinkRepo: DEFAULT_PRODUCT_SIGNAL_SINK_REPO,
+        },
+        source: resolved.source,
+    };
+}
+/** Inspector row for `policy:show --field=productSignal`. */
+export function inspectProductSignal(data, projectRoot) {
+    if (data === null) {
+        return fieldFromResolved(defaultResolved("default"));
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("productSignal" in policyBlock)) {
+        if (projectRoot !== undefined) {
+            return fieldFromResolved(resolveProductSignal(projectRoot));
+        }
+        return fieldFromResolved(defaultResolved("default"));
+    }
+    return fieldFromResolved(resolveFromPolicyBlock(policyBlock.productSignal));
+}
+/** Persist `productSignal.enabled=true` after capability-cost disclosure (#2693). */
+export function enableProductSignal(projectRoot, options) {
+    if (!options.confirm) {
+        return {
+            exitCode: 1,
+            stdout: `${PRODUCT_SIGNAL_CAPABILITY_COST_DISCLOSURE}\n\n` +
+                `Re-run with --confirm to apply: task product-signal:enable -- --confirm\n`,
+            changed: false,
+        };
+    }
+    const path = projectDefinitionPath(projectRoot);
+    try {
+        const { changed } = projectDefinitionMutationLock(projectRoot, () => {
+            const parsed = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+            if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error(`PROJECT-DEFINITION at ${path} top-level value is not a JSON object`);
+            }
+            const data = parsed;
+            if (typeof data.plan !== "object" || data.plan === null || Array.isArray(data.plan)) {
+                if (data.plan === undefined) {
+                    data.plan = {};
+                }
+                else {
+                    throw new Error("PROJECT-DEFINITION 'plan' is not an object");
+                }
+            }
+            const plan = data.plan;
+            migrateLegacyPolicyKey(plan);
+            const existingPolicy = plan[PLAN_POLICY_KEY];
+            if (typeof existingPolicy !== "object" ||
+                existingPolicy === null ||
+                Array.isArray(existingPolicy)) {
+                if (existingPolicy === undefined) {
+                    plan[PLAN_POLICY_KEY] = {};
+                }
+                else {
+                    throw new Error("plan.policy is not an object");
+                }
+            }
+            const policyBlock = plan[PLAN_POLICY_KEY];
+            const previous = policyBlock.productSignal;
+            const prevObj = typeof previous === "object" && previous !== null && !Array.isArray(previous)
+                ? previous
+                : {};
+            const sinkRepo = options.sinkRepo?.trim() ||
+                (typeof prevObj.sinkRepo === "string" && prevObj.sinkRepo.trim().length > 0
+                    ? prevObj.sinkRepo.trim()
+                    : DEFAULT_PRODUCT_SIGNAL_SINK_REPO);
+            const nextBlock = { enabled: true, sinkRepo };
+            const previousNormalized = resolveFromPolicyBlock(previous);
+            const changedFlag = previousNormalized.enabled !== nextBlock.enabled ||
+                previousNormalized.sinkRepo !== nextBlock.sinkRepo;
+            policyBlock.productSignal = nextBlock;
+            if (changedFlag) {
+                atomicWriteProjectDefinition(path, data);
+            }
+            const actor = options.actor ?? "task product-signal:enable";
+            const note = options.note ?? "";
+            const parts = [
+                `actor=${actor}`,
+                "productSignal.enabled=true",
+                `sinkRepo=${sinkRepo}`,
+                `previous=${JSON.stringify(previous ?? null)}`,
+            ];
+            if (note) {
+                parts.push(`note=${note.replace(/\n/g, " ").replace(/\r/g, " ")}`);
+            }
+            appendAuditLog(projectRoot, parts.join(" "));
+            return { changed: changedFlag };
+        });
+        const resolved = resolveProductSignal(projectRoot);
+        const lines = [
+            `\u2713 ${FIELD_PRODUCT_SIGNAL}.enabled=true (product-signal ON).`,
+            changed
+                ? "  audit: meta/policy-changes.log updated."
+                : "  no-op: value already matched (audit entry still appended for trail).",
+            formatProductSignalStatusLine(resolved),
+        ];
+        return { exitCode: 0, stdout: `${lines.join("\n")}\n`, changed };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("PROJECT-DEFINITION not found")) {
+            return { exitCode: 2, stdout: `\u274c ${message}\n`, changed: false };
+        }
+        return { exitCode: 2, stdout: `\u274c Config error: ${message}\n`, changed: false };
+    }
+}
+//# sourceMappingURL=product-signal.js.map

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