@deftai/directive-core 0.94.0 → 0.95.0

package/dist/swarm/verify-review-clean.js

@@ -1,10 +1,9 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { hasArtifactSuffix } from "../layout/resolve.js";
-import { buildCiSummaryLine, evaluateCiGate } from "../pr-merge-readiness/ci-gate.js";
-import { defaultRunGh, fetchCheckRunsRest, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
-import { evaluateGates, parseGreptileBody } from "../pr-merge-readiness/index.js";
-import { evaluateSlizardGate, isSlizardCheck } from "../pr-merge-readiness/slizard-gate.js";
+import { computeGateResult, isMergeReady, } from "../pr-merge-readiness/compute.js";
+import { VIA_ERROR, VIA_FALLBACK2 } from "../pr-merge-readiness/constants.js";
+import { defaultRunGh } from "../pr-merge-readiness/gh.js";
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 function extractPrFromUri(uri) {
     const pullIdx = uri.indexOf("/pull/");
@@ -104,83 +103,29 @@ export function resolveCohortFromVbriefs(vbriefGlobs) {
     return { prNumbers: seenPrs, failures };
 }
 export function evaluatePr(prNumber, repo, runGh = defaultRunGh, options = {}) {
-    const headSha = fetchPrHeadSha(prNumber, repo, runGh);
-    if (headSha === null) {
+    const result = computeGateResult(prNumber, repo, runGh, options);
+    if (result.via === VIA_ERROR) {
         return null;
     }
-    const body = fetchGreptileCommentBody(prNumber, repo, runGh);
-    if (body === null) {
-        return null;
-    }
-    const verdict = parseGreptileBody(body);
-    const failures = evaluateGates(prNumber, headSha, verdict);
-    let ciSummary = null;
-    let slizardSummary = null;
-    if (failures.length === 0) {
-        if (repo === null) {
-            failures.push("Could not resolve repo for required CI check-run gate. " +
-                "Use --repo OWNER/REPO or run from a checked-out repository.");
-            ciSummary = {
-                ready_state: "blocked",
-                error: "repo unresolved for check-runs lookup",
-            };
-            slizardSummary = { ready_state: "skipped", present: false };
-        }
-        else if (options.skipCi === true) {
-            const ci = evaluateCiGate([], { skipCi: true });
-            ciSummary = {
-                ...ci.summary,
-                summary_line: "CI check-runs: skipped (--skip-ci)",
-            };
-            const slizard = evaluateSlizardGate([], options);
-            failures.push(...slizard.failures);
-            slizardSummary = { ...slizard.summary };
-        }
-        else {
-            const checks = fetchCheckRunsRest(headSha, repo, runGh);
-            if (checks.summary === null) {
-                failures.push("Required CI check-runs could not be fetched; fail closed by default (#2169). " +
-                    `Root cause: ${checks.error}`);
-                ciSummary = {
-                    ready_state: "blocked",
-                    error: checks.error,
-                    checked_count: 0,
-                    ignored_checks: [...(options.ignoreCheckNames ?? [])],
-                    failed_required: [],
-                    pending_required: [],
-                    conclusions: [],
-                };
-                slizardSummary = { ready_state: "skipped", present: false };
-            }
-            else {
-                const slizard = evaluateSlizardGate(checks.checkRuns, options);
-                // SLizard is scored by the structured gate; exclude it from the generic CI set.
-                const slizardNames = checks.checkRuns
-                    .filter((r) => isSlizardCheck(r.name))
-                    .map((r) => r.name);
-                const ci = evaluateCiGate(checks.checkRuns, {
-                    skipCi: options.skipCi,
-                    ignoreCheckNames: [...(options.ignoreCheckNames ?? []), ...slizardNames],
-                });
-                failures.push(...ci.failures, ...slizard.failures);
-                ciSummary = {
-                    ...ci.summary,
-                    summary_line: buildCiSummaryLine(ci.summary),
-                };
-                slizardSummary = { ...slizard.summary };
-            }
-        }
-    }
+    const ciSummary = asRecord(result.partialData.ci);
+    const slizardSummary = asRecord(result.partialData.slizard);
     return {
         pr_number: prNumber,
-        head_sha: headSha,
-        verdict: { ...verdict },
-        failures: [...failures],
-        clean: failures.length === 0,
+        head_sha: result.headSha,
+        verdict: { ...result.verdict },
+        failures: [...result.failures],
+        clean: result.via !== VIA_FALLBACK2 && isMergeReady(result.failures),
         ci_summary: ciSummary,
         slizard_summary: slizardSummary,
+        via: result.via,
+        partial_data: { ...result.partialData },
     };
 }
+function asRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? { ...value }
+        : null;
+}
 export function cohortResultToDict(cohort) {
     return {
         repo: cohort.repo,
@@ -194,6 +139,8 @@ export function cohortResultToDict(cohort) {
             failures: r.failures,
             ci_summary: r.ci_summary,
             slizard_summary: r.slizard_summary,
+            via: r.via ?? null,
+            partial_data: r.partial_data ?? {},
         })),
         resolution_errors: cohort.resolution_errors,
     };
@@ -216,6 +163,7 @@ export function renderReviewCleanText(cohort) {
         lines.push("");
         lines.push(`  PR #${r.pr_number} -- ${status}`);
         lines.push(`    HEAD SHA:           ${r.head_sha ?? "<unknown>"}`);
+        lines.push(`    Gate via:           ${r.via ?? "<unknown>"}`);
         lines.push(`    Greptile reviewed:  ${String(v.lastReviewedSha ?? "<not parsed>")}`);
         const conf = v.confidence;
         lines.push(`    Confidence:         ${conf === null || conf === undefined ? "<not parsed>" : String(conf)}/5`);
@@ -228,6 +176,13 @@ export function renderReviewCleanText(cohort) {
         if (r.slizard_summary && typeof r.slizard_summary.summary_line === "string") {
             lines.push(`    ${r.slizard_summary.summary_line}`);
         }
+        const override = asRecord(r.partial_data?.verdict_override);
+        if (override !== null) {
+            lines.push(`    Verdict override:   ${String(override.reason ?? "<unknown>")}`);
+            if (typeof override.basis === "string") {
+                lines.push(`    Override basis:     ${override.basis}`);
+            }
+        }
         r.failures.forEach((fail, index) => {
             lines.push(`      [${index + 1}] ${fail}`);
         });

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

@@ -85,4 +85,13 @@ 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, };
+/** Public options: engine is optional (defaults to this module's classify API). */
+export type LabelMirrorOptions = Omit<LabelMirrorOptionsCore, "engine"> & {
+    readonly engine?: LabelMirrorEngine;
+};
+export { extractReferencedRepoIssueKeys } from "./label-mirror.js";
+/** Tier-1 label mirror with the #1129 classify engine bound in. */
+export declare function mirrorLabels(projectRoot: string, options?: LabelMirrorOptions): [number, LabelMirrorOutcome];
 //# sourceMappingURL=index.d.ts.map

package/dist/triage/classify/index.js

@@ -721,7 +721,9 @@ export function validateProject(projectRoot) {
     const rel = projectDefinitionPath(root);
     const classifyErrs = validateTriageAutoClassifyOnPlan(plan, rel);
     const holderErrs = validateTriageHoldMarkersOnPlan(plan, rel);
-    const errors = [...classifyErrs, ...holderErrs];
+    // label-mirror validates plan.policy.triageLabelMirror (#1423); imported via re-export graph.
+    const mirrorErrs = validateTriageLabelMirrorOnPlanFromModule(plan, rel);
+    const errors = [...classifyErrs, ...holderErrs, ...mirrorErrs];
     if (errors.length > 0) {
         const lines = errors.map((err) => `FAIL: ${err}`);
         lines.push("");
@@ -732,7 +734,7 @@ export function validateProject(projectRoot) {
     const markers = resolveHoldMarkers({ projectRoot: root });
     return {
         code: 0,
-        stdout: "OK: triageAutoClassify[] + triageHoldMarkers[] valid " +
+        stdout: "OK: triageAutoClassify[] + triageHoldMarkers[] + triageLabelMirror valid " +
             `(${rules.length} rules, ${markers.length} hold markers).\n`,
         stderr: "",
     };
@@ -744,4 +746,34 @@ export function listProject(projectRoot) {
     const markers = resolveHoldMarkers({ projectRoot: root });
     return `${renderList(rules, { holdMarkers: markers })}\n`;
 }
+// ---------------------------------------------------------------------------
+// Tier-1 label mirror (#1423 Wave 1)
+// 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, };
+function defaultLabelMirrorEngine() {
+    return {
+        classifyIssue: (issue, options) => classifyIssue(issue, {
+            rules: options?.rules,
+            holdMarkers: options?.holdMarkers,
+            vbriefReferenced: options?.vbriefReferenced,
+            hasTriageDecision: options?.hasTriageDecision,
+            now: options?.now,
+        }),
+        resolveClassifyRules,
+        resolveHoldMarkers,
+        extractReferencedIssues,
+    };
+}
+export { extractReferencedRepoIssueKeys } from "./label-mirror.js";
+/** Tier-1 label mirror with the #1129 classify engine bound in. */
+export function mirrorLabels(projectRoot, options = {}) {
+    const { engine, ...rest } = options;
+    return mirrorLabelsCore(projectRoot, {
+        ...rest,
+        engine: engine ?? defaultLabelMirrorEngine(),
+    });
+}
 //# sourceMappingURL=index.js.map

package/dist/triage/classify/label-mirror.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Tier-1 deterministic SCM label mirror (#1423 Wave 1).
+ *
+ * Classifies cached issues with the existing #1129 engine, then mirrors the
+ * outcome as SCM labels (dry-run default, --apply to write). Never accepts into
+ * the xBRIEF lifecycle and never writes proposed/ scopes.
+ *
+ * Intentionally does NOT import from ./index.js (SLizard P1 cycle). The classify
+ * engine is injected via LabelMirrorEngine / mirrorLabels() wrapper in index.ts.
+ */
+import type { LabelClient } from "../../vbrief-reconcile/types.js";
+export declare const DEFAULT_IDEMPOTENCY_LABEL = "triaged";
+export declare const CACHE_DIR_NAME = ".deft-cache";
+export declare const CACHE_SOURCE = "github-issue";
+export type ClassifyAction = "defer" | "archive" | "escalate" | "accept";
+/** Minimal issue shape used by the mirror (matches classify GitHubIssue). */
+export interface MirrorGitHubIssue {
+    readonly number?: number;
+    readonly state?: string;
+    readonly body?: string | null;
+    readonly labels?: ReadonlyArray<{
+        name?: string;
+    } | string>;
+    readonly updated_at?: string;
+    readonly created_at?: string;
+}
+export interface MirrorClassificationResult {
+    readonly action: string;
+    readonly reason: string;
+    readonly ruleIndex: number;
+    readonly ruleSource: string;
+    readonly ruleKind: string;
+    readonly resumeOn: string | null;
+}
+/** Injected classify engine — avoids a runtime import cycle with classify/index.ts. */
+export interface LabelMirrorEngine {
+    readonly classifyIssue: (issue: MirrorGitHubIssue, options?: {
+        rules?: readonly unknown[];
+        holdMarkers?: string[] | null;
+        vbriefReferenced?: ReadonlySet<number> | null;
+        hasTriageDecision?: boolean;
+        now?: Date;
+    }) => MirrorClassificationResult | null;
+    readonly resolveClassifyRules: (options?: {
+        projectRoot?: string;
+        projectDefinition?: Record<string, unknown> | null;
+    }) => readonly unknown[];
+    readonly resolveHoldMarkers: (options?: {
+        projectRoot?: string;
+        projectDefinition?: Record<string, unknown> | null;
+    }) => string[];
+    /** Optional; label-mirror prefers repo-qualified keys and only needs numbers as fallback. */
+    readonly extractReferencedIssues?: (projectRoot?: string) => Set<number>;
+}
+/**
+ * Repo-qualified xBRIEF github-issue keys (`owner/name\\0number`).
+ * Unlike number-only extractReferencedIssues, this never collides across repos.
+ */
+export declare function extractReferencedRepoIssueKeys(projectRoot?: string, lifecycleFolders?: readonly string[]): Set<string>;
+export interface LabelMirrorPolicy {
+    /** When false, mirror is a no-op (default true when policy object is used). */
+    readonly enabled?: boolean;
+    /** Idempotency marker; issues already carrying this label are skipped. Default: triaged. */
+    readonly idempotencyLabel?: string;
+    /** Labels always applied on a successful classification (default: [idempotencyLabel]). */
+    readonly alwaysLabels?: readonly string[];
+    /** Map classify action -> additional labels to apply. */
+    readonly actionLabels?: Readonly<Partial<Record<ClassifyAction, readonly string[]>>>;
+}
+export interface ResolvedLabelMirrorPolicy {
+    readonly enabled: boolean;
+    readonly idempotencyLabel: string;
+    readonly alwaysLabels: readonly string[];
+    readonly actionLabels: Readonly<Partial<Record<ClassifyAction, readonly string[]>>>;
+}
+export type LabelMirrorStatus = "planned" | "applied" | "unchanged" | "skipped_already_triaged" | "skipped_no_match" | "skipped_unreadable" | "skipped_disabled" | "error";
+export interface LabelMirrorItem {
+    readonly repo: string;
+    readonly issue_number: number;
+    readonly action: string | null;
+    readonly reason: string | null;
+    readonly ruleKind: string | null;
+    readonly current: readonly string[];
+    readonly desired: readonly string[];
+    readonly add: readonly string[];
+    readonly status: LabelMirrorStatus;
+    readonly message?: string;
+}
+export interface LabelMirrorOutcome {
+    readonly project_root: string;
+    readonly dry_run: boolean;
+    readonly scanned: number;
+    readonly planned: number;
+    readonly applied: number;
+    readonly unchanged: number;
+    readonly skipped_already_triaged: number;
+    readonly skipped_no_match: number;
+    readonly skipped_unreadable: number;
+    readonly errors: number;
+    readonly items: readonly LabelMirrorItem[];
+    readonly policy: ResolvedLabelMirrorPolicy;
+}
+export interface LabelMirrorOptions {
+    readonly dryRun?: boolean;
+    readonly repo?: string | null;
+    readonly cacheRoot?: string;
+    readonly client?: LabelClient;
+    readonly allowCrossRepo?: boolean;
+    readonly repoAllowlist?: readonly string[];
+    /** Prefer live SCM labels when true (default: !dryRun). Cache labels used for dry-run. */
+    readonly useLiveLabels?: boolean;
+    readonly now?: Date;
+    /** Required: classify engine (provided by classify/index mirrorLabels wrapper). */
+    readonly engine: LabelMirrorEngine;
+}
+/** Validate plan.policy.triageLabelMirror payload. */
+export declare function validateLabelMirrorPolicy(raw: unknown): {
+    errors: string[];
+    warnings: string[];
+};
+/** Default resolved policy when triageLabelMirror is absent. */
+export declare function defaultLabelMirrorPolicy(): ResolvedLabelMirrorPolicy;
+/** Resolve effective label-mirror policy from PROJECT-DEFINITION or inline object. */
+export declare function resolveLabelMirrorPolicy(options?: {
+    projectRoot?: string;
+    projectDefinition?: Record<string, unknown> | null;
+    override?: LabelMirrorPolicy | null;
+}): ResolvedLabelMirrorPolicy;
+/** Labels to apply for a classified action (always + action-mapped). */
+export declare function desiredLabelsForClassification(action: string, policy: ResolvedLabelMirrorPolicy): string[];
+/**
+ * Run Tier-1 label mirror over the github-issue cache.
+ * Dry-run by default (no SCM writes). Pass dryRun: false to apply.
+ * Requires options.engine (classify/index wrapper injects it).
+ */
+export declare function mirrorLabels(projectRoot: string, options: LabelMirrorOptions): [number, LabelMirrorOutcome];
+/** Human-readable digest for dry-run / apply reports. */
+export declare function renderLabelMirrorReport(outcome: LabelMirrorOutcome): string;
+/** JSON-serializable outcome (stable key order not required). */
+export declare function labelMirrorOutcomeToJson(outcome: LabelMirrorOutcome): Record<string, unknown>;
+/** Validate triageLabelMirror on a plan object (vbrief_validate hook). */
+export declare function validateTriageLabelMirrorOnPlan(plan: unknown, filepath: string): string[];
+//# sourceMappingURL=label-mirror.d.ts.map