@deftai/directive-core 0.55.0

package/dist/triage/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `@deftai/directive-core/triage` — the ported triage engine surface (#1530 Wave 3, #1725).
+ *
+ * Each triage verb is a self-contained module ported from its `scripts/triage_*.py`
+ * oracle. They are re-exported here under stable per-verb namespaces (rather than
+ * flat) so the verbs can share common symbol names (`evaluate`, `render`, `main`,
+ * ...) without colliding.
+ */
+export * as actions from "./actions/index.js";
+export * as bootstrap from "./bootstrap/index.js";
+export * as bulk from "./bulk/index.js";
+export * as classify from "./classify/index.js";
+export * as help from "./help/index.js";
+export * as queue from "./queue/index.js";
+export * as reconcile from "./reconcile/index.js";
+export * as refresh from "./refresh/index.js";
+export * as scope from "./scope/index.js";
+export * as scopeDrift from "./scope-drift/index.js";
+export * as smoketest from "./smoketest/index.js";
+export * as subscribe from "./subscribe/index.js";
+export * as summary from "./summary/index.js";
+export * as welcome from "./welcome/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/index.js

@@ -0,0 +1,23 @@
+/**
+ * `@deftai/directive-core/triage` — the ported triage engine surface (#1530 Wave 3, #1725).
+ *
+ * Each triage verb is a self-contained module ported from its `scripts/triage_*.py`
+ * oracle. They are re-exported here under stable per-verb namespaces (rather than
+ * flat) so the verbs can share common symbol names (`evaluate`, `render`, `main`,
+ * ...) without colliding.
+ */
+export * as actions from "./actions/index.js";
+export * as bootstrap from "./bootstrap/index.js";
+export * as bulk from "./bulk/index.js";
+export * as classify from "./classify/index.js";
+export * as help from "./help/index.js";
+export * as queue from "./queue/index.js";
+export * as reconcile from "./reconcile/index.js";
+export * as refresh from "./refresh/index.js";
+export * as scope from "./scope/index.js";
+export * as scopeDrift from "./scope-drift/index.js";
+export * as smoketest from "./smoketest/index.js";
+export * as subscribe from "./subscribe/index.js";
+export * as summary from "./summary/index.js";
+export * as welcome from "./welcome/index.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/queue/audit.d.ts

@@ -0,0 +1,12 @@
+import type { AuditEntry } from "./types.js";
+/** Resolve audit log path; mirrors candidates_log._resolve_path (framework root). */
+export declare function resolveAuditLogPath(options?: {
+    readonly auditLogPath?: string | null;
+    readonly frameworkRoot?: string | null;
+}): string;
+/** Read audit log entries, optionally filtered by repo. */
+export declare function readAuditEntries(repo: string | null, options?: {
+    readonly frameworkRoot?: string | null;
+    readonly auditLogPath?: string | null;
+}): readonly AuditEntry[];
+//# sourceMappingURL=audit.d.ts.map

package/dist/triage/queue/audit.js

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { DEFAULT_AUDIT_LOG_REL_PATH } from "./constants.js";
+/** Resolve audit log path; mirrors candidates_log._resolve_path (framework root). */
+export function resolveAuditLogPath(options = {}) {
+    if (options.auditLogPath !== null && options.auditLogPath !== undefined) {
+        return resolve(options.auditLogPath);
+    }
+    const envRoot = process.env.DEFT_ROOT?.trim() ?? "";
+    const root = options.frameworkRoot !== null && options.frameworkRoot !== undefined
+        ? resolve(options.frameworkRoot)
+        : envRoot.length > 0
+            ? resolve(envRoot)
+            : process.cwd();
+    return join(root, DEFAULT_AUDIT_LOG_REL_PATH);
+}
+/** Read audit log entries, optionally filtered by repo. */
+export function readAuditEntries(repo, options = {}) {
+    const logPath = resolveAuditLogPath(options);
+    if (!existsSync(logPath)) {
+        return [];
+    }
+    const out = [];
+    const raw = readFileSync(logPath, { encoding: "utf8" });
+    for (const line of raw.split("\n")) {
+        const stripped = line.trim();
+        if (stripped.length === 0) {
+            continue;
+        }
+        try {
+            const obj = JSON.parse(stripped);
+            if (typeof obj !== "object" || obj === null) {
+                continue;
+            }
+            const entry = obj;
+            if (repo !== null && entry.repo !== repo) {
+                continue;
+            }
+            out.push(entry);
+        }
+        catch {
+            // skip malformed audit rows
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=audit.js.map

package/dist/triage/queue/build-queue.d.ts

@@ -0,0 +1,9 @@
+import type { AuditEntry, CachedIssue, QueueBuildOptions, QueueItem } from "./types.js";
+/** Reduce audit entries to {issue_number: latest_entry} by timestamp. */
+export declare function latestDecisionsByIssue(entries: readonly AuditEntry[]): ReadonlyMap<number, AuditEntry>;
+/** Compose the ranked queue. Mirrors scripts/triage_queue.py::build_queue. */
+export declare function buildQueue(issues: readonly CachedIssue[], auditEntries: readonly AuditEntry[], options: {
+    readonly repo: string;
+    readonly queue?: QueueBuildOptions;
+}): readonly QueueItem[];
+//# sourceMappingURL=build-queue.d.ts.map

package/dist/triage/queue/build-queue.js

@@ -0,0 +1,133 @@
+import { GROUP_ORDER } from "./constants.js";
+import { deriveGroup } from "./derive-group.js";
+import { compareSelectionKeys, matchedLabelFor, withinGroupSortKey } from "./selection.js";
+function resolveRank(issue, number, rankByNumber) {
+    let candidate = rankByNumber.get(number);
+    if (candidate === undefined) {
+        candidate = issue.metadataRank ?? undefined;
+    }
+    if (typeof candidate !== "number" || !Number.isInteger(candidate)) {
+        return null;
+    }
+    return candidate;
+}
+function resolveContinuation(issue, number, continuationNumbers) {
+    if (continuationNumbers.has(number)) {
+        return true;
+    }
+    return Boolean(issue.continuation);
+}
+function resolveContinuationOrder(issue, number, orderByNumber) {
+    let candidate = orderByNumber.get(number);
+    if (candidate === undefined) {
+        candidate = issue.continuationOrder;
+    }
+    return typeof candidate === "string" ? candidate : "";
+}
+function resolveDeficit(issue, number, deficitByNumber) {
+    let candidate = deficitByNumber.get(number);
+    if (candidate === undefined) {
+        candidate = issue.bucketDeficit ?? undefined;
+    }
+    if (typeof candidate !== "number" || !Number.isFinite(candidate)) {
+        return null;
+    }
+    return candidate;
+}
+function resolveBlocked(issue, number, blockedNumbers) {
+    if (blockedNumbers.has(number)) {
+        return true;
+    }
+    return Boolean(issue.blocked);
+}
+/** Reduce audit entries to {issue_number: latest_entry} by timestamp. */
+export function latestDecisionsByIssue(entries) {
+    const out = new Map();
+    for (const entry of entries) {
+        const n = entry.issue_number;
+        if (typeof n !== "number") {
+            continue;
+        }
+        const current = out.get(n);
+        const stamp = entry.timestamp ?? "";
+        const currentStamp = current?.timestamp ?? "";
+        if (current === undefined || stamp > currentStamp) {
+            out.set(n, entry);
+        }
+    }
+    return out;
+}
+/** Compose the ranked queue. Mirrors scripts/triage_queue.py::build_queue. */
+export function buildQueue(issues, auditEntries, options) {
+    const opts = options.queue ?? {};
+    const rankingLabels = opts.rankingLabels ?? [];
+    const activeReferenced = opts.activeReferenced ?? new Set();
+    const orphanIssueNumbers = opts.orphanIssueNumbers ?? new Set();
+    const rankByNumber = opts.rankByNumber ?? new Map();
+    const continuationNumbers = opts.continuationNumbers ?? new Set();
+    const continuationOrderByNumber = opts.continuationOrderByNumber ?? new Map();
+    const deficitByNumber = opts.deficitByNumber ?? new Map();
+    const blockedIssueNumbers = opts.blockedIssueNumbers ?? new Set();
+    const dropNetNew = Boolean(opts.finishBeforeStart && opts.wipAtCap);
+    const includeBlocked = Boolean(opts.includeBlocked);
+    const limit = opts.limit;
+    const decisions = latestDecisionsByIssue(auditEntries);
+    const grouped = new Map();
+    for (const group of GROUP_ORDER) {
+        grouped.set(group, []);
+    }
+    for (const issue of issues) {
+        const n = issue.number;
+        if (typeof n !== "number") {
+            continue;
+        }
+        const isContinuation = resolveContinuation(issue, n, continuationNumbers);
+        const isOrphan = orphanIssueNumbers.has(n);
+        if (dropNetNew && !isContinuation && !isOrphan) {
+            continue;
+        }
+        const isBlocked = resolveBlocked(issue, n, blockedIssueNumbers);
+        const latest = decisions.get(n);
+        const latestDecision = typeof latest?.decision === "string" ? latest.decision : null;
+        let group;
+        if (isBlocked && !includeBlocked) {
+            group = "BLOCKED";
+        }
+        else if (isOrphan) {
+            group = "ORPHAN";
+        }
+        else {
+            group = deriveGroup(latestDecision, activeReferenced.has(n));
+        }
+        const mutable = { ...issue };
+        mutable._latestDecision = latestDecision;
+        mutable._blocked = isBlocked;
+        mutable._resolvedRank = resolveRank(issue, n, rankByNumber);
+        mutable._continuation = isContinuation;
+        mutable._continuationOrder = resolveContinuationOrder(issue, n, continuationOrderByNumber);
+        mutable._bucketDeficit = resolveDeficit(issue, n, deficitByNumber);
+        grouped.get(group)?.push(mutable);
+    }
+    const out = [];
+    for (const group of GROUP_ORDER) {
+        const bucket = [...(grouped.get(group) ?? [])].sort((left, right) => compareSelectionKeys(withinGroupSortKey(left, rankingLabels), withinGroupSortKey(right, rankingLabels)));
+        for (const issue of bucket) {
+            out.push({
+                number: issue.number,
+                title: String(issue.title ?? ""),
+                state: String(issue.state ?? "open"),
+                labels: issue.labels ?? [],
+                updatedAt: String(issue.updatedAt ?? ""),
+                group,
+                latestDecision: issue._latestDecision ?? null,
+                matchedLabel: matchedLabelFor(issue, rankingLabels),
+                repo: options.repo,
+            });
+            if (limit !== null && limit !== undefined && out.length >= limit) {
+                return out;
+            }
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=build-queue.js.map

package/dist/triage/queue/cache.d.ts

@@ -0,0 +1,20 @@
+import type { CachedIssue } from "./types.js";
+/** Read slices.jsonl records. */
+export declare function resolveSlicesLogPath(options?: {
+    readonly slicesLogPath?: string | null;
+    readonly frameworkRoot?: string | null;
+}): string;
+/** Read slices.jsonl records. */
+export declare function loadSliceRecords(options?: {
+    readonly slicesLogPath?: string | null;
+    readonly frameworkRoot?: string | null;
+}): readonly Record<string, unknown>[];
+/** Return orphan child issue numbers (open child + closed umbrella). */
+export declare function collectOrphanIssueNumbers(sliceRecords: readonly Record<string, unknown>[], issuesByNumber: ReadonlyMap<number, CachedIssue | Record<string, unknown>>): ReadonlySet<number>;
+/** Walk the cache and return one CachedIssue per cached issue. */
+export declare function loadCachedIssues(repo: string, options: {
+    readonly projectRoot: string;
+    readonly source?: string;
+    readonly includeClosed?: boolean;
+}): readonly CachedIssue[];
+//# sourceMappingURL=cache.d.ts.map

package/dist/triage/queue/cache.js

@@ -0,0 +1,169 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE, DEFAULT_SLICES_LOG_REL_PATH, } from "./constants.js";
+import { blockedByIssueNumber, rankByIssueNumber } from "./scope-walk.js";
+function cachedState(issue) {
+    if (issue === undefined) {
+        return "";
+    }
+    const state = issue.state;
+    return typeof state === "string" ? state.toLowerCase() : "";
+}
+/** Read slices.jsonl records. */
+export function resolveSlicesLogPath(options = {}) {
+    if (options.slicesLogPath !== null && options.slicesLogPath !== undefined) {
+        return resolve(options.slicesLogPath);
+    }
+    const envRoot = process.env.DEFT_ROOT?.trim() ?? "";
+    const root = options.frameworkRoot !== null && options.frameworkRoot !== undefined
+        ? resolve(options.frameworkRoot)
+        : envRoot.length > 0
+            ? resolve(envRoot)
+            : process.cwd();
+    return join(root, DEFAULT_SLICES_LOG_REL_PATH);
+}
+/** Read slices.jsonl records. */
+export function loadSliceRecords(options = {}) {
+    const path = resolveSlicesLogPath(options);
+    if (!existsSync(path)) {
+        return [];
+    }
+    const out = [];
+    const raw = readFileSync(path, { encoding: "utf8" });
+    for (const line of raw.split("\n")) {
+        const stripped = line.trim();
+        if (stripped.length === 0) {
+            continue;
+        }
+        try {
+            const obj = JSON.parse(stripped);
+            if (typeof obj === "object" && obj !== null) {
+                out.push(obj);
+            }
+        }
+        catch {
+            // skip malformed slice rows
+        }
+    }
+    return out;
+}
+/** Return orphan child issue numbers (open child + closed umbrella). */
+export function collectOrphanIssueNumbers(sliceRecords, issuesByNumber) {
+    const out = new Set();
+    for (const record of sliceRecords) {
+        const umbrella = record.umbrella;
+        if (typeof umbrella !== "number") {
+            continue;
+        }
+        const umbrellaIssue = issuesByNumber.get(umbrella);
+        if (cachedState(umbrellaIssue) !== "closed") {
+            continue;
+        }
+        const children = record.children;
+        if (!Array.isArray(children)) {
+            continue;
+        }
+        for (const child of children) {
+            if (typeof child !== "object" || child === null) {
+                continue;
+            }
+            const n = child.n;
+            if (typeof n !== "number") {
+                continue;
+            }
+            const childIssue = issuesByNumber.get(n);
+            if (cachedState(childIssue) === "open") {
+                out.add(n);
+            }
+        }
+    }
+    return out;
+}
+function parseLabels(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const labels = [];
+    for (const item of raw) {
+        if (typeof item === "object" && item !== null) {
+            const name = item.name;
+            if (typeof name === "string") {
+                labels.push(name);
+            }
+        }
+        else if (typeof item === "string") {
+            labels.push(item);
+        }
+    }
+    return labels;
+}
+/** Walk the cache and return one CachedIssue per cached issue. */
+export function loadCachedIssues(repo, options) {
+    if (!repo.includes("/")) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const parts = repo.split("/", 2);
+    const owner = parts[0];
+    const name = parts[1];
+    if (owner === undefined || name === undefined || owner.length === 0 || name.length === 0) {
+        throw new Error(`repo must be 'owner/name'; got '${repo}'`);
+    }
+    const root = resolve(options.projectRoot);
+    const source = options.source ?? CACHE_SOURCE_GITHUB_ISSUE;
+    const base = join(root, CACHE_DIR_NAME, source, owner, name);
+    if (!existsSync(base)) {
+        return [];
+    }
+    const rankMap = rankByIssueNumber(root);
+    const blockedSet = blockedByIssueNumber(root);
+    const issues = [];
+    for (const entryName of readdirSync(base)) {
+        if (!/^\d+$/.test(entryName)) {
+            continue;
+        }
+        const entryDir = join(base, entryName);
+        const rawPath = join(entryDir, "raw.json");
+        if (!existsSync(rawPath)) {
+            continue;
+        }
+        let payload;
+        try {
+            const parsed = JSON.parse(readFileSync(rawPath, { encoding: "utf8" }));
+            if (typeof parsed !== "object" || parsed === null) {
+                continue;
+            }
+            payload = parsed;
+        }
+        catch {
+            continue;
+        }
+        let n = payload.number;
+        if (typeof n !== "number") {
+            const parsed = Number.parseInt(entryName, 10);
+            n = Number.isFinite(parsed) ? parsed : undefined;
+        }
+        if (typeof n !== "number") {
+            continue;
+        }
+        const stateRaw = payload.state ?? "open";
+        const state = typeof stateRaw === "string" ? stateRaw.toLowerCase() : "open";
+        if (state !== "open" && !options.includeClosed) {
+            continue;
+        }
+        issues.push({
+            number: n,
+            title: typeof payload.title === "string" ? payload.title : "",
+            state,
+            labels: parseLabels(payload.labels),
+            updatedAt: typeof payload.updated_at === "string" ? payload.updated_at : "",
+            createdAt: typeof payload.created_at === "string" ? payload.created_at : "",
+            metadataRank: rankMap.get(n) ?? null,
+            continuation: false,
+            continuationOrder: "",
+            bucketDeficit: null,
+            blocked: blockedSet.has(n),
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=cache.js.map

package/dist/triage/queue/constants.d.ts

@@ -0,0 +1,22 @@
+/** Filesystem-relative location of the unified cache root (#883 Story 2). */
+export declare const CACHE_DIR_NAME = ".deft-cache";
+/** Cache source layer for upstream GitHub issues. */
+export declare const CACHE_SOURCE_GITHUB_ISSUE = "github-issue";
+/** Env var honoured for repo inference when `--repo` is absent (#1238). */
+export declare const ENV_TRIAGE_REPO = "DEFT_TRIAGE_REPO";
+/** PROJECT-DEFINITION vBRIEF location for typed-policy lookup. */
+export declare const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+/** Default queue limit when `--limit` is omitted on the CLI surface. */
+export declare const DEFAULT_QUEUE_LIMIT = 25;
+/** Default audit log path relative to the deft framework root (candidates_log.REPO_ROOT). */
+export declare const DEFAULT_AUDIT_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
+/** Default slices log path relative to project root. */
+export declare const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+/** Group display order (#1128 / D13 / #1286). */
+export declare const GROUP_ORDER: readonly ["ORPHAN", "RESUME", "URGENT", "untriaged", "other", "BLOCKED"];
+export type QueueGroup = (typeof GROUP_ORDER)[number];
+/** Display labels per group (left-of-issue marker). */
+export declare const GROUP_DISPLAY: Readonly<Record<QueueGroup, string>>;
+/** Framework default for plan.policy.triageRankingLabels[] (empty). */
+export declare const DEFAULT_TRIAGE_RANKING_LABELS: readonly string[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/triage/queue/constants.js

@@ -0,0 +1,28 @@
+/** Filesystem-relative location of the unified cache root (#883 Story 2). */
+export const CACHE_DIR_NAME = ".deft-cache";
+/** Cache source layer for upstream GitHub issues. */
+export const CACHE_SOURCE_GITHUB_ISSUE = "github-issue";
+/** Env var honoured for repo inference when `--repo` is absent (#1238). */
+export const ENV_TRIAGE_REPO = "DEFT_TRIAGE_REPO";
+/** PROJECT-DEFINITION vBRIEF location for typed-policy lookup. */
+export const PROJECT_DEFINITION_REL_PATH = "vbrief/PROJECT-DEFINITION.vbrief.json";
+/** Default queue limit when `--limit` is omitted on the CLI surface. */
+export const DEFAULT_QUEUE_LIMIT = 25;
+/** Default audit log path relative to the deft framework root (candidates_log.REPO_ROOT). */
+export const DEFAULT_AUDIT_LOG_REL_PATH = "vbrief/.eval/candidates.jsonl";
+/** Default slices log path relative to project root. */
+export const DEFAULT_SLICES_LOG_REL_PATH = "vbrief/.eval/slices.jsonl";
+/** Group display order (#1128 / D13 / #1286). */
+export const GROUP_ORDER = ["ORPHAN", "RESUME", "URGENT", "untriaged", "other", "BLOCKED"];
+/** Display labels per group (left-of-issue marker). */
+export const GROUP_DISPLAY = {
+    ORPHAN: "[ORPHAN]    ",
+    RESUME: "[RESUME]    ",
+    URGENT: "[URGENT]    ",
+    untriaged: "[untriaged] ",
+    other: "[other]     ",
+    BLOCKED: "[BLOCKED]   ",
+};
+/** Framework default for plan.policy.triageRankingLabels[] (empty). */
+export const DEFAULT_TRIAGE_RANKING_LABELS = [];
+//# sourceMappingURL=constants.js.map

package/dist/triage/queue/derive-group.d.ts

@@ -0,0 +1,7 @@
+import type { QueueGroup } from "./constants.js";
+/**
+ * Map (latestDecision, inActiveVbrief) to a group bucket.
+ * Mirrors scripts/triage_queue.py::derive_group.
+ */
+export declare function deriveGroup(latestDecision: string | null | undefined, inActiveVbrief: boolean): QueueGroup;
+//# sourceMappingURL=derive-group.d.ts.map

package/dist/triage/queue/derive-group.js

@@ -0,0 +1,20 @@
+/**
+ * Map (latestDecision, inActiveVbrief) to a group bucket.
+ * Mirrors scripts/triage_queue.py::derive_group.
+ */
+export function deriveGroup(latestDecision, inActiveVbrief) {
+    if (inActiveVbrief) {
+        return "RESUME";
+    }
+    if (latestDecision === "resume-eligible") {
+        return "RESUME";
+    }
+    if (latestDecision === "needs-ac") {
+        return "URGENT";
+    }
+    if (latestDecision === null || latestDecision === undefined) {
+        return "untriaged";
+    }
+    return "other";
+}
+//# sourceMappingURL=derive-group.js.map

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

@@ -0,0 +1,12 @@
+export * from "./audit.js";
+export * from "./build-queue.js";
+export * from "./cache.js";
+export * from "./constants.js";
+export * from "./derive-group.js";
+export * from "./ranking-labels.js";
+export * from "./render.js";
+export * from "./repo.js";
+export * from "./scope-walk.js";
+export * from "./selection.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/queue/index.js

@@ -0,0 +1,12 @@
+export * from "./audit.js";
+export * from "./build-queue.js";
+export * from "./cache.js";
+export * from "./constants.js";
+export * from "./derive-group.js";
+export * from "./ranking-labels.js";
+export * from "./render.js";
+export * from "./repo.js";
+export * from "./scope-walk.js";
+export * from "./selection.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/triage/queue/project.d.ts

@@ -0,0 +1,6 @@
+export interface ProjectDefinition {
+    readonly plan?: unknown;
+}
+/** Read vbrief/PROJECT-DEFINITION.vbrief.json. Returns null if absent/invalid. */
+export declare function loadProjectDefinition(projectRoot: string): ProjectDefinition | null;
+//# sourceMappingURL=project.d.ts.map

package/dist/triage/queue/project.js

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { PROJECT_DEFINITION_REL_PATH } from "./constants.js";
+/** Read vbrief/PROJECT-DEFINITION.vbrief.json. Returns null if absent/invalid. */
+export function loadProjectDefinition(projectRoot) {
+    const path = join(resolve(projectRoot), PROJECT_DEFINITION_REL_PATH);
+    if (!existsSync(path)) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(readFileSync(path, { encoding: "utf8" }));
+        return typeof data === "object" && data !== null ? data : null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=project.js.map

package/dist/triage/queue/ranking-labels.d.ts

@@ -0,0 +1,10 @@
+import { PROJECT_DEFINITION_REL_PATH } from "./constants.js";
+/** Resolve effective plan.policy.triageRankingLabels list. */
+export declare function resolveRankingLabels(projectRoot: string): readonly string[];
+/** Validate plan.policy.triageRankingLabels payload. */
+export declare function validateRankingLabels(value: unknown): {
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+};
+export { PROJECT_DEFINITION_REL_PATH };
+//# sourceMappingURL=ranking-labels.d.ts.map

package/dist/triage/queue/ranking-labels.js

@@ -0,0 +1,54 @@
+import { DEFAULT_TRIAGE_RANKING_LABELS, PROJECT_DEFINITION_REL_PATH } from "./constants.js";
+import { loadProjectDefinition } from "./project.js";
+/** Resolve effective plan.policy.triageRankingLabels list. */
+export function resolveRankingLabels(projectRoot) {
+    const data = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return [...DEFAULT_TRIAGE_RANKING_LABELS];
+    }
+    const plan = data.plan;
+    if (typeof plan !== "object" || plan === null) {
+        return [...DEFAULT_TRIAGE_RANKING_LABELS];
+    }
+    const policy = plan.policy;
+    if (typeof policy !== "object" || policy === null) {
+        return [...DEFAULT_TRIAGE_RANKING_LABELS];
+    }
+    const value = policy.triageRankingLabels;
+    if (!Array.isArray(value) || value.length === 0) {
+        return [...DEFAULT_TRIAGE_RANKING_LABELS];
+    }
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+/** Validate plan.policy.triageRankingLabels payload. */
+export function validateRankingLabels(value) {
+    const errors = [];
+    const warnings = [];
+    if (value === null || value === undefined) {
+        return { errors, warnings };
+    }
+    if (!Array.isArray(value)) {
+        errors.push(`plan.policy.triageRankingLabels must be a list of strings; got ${typeof value}`);
+        return { errors, warnings };
+    }
+    const seen = new Set();
+    for (let i = 0; i < value.length; i += 1) {
+        const entry = value[i];
+        const prefix = `plan.policy.triageRankingLabels[${i}]`;
+        if (typeof entry !== "string") {
+            errors.push(`${prefix} must be a string, got ${typeof entry}`);
+            continue;
+        }
+        if (entry.trim().length === 0) {
+            errors.push(`${prefix} must be a non-empty string`);
+            continue;
+        }
+        if (seen.has(entry)) {
+            warnings.push(`${prefix} duplicate label '${entry}'; only the first occurrence ranks`);
+        }
+        seen.add(entry);
+    }
+    return { errors, warnings };
+}
+export { PROJECT_DEFINITION_REL_PATH };
+//# sourceMappingURL=ranking-labels.js.map

package/dist/triage/queue/render.d.ts

@@ -0,0 +1,9 @@
+import type { QueueItem } from "./types.js";
+/** Pretty-print the ranked queue. Mirrors scripts/triage_queue.py::render_queue. */
+export declare function renderQueue(options: {
+    readonly items: readonly QueueItem[];
+    readonly repo: string;
+    readonly limit?: number | null;
+    readonly rankingLabels?: readonly string[];
+}): string;
+//# sourceMappingURL=render.d.ts.map