@deftai/directive-core 0.95.0 → 0.96.0

package/dist/scope/promote-path.js

@@ -0,0 +1,105 @@
+/**
+ * Shared single-path promote (proposed/ → pending/) with optional triage audit linkage (#1136).
+ */
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { append, canonicalLogPath, newDecisionId } from "./audit-log.js";
+import { resolveProjectRoot } from "./project-context.js";
+import { recordWipCapOverride, runTransition } from "./transition.js";
+import { utcNowIso } from "./vbrief-json.js";
+import { canonicalRelpath } from "./vbrief-ref.js";
+import { checkWipCap, formatWipCapRefusal } from "./wip-cap-check.js";
+/**
+ * Promote a single proposed-scope path to pending/, enforcing WIP and
+ * optionally recording from_issue / cache_decision_id on the scope audit log.
+ */
+export function promotePath(filePath, options = {}) {
+    const root = resolveProjectRoot(options.projectRoot);
+    if (root === null) {
+        return {
+            ok: false,
+            message: "Cannot determine project root. Pass --project-root PATH, set $DEFT_PROJECT_ROOT, or run from inside a directory tree that contains vbrief/ or .git/ (#535).",
+            exitCode: 2,
+        };
+    }
+    const resolved = resolve(filePath);
+    if (!existsSync(resolved)) {
+        return { ok: false, message: `File not found: ${resolved}`, exitCode: 2 };
+    }
+    const capCheck = checkWipCap(root, options.force === true);
+    if (!capCheck.allowed) {
+        return {
+            ok: false,
+            message: formatWipCapRefusal(capCheck),
+            exitCode: 1,
+        };
+    }
+    const now = options.now ?? new Date();
+    const result = runTransition("promote", resolved, now);
+    if (!result.ok) {
+        return { ok: false, message: result.message, exitCode: 1 };
+    }
+    const basename = resolved.split(/[/\\]/).pop() ?? "";
+    // Destination after promote is sibling pending/ under the same lifecycle root.
+    const lifecycleRoot = dirname(dirname(resolved));
+    const destPath = join(lifecycleRoot, "pending", basename);
+    let auditEntry = null;
+    const shouldAudit = options.alwaysAudit === true ||
+        options.fromIssue !== undefined ||
+        options.forceNoCache === true ||
+        options.cacheDecisionId !== undefined ||
+        options.cacheStateAtPromote !== undefined;
+    if (shouldAudit) {
+        try {
+            const entry = {
+                decision_id: newDecisionId(),
+                timestamp: utcNowIso(now),
+                action: "promote",
+                vbrief_path: canonicalRelpath(destPath, root),
+                from_status: "proposed",
+                to_status: "pending",
+                actor: options.actor ?? "operator",
+            };
+            if (options.fromIssue !== undefined) {
+                entry.from_issue = options.fromIssue;
+            }
+            if (options.cacheDecisionId !== undefined) {
+                entry.cache_decision_id = options.cacheDecisionId;
+            }
+            if (options.cacheStateAtPromote !== undefined) {
+                entry.cache_state_at_promote = options.cacheStateAtPromote;
+            }
+            if (options.forceNoCache === true) {
+                entry.force_no_cache = true;
+            }
+            append(entry, canonicalLogPath(root));
+            auditEntry = entry;
+        }
+        catch (err) {
+            if (options.requireAudit === true) {
+                return {
+                    ok: false,
+                    message: `Promoted ${basename} to pending/ but required scope audit failed: ${String(err)}. ` +
+                        `Artifact is in pending/; re-run promote will no-op once audit is writable.`,
+                    exitCode: 1,
+                    destPath,
+                    auditEntry: null,
+                    wipCapOverride: capCheck.forceOverride,
+                };
+            }
+            /* best-effort audit for plain path promote */
+        }
+    }
+    if (capCheck.forceOverride) {
+        recordWipCapOverride(destPath, root, capCheck, now);
+    }
+    return {
+        ok: true,
+        message: result.message,
+        exitCode: 0,
+        destPath,
+        auditEntry,
+        wipCapOverride: capCheck.forceOverride,
+    };
+}
+//# sourceMappingURL=promote-path.js.map

package/dist/swarm/routing.d.ts

@@ -9,7 +9,7 @@ export declare const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export declare const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export declare const HARNESS_BOUND_PROVIDERS: Set<string>;
-/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875). */
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875 / #3134). */
 export declare const ROUTING_GATED_DISPATCH_PROVIDERS: Set<string>;
 export interface RouteDecision {
     model: string | null;
@@ -55,7 +55,9 @@ export declare function dispatchProviderFromRuntime(runtimeMode: string): string
  * Separate from `runtime_mode` (#1557): Cursor sessions may carry
  * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
  * `cursor` for model selection (#1877). OpenClaw routes under `openclaw` when
- * `sessions_spawn` / OPENCLAW signals are present (#2875).
+ * `sessions_spawn` / OPENCLAW signals are present (#2875). Claude Code routes
+ * under `claude` when Claude-unique signals are present (#3134) — never via bare
+ * Task (that would misclassify as cursor).
  */
 export declare function resolveDispatchProvider(environ?: NodeJS.ProcessEnv): string;
 /**

package/dist/swarm/routing.js

@@ -33,8 +33,13 @@ export const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export const HARNESS_BOUND_PROVIDERS = new Set(["grok"]);
-/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875). */
-export const ROUTING_GATED_DISPATCH_PROVIDERS = new Set(["cursor", "grok", "openclaw"]);
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877 / #2875 / #3134). */
+export const ROUTING_GATED_DISPATCH_PROVIDERS = new Set([
+    "cursor",
+    "grok",
+    "openclaw",
+    "claude",
+]);
 const TRUTHY_ENV = new Set(["1", "true", "yes", "on"]);
 function envTruthy(environ, name) {
     return TRUTHY_ENV.has((environ[name] ?? "").trim().toLowerCase());
@@ -153,6 +158,9 @@ export function dispatchProviderFromRuntime(runtimeMode) {
     if (normalized.includes("openclaw")) {
         return "openclaw";
     }
+    if (normalized.includes("claude")) {
+        return "claude";
+    }
     if (normalized.includes("grok")) {
         return "grok";
     }
@@ -166,13 +174,24 @@ export function dispatchProviderFromRuntime(runtimeMode) {
  * Separate from `runtime_mode` (#1557): Cursor sessions may carry
  * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
  * `cursor` for model selection (#1877). OpenClaw routes under `openclaw` when
- * `sessions_spawn` / OPENCLAW signals are present (#2875).
+ * `sessions_spawn` / OPENCLAW signals are present (#2875). Claude Code routes
+ * under `claude` when Claude-unique signals are present (#3134) — never via bare
+ * Task (that would misclassify as cursor).
  */
 export function resolveDispatchProvider(environ = process.env) {
     if (envTruthy(environ, "CURSOR_COMPOSER") || envTruthy(environ, "CURSOR_AGENT")) {
         return "cursor";
     }
     const runtime = (environ.DEFT_AGENT_RUNTIME ?? "").trim().toLowerCase();
+    // Claude Code before OpenClaw/CI so CLAUDECODE / DEFT_PROBE_CLAUDE_CODE win (#3134).
+    if (envTruthy(environ, "DEFT_PROBE_CLAUDE_CODE") ||
+        envTruthy(environ, "DEFT_HAS_CLAUDE_AGENT") ||
+        envTruthy(environ, "CLAUDECODE") ||
+        envTruthy(environ, "CLAUDE_CODE") ||
+        runtime === "claude-code" ||
+        runtime === "claude") {
+        return "claude";
+    }
     if (envTruthy(environ, "OPENCLAW") ||
         envTruthy(environ, "DEFT_HAS_SESSIONS_SPAWN") ||
         envTruthy(environ, "DEFT_PROBE_SESSIONS_SPAWN") ||
@@ -191,7 +210,10 @@ export function resolveDispatchProvider(environ = process.env) {
             !envTruthy(environ, "CURSOR_COMPOSER") &&
             !envTruthy(environ, "CURSOR_AGENT") &&
             !envTruthy(environ, "OPENCLAW") &&
-            !envTruthy(environ, "DEFT_HAS_SESSIONS_SPAWN"))) {
+            !envTruthy(environ, "DEFT_HAS_SESSIONS_SPAWN") &&
+            !envTruthy(environ, "CLAUDECODE") &&
+            !envTruthy(environ, "CLAUDE_CODE") &&
+            !envTruthy(environ, "DEFT_PROBE_CLAUDE_CODE"))) {
         return "cloud-headless";
     }
     return "unknown";

package/dist/triage/actions/index.js

@@ -4,6 +4,8 @@ import { cacheGet } from "../../cache/operations.js";
 import { ingestSingleForAccept as ingestSingleForAcceptTs } from "../../intake/issue-ingest.js";
 import { call } from "../../scm/call.js";
 import { ScmStubError } from "../../scm/errors.js";
+import { findLifecycleArtifactsForIssue, findProposedArtifactsForIssue, promoteFromIssue, } from "../../scope/promote-from-issue.js";
+import { promotePath } from "../../scope/promote-path.js";
 import { createCandidatesLog, findByIssue, resolveAuditLogPath, rollbackAuditEntry, } from "./candidates-log.js";
 import { TriageError, UpstreamCloseError } from "./errors.js";
 import { parseResumeOn } from "./resume-on.js";
@@ -62,7 +64,8 @@ function defaultIssueIngest() {
             // Delegate to the native TS intake path (#2350). The legacy Python
             // `scripts/issue_ingest.py` shell-out was orphaned when #1933 removed the
             // Python surface, leaving `triage:accept` raising ModuleNotFoundError.
-            ingestSingleForAcceptTs(issueNumber, repo, { projectRoot });
+            const [, path] = ingestSingleForAcceptTs(issueNumber, repo, { projectRoot });
+            return path;
         },
     };
 }
@@ -207,24 +210,81 @@ function ensureRejectedLabelApplied(deps, issueNumber, repo) {
         writeErr(`triage_actions: reject #${issueNumber} (${repo}) closed successfully but the '${REJECTED_LABEL}' label is missing and auto-create/re-add failed: ${healExc instanceof Error ? healExc.message : String(healExc)}`);
     }
 }
+/**
+ * After a successful accept (or idempotent re-accept), promote proposed → pending (#1136).
+ * Surfaces WIP-cap refusals with the same messaging as scope:promote.
+ */
+function runAutoPromote(issueNumber, repo, projectRoot, decisionId, ingestedPath, force) {
+    // Already pending for this issue → idempotent success (repeat accept --auto-promote).
+    const pending = findLifecycleArtifactsForIssue(projectRoot, issueNumber, {
+        folder: "pending",
+        repo,
+    });
+    if (pending.length >= 1) {
+        return;
+    }
+    let path = typeof ingestedPath === "string" && ingestedPath.length > 0 ? ingestedPath : null;
+    if (path === null) {
+        const matches = findProposedArtifactsForIssue(projectRoot, issueNumber, repo);
+        if (matches.length === 1) {
+            path = matches[0] ?? null;
+        }
+        else if (matches.length > 1) {
+            throw new TriageError(`accept #${issueNumber} (${repo}): --auto-promote found multiple proposed artifacts:\n` +
+                matches.map((p) => `  - ${p}`).join("\n") +
+                `\nPromote one with: task scope:promote -- <path>`);
+        }
+    }
+    if (path === null) {
+        // Fall back to full from-issue resolution (may still fail on missing artifact).
+        const fromIssue = promoteFromIssue({
+            issueNumber,
+            repo,
+            projectRoot,
+            force: force === true,
+        });
+        if (!fromIssue.ok) {
+            throw new TriageError(`accept #${issueNumber} (${repo}): accept recorded but --auto-promote failed: ${fromIssue.message}`);
+        }
+        return;
+    }
+    const result = promotePath(path, {
+        projectRoot,
+        force: force === true,
+        fromIssue: issueNumber,
+        cacheDecisionId: decisionId,
+        cacheStateAtPromote: "accept",
+        requireAudit: true,
+    });
+    if (!result.ok) {
+        throw new TriageError(`accept #${issueNumber} (${repo}): accept recorded but --auto-promote failed: ${result.message}`);
+    }
+}
 /** Record an accept audit entry and delegate vBRIEF authoring to issue_ingest. */
 export function accept(issueNumber, repo, deps, options = {}) {
     const projectRoot = options.projectRoot ?? process.cwd();
     const actor = resolveActor(options.actor);
     const prior = isIdempotentRepeat(deps, issueNumber, repo, "accept", projectRoot);
     if (prior !== null) {
+        if (options.autoPromote === true) {
+            runAutoPromote(issueNumber, repo, projectRoot, prior.decision_id, null, options.force);
+        }
         return prior.decision_id;
     }
     const entry = buildEntry(deps, "accept", issueNumber, repo, actor);
     const logPath = logPathFor(projectRoot);
     const decisionId = deps.candidatesLog.append(entry, { path: logPath });
+    let ingestedPath = null;
     try {
-        deps.issueIngest.ingestSingleForAccept(issueNumber, repo, { projectRoot });
+        ingestedPath = deps.issueIngest.ingestSingleForAccept(issueNumber, repo, { projectRoot });
     }
     catch (exc) {
         rollbackAuditEntry(decisionId, projectRoot, logPath);
         throw new TriageError(`accept #${issueNumber} (${repo}): issue:ingest delegation failed; audit entry rolled back. Cause: ${exc instanceof Error ? exc.message : String(exc)}`);
     }
+    if (options.autoPromote === true) {
+        runAutoPromote(issueNumber, repo, projectRoot, decisionId, typeof ingestedPath === "string" ? ingestedPath : null, options.force);
+    }
     return decisionId;
 }
 /** Close upstream, best-effort label, record reject audit entry. */

package/dist/triage/actions/types.d.ts

@@ -21,9 +21,12 @@ export interface CandidatesLog {
     newDecisionId(): string;
 }
 export interface IssueIngest {
+    /**
+     * Ingest issue into proposed/; return absolute path when known (#1136 auto-promote).
+     */
     ingestSingleForAccept(issueNumber: number, repo: string, options?: {
         projectRoot?: string;
-    }): void;
+    }): string | null | undefined;
 }
 export interface ScmRunner {
     call(source: string, verb: string, args: readonly string[], options?: {
@@ -44,6 +47,10 @@ export interface TriageActionsDeps {
 export interface AcceptOptions {
     actor?: string | null;
     projectRoot?: string;
+    /** After accept+ingest, promote proposed → pending (#1136). */
+    autoPromote?: boolean;
+    /** WIP-cap override for the auto-promote leg. */
+    force?: boolean;
 }
 export interface RejectOptions {
     actor?: string | null;

package/dist/triage/author-filter.d.ts

@@ -0,0 +1,51 @@
+/** Injectable authenticated-login resolver (tests inject; production uses gh). */
+export type ResolveAuthenticatedLogin = () => string | null;
+export interface AuthorFilter {
+    /** Raw CLI value before resolution (e.g. `@me` or `alice,bob`). */
+    readonly raw: string;
+    /** Resolved allow-list logins (exact match; case-sensitive like bulk). */
+    readonly allowLogins: readonly string[];
+    /** True when any token was `@me` / `--author-mine`. */
+    readonly usedMe: boolean;
+    /** Header/digest display string. */
+    readonly display: string;
+}
+export interface AuthorFilterResolveResult {
+    readonly filter?: AuthorFilter;
+    readonly error?: string;
+}
+export interface AuthorPartitionResult<T> {
+    readonly matched: readonly T[];
+    readonly unknownCount: number;
+    readonly nonMatchingCount: number;
+}
+/** Split comma allow-list; trim; drop empties. */
+export declare function parseAuthorTokens(raw: string): string[];
+/**
+ * Resolve `@me` (and bare tokens) into an AuthorFilter.
+ * Returns error when raw is empty/whitespace-only or `@me` cannot be resolved.
+ */
+export declare function resolveAuthorFilter(raw: string, resolveMe?: ResolveAuthenticatedLogin | null): AuthorFilterResolveResult;
+/**
+ * Default `@me` resolution via live `gh` (not ghx — multi-arg api --jq; #2275 / #954).
+ */
+export declare function defaultResolveAuthenticatedLogin(): string | null;
+/** Login from a CachedIssue.author string (empty = unknown). */
+export declare function normalizeAuthorLogin(login: string | null | undefined): string | null;
+/**
+ * Login from a raw cache payload (author.login / user.login / string author).
+ * Empty / missing → null (unknown).
+ */
+export declare function authorLoginFromRawIssue(issue: Record<string, unknown> | null | undefined): string | null;
+/** Exact allow-list match (bulk parity). Unknown/missing never matches. */
+export declare function matchesAuthorFilter(login: string | null | undefined, filter: AuthorFilter): boolean;
+/**
+ * Partition items by author filter. Unknown (missing login) counted separately
+ * and excluded from matched — callers disclose unknownCount in headers.
+ */
+export declare function partitionByAuthorFilter<T>(items: readonly T[], getLogin: (item: T) => string | null | undefined, filter: AuthorFilter): AuthorPartitionResult<T>;
+/** Single-line header fragment for queue / classify digest. */
+export declare function formatAuthorFilterLine(filter: AuthorFilter, options?: {
+    readonly unknownCount?: number;
+}): string;
+//# sourceMappingURL=author-filter.d.ts.map

package/dist/triage/author-filter.js

@@ -0,0 +1,152 @@
+/**
+ * Shared `--author` filter for triage:queue and triage:classify (#3129 / #1318 Layer 1).
+ *
+ * Matches existing bulk/bootstrap semantics: exact login match on cached author.login
+ * (or user.login). `@me` resolves via authenticated `gh api user --jq .login`.
+ * Comma allow-lists are accepted. Missing author on cache rows is "unknown" — not a match,
+ * and callers should disclose the unknown count rather than silent-drop.
+ */
+import { spawnSync } from "node:child_process";
+import { extractAuthor } from "./scope-drift/cache-walker.js";
+/** Split comma allow-list; trim; drop empties. */
+export function parseAuthorTokens(raw) {
+    return raw
+        .split(",")
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+}
+/**
+ * Resolve `@me` (and bare tokens) into an AuthorFilter.
+ * Returns error when raw is empty/whitespace-only or `@me` cannot be resolved.
+ */
+export function resolveAuthorFilter(raw, resolveMe) {
+    const resolveAuthenticated = resolveMe ?? defaultResolveAuthenticatedLogin;
+    const tokens = parseAuthorTokens(raw);
+    if (tokens.length === 0) {
+        return { error: "argument --author: expected a non-empty login (or @me)" };
+    }
+    let usedMe = false;
+    let meLogin;
+    const allow = [];
+    const displayParts = [];
+    for (const token of tokens) {
+        if (token === "@me" || token.toLowerCase() === "@me") {
+            usedMe = true;
+            if (meLogin === undefined) {
+                meLogin = resolveAuthenticated();
+            }
+            if (meLogin === null || meLogin.length === 0) {
+                return {
+                    error: "argument --author: @me could not be resolved (gh api user --jq .login failed; authenticate gh or pass an explicit login)",
+                };
+            }
+            allow.push(meLogin);
+            displayParts.push(`@me (resolved -> ${meLogin})`);
+        }
+        else {
+            allow.push(token);
+            displayParts.push(token);
+        }
+    }
+    // Dedup while preserving order
+    const seen = new Set();
+    const allowLogins = [];
+    for (const login of allow) {
+        if (!seen.has(login)) {
+            seen.add(login);
+            allowLogins.push(login);
+        }
+    }
+    return {
+        filter: {
+            raw,
+            allowLogins,
+            usedMe,
+            display: displayParts.join(", "),
+        },
+    };
+}
+/**
+ * Default `@me` resolution via live `gh` (not ghx — multi-arg api --jq; #2275 / #954).
+ */
+export function defaultResolveAuthenticatedLogin() {
+    try {
+        const result = spawnSync("gh", ["api", "user", "--jq", ".login"], {
+            encoding: "utf8",
+            env: process.env,
+            windowsHide: true,
+        });
+        if (result.status !== 0) {
+            return null;
+        }
+        const text = String(result.stdout ?? "").trim();
+        if (text.length === 0) {
+            return null;
+        }
+        // jq may emit a JSON string with quotes; strip surrounding quotes when present
+        if ((text.startsWith('"') && text.endsWith('"')) ||
+            (text.startsWith("'") && text.endsWith("'"))) {
+            return text.slice(1, -1);
+        }
+        return text;
+    }
+    catch {
+        return null;
+    }
+}
+/** Login from a CachedIssue.author string (empty = unknown). */
+export function normalizeAuthorLogin(login) {
+    if (login === null || login === undefined) {
+        return null;
+    }
+    const trimmed = login.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+/**
+ * Login from a raw cache payload (author.login / user.login / string author).
+ * Empty / missing → null (unknown).
+ */
+export function authorLoginFromRawIssue(issue) {
+    if (issue === null || issue === undefined) {
+        return null;
+    }
+    return normalizeAuthorLogin(extractAuthor(issue));
+}
+/** Exact allow-list match (bulk parity). Unknown/missing never matches. */
+export function matchesAuthorFilter(login, filter) {
+    const normalized = normalizeAuthorLogin(login);
+    if (normalized === null) {
+        return false;
+    }
+    return filter.allowLogins.includes(normalized);
+}
+/**
+ * Partition items by author filter. Unknown (missing login) counted separately
+ * and excluded from matched — callers disclose unknownCount in headers.
+ */
+export function partitionByAuthorFilter(items, getLogin, filter) {
+    const matched = [];
+    let unknownCount = 0;
+    let nonMatchingCount = 0;
+    for (const item of items) {
+        const login = normalizeAuthorLogin(getLogin(item));
+        if (login === null) {
+            unknownCount += 1;
+            continue;
+        }
+        if (filter.allowLogins.includes(login)) {
+            matched.push(item);
+        }
+        else {
+            nonMatchingCount += 1;
+        }
+    }
+    return { matched, unknownCount, nonMatchingCount };
+}
+/** Single-line header fragment for queue / classify digest. */
+export function formatAuthorFilterLine(filter, options = {}) {
+    const unknown = options.unknownCount ?? 0;
+    const unknownPart = unknown > 0 ? `; ${unknown} cached issue(s) missing author (unknown — excluded)` : "";
+    return `author filter: ${filter.display}${unknownPart}`;
+}
+//# sourceMappingURL=author-filter.js.map

package/dist/triage/classify/index.d.ts

@@ -85,8 +85,8 @@ export declare function validateProject(projectRoot: string): {
 };
 /** Render --list output for a project root. */
 export declare function listProject(projectRoot: string): string;
-import { type ClassifyAction, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, type LabelMirrorEngine, type LabelMirrorItem, type LabelMirrorOptions as LabelMirrorOptionsCore, type LabelMirrorOutcome, type LabelMirrorPolicy, type LabelMirrorStatus, labelMirrorOutcomeToJson, type ResolvedLabelMirrorPolicy, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlan as validateTriageLabelMirrorOnPlanFromModule } from "./label-mirror.js";
-export { type ClassifyAction, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, type LabelMirrorEngine, type LabelMirrorItem, type LabelMirrorOutcome, type LabelMirrorPolicy, type LabelMirrorStatus, labelMirrorOutcomeToJson, type ResolvedLabelMirrorPolicy, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlanFromModule as validateTriageLabelMirrorOnPlan, };
+import { buildLabelMirrorDigest, type ClassifyAction, DEFAULT_APPLY_BATCH_SIZE, DEFAULT_APPLY_DELAY_MS, DEFAULT_DIGEST_SAMPLE_LIMIT, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, type LabelMirrorDigest, type LabelMirrorEngine, type LabelMirrorFilters, type LabelMirrorItem, type LabelMirrorOptions as LabelMirrorOptionsCore, type LabelMirrorOutcome, type LabelMirrorPolicy, type LabelMirrorSleepFn, type LabelMirrorStatus, labelMirrorOutcomeToJson, type ResolvedLabelMirrorPolicy, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlan as validateTriageLabelMirrorOnPlanFromModule } from "./label-mirror.js";
+export { buildLabelMirrorDigest, type ClassifyAction, DEFAULT_APPLY_BATCH_SIZE, DEFAULT_APPLY_DELAY_MS, DEFAULT_DIGEST_SAMPLE_LIMIT, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, type LabelMirrorDigest, type LabelMirrorEngine, type LabelMirrorFilters, type LabelMirrorItem, type LabelMirrorOutcome, type LabelMirrorPolicy, type LabelMirrorSleepFn, type LabelMirrorStatus, labelMirrorOutcomeToJson, type ResolvedLabelMirrorPolicy, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlanFromModule as validateTriageLabelMirrorOnPlan, };
 /** Public options: engine is optional (defaults to this module's classify API). */
 export type LabelMirrorOptions = Omit<LabelMirrorOptionsCore, "engine"> & {
     readonly engine?: LabelMirrorEngine;

package/dist/triage/classify/index.js

@@ -751,8 +751,8 @@ export function listProject(projectRoot) {
 // label-mirror.ts does not import this module (avoids ESM/SLizard cycle).
 // Public mirrorLabels injects the classify engine into the pure implementation.
 // ---------------------------------------------------------------------------
-import { DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, labelMirrorOutcomeToJson, mirrorLabels as mirrorLabelsCore, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlan as validateTriageLabelMirrorOnPlanFromModule, } from "./label-mirror.js";
-export { DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, labelMirrorOutcomeToJson, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlanFromModule as validateTriageLabelMirrorOnPlan, };
+import { buildLabelMirrorDigest, DEFAULT_APPLY_BATCH_SIZE, DEFAULT_APPLY_DELAY_MS, DEFAULT_DIGEST_SAMPLE_LIMIT, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, labelMirrorOutcomeToJson, mirrorLabels as mirrorLabelsCore, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlan as validateTriageLabelMirrorOnPlanFromModule, } from "./label-mirror.js";
+export { buildLabelMirrorDigest, DEFAULT_APPLY_BATCH_SIZE, DEFAULT_APPLY_DELAY_MS, DEFAULT_DIGEST_SAMPLE_LIMIT, DEFAULT_IDEMPOTENCY_LABEL, defaultLabelMirrorPolicy, desiredLabelsForClassification, labelMirrorOutcomeToJson, renderLabelMirrorReport, resolveLabelMirrorPolicy, validateLabelMirrorPolicy, validateTriageLabelMirrorOnPlanFromModule as validateTriageLabelMirrorOnPlan, };
 function defaultLabelMirrorEngine() {
     return {
         classifyIssue: (issue, options) => classifyIssue(issue, {