@deftai/directive-core 0.93.0 → 0.95.0

package/dist/session/ritual-entrypoint.js

@@ -1,5 +1,6 @@
 import { cmdDoctor } from "../doctor/main.js";
 import { evaluate } from "../preflight-cache/evaluate.js";
+import { evaluateAgentHookReadinessSafely, } from "../verify-env/agent-hook-readiness.js";
 export const ENTRYPOINT_TIMEOUT_SECONDS = 300;
 export const ENTRYPOINT_TIMEOUT_EXIT_CODE = 124;
 /** Run an in-process ritual entrypoint with stdout/stderr capture. */
@@ -66,9 +67,21 @@ export function runCacheFreshMain(argv) {
     }
     return result.code;
 }
-/** Default gated-tier runner: in-process doctor + cache-fresh (mirrors verify_session_ritual.py). */
-export function defaultRitualRunner(command, projectRoot) {
+/** Default gated-tier runner: in-process hook readiness, doctor, and cache freshness. */
+export function defaultRitualRunner(command, projectRoot, seams = {}) {
     const [verb, ...rest] = command;
+    if (verb === "verify:hooks-installed") {
+        const evaluateReadiness = seams.evaluateAgentHookReadiness
+            ? (root) => evaluateAgentHookReadinessSafely(root, seams.evaluateAgentHookReadiness)
+            : evaluateAgentHookReadinessSafely;
+        const result = evaluateReadiness(projectRoot);
+        const output = `${result.message}\n`;
+        return {
+            code: result.code,
+            stdout: result.stream === "stdout" ? output : "",
+            stderr: result.stream === "stderr" ? output : "",
+        };
+    }
     if (verb === "doctor") {
         return callMain((argv) => cmdDoctor(argv), ["--project-root", projectRoot, ...rest]);
     }

package/dist/session/session-ready.js

@@ -90,12 +90,20 @@ export function runSessionReady(projectRoot, options = {}) {
     const env = options.env ?? process.env;
     const lines = [];
     const steps = [];
-    const inspect = options.inspectRitual ?? ((root, opts) => inspectSessionRitual(root, opts));
-    const verify = options.verifyRitual ?? ((root, opts) => verifySessionRitual(root, opts));
-    const start = options.runStart ?? ((root, opts) => runSessionStart(root, opts));
+    const inspect = options.inspectRitual ?? inspectSessionRitual;
+    const verify = options.verifyRitual ?? verifySessionRitual;
+    const start = options.runStart ?? runSessionStart;
     const fetchAll = options.fetchAll ?? cacheFetchAll;
     const inferRepo = options.inferRepo ?? ((root) => inferSessionReadyRepo(root, env));
-    // --- Fast path: already green for PreToolUse gated inspect ---
+    const verifyOpts = {
+        tier: "gated",
+        posture: "mutation",
+        now,
+        runGit: options.runGit,
+        runner: options.runner,
+        forceGatedSteps: ["agent_hooks"],
+    };
+    // --- Fast path: inspect is green, but refresh functional hook readiness before returning. ---
     const gatedInspect = inspect(projectRoot, {
         tier: "gated",
         posture: "mutation",
@@ -103,6 +111,22 @@ export function runSessionReady(projectRoot, options = {}) {
         runGit: options.runGit,
     });
     if (gatedInspect.code === 0) {
+        steps.push("verify:session-ritual:gated");
+        const refreshed = verify(projectRoot, verifyOpts);
+        if (!isGatedVerifyActuallyReady(refreshed)) {
+            const message = refreshed.code === 0 && refreshed.bypassed
+                ? bypassedReadyFailure(refreshed)
+                : `${refreshed.message}\n  Remaining blocker after session:ready. Fix the step above, then re-run \`${readyCommand()}\`.`;
+            lines.push(message);
+            return {
+                code: refreshed.code === 0 ? 1 : refreshed.code,
+                message,
+                path: SESSION_READY_FAILED,
+                lines,
+                steps,
+                duration_ms: elapsedMs(started),
+            };
+        }
         const message = "OK session ready (gated ritual already fresh).";
         lines.push(message);
         return {
@@ -138,7 +162,7 @@ export function runSessionReady(projectRoot, options = {}) {
                 `session:start failed (exit ${startResult.code}). Recovery: run \`${readyCommand()}\` again after fixing the blocker.`;
             lines.push(message);
             return {
-                code: startResult.code === 0 ? 1 : startResult.code,
+                code: startResult.code,
                 message,
                 path: SESSION_READY_FAILED,
                 lines,
@@ -149,13 +173,6 @@ export function runSessionReady(projectRoot, options = {}) {
     }
     // --- Gated verify (lazy doctor + cache_fresh) ---
     steps.push("verify:session-ritual:gated");
-    const verifyOpts = {
-        tier: "gated",
-        posture: "mutation",
-        now,
-        runGit: options.runGit,
-        runner: options.runner,
-    };
     let verifyResult = verify(projectRoot, verifyOpts);
     if (isGatedVerifyActuallyReady(verifyResult)) {
         const message = "OK session ready (gated ritual verified).";
@@ -222,7 +239,7 @@ export function runSessionReady(projectRoot, options = {}) {
             };
         }
         steps.push("verify:session-ritual:gated:retry");
-        verifyResult = verify(projectRoot, verifyOpts);
+        verifyResult = verify(projectRoot, { ...verifyOpts, forceGatedSteps: [] });
         if (isGatedVerifyActuallyReady(verifyResult)) {
             const message = "OK session ready (recovered via cache refresh).";
             lines.push(message);
@@ -253,7 +270,7 @@ export function runSessionReady(projectRoot, options = {}) {
         `  Remaining blocker after session:ready. Fix the step above, then re-run \`${readyCommand()}\`.`;
     lines.push(message);
     return {
-        code: verifyResult.code === 0 ? 1 : verifyResult.code,
+        code: verifyResult.code,
         message,
         path: SESSION_READY_FAILED,
         lines,

package/dist/session/session-start.d.ts

@@ -16,7 +16,8 @@ export type SessionCeremonyTier = (typeof SESSION_CEREMONY_TIERS)[number];
 export declare const COLD_CEREMONY_TIER: SessionCeremonyTier;
 export declare const REARM_CEREMONY_TIER: SessionCeremonyTier;
 export declare const QUICK_STEPS: readonly ["alignment", "branch_policy", "triage_welcome"];
-export declare const GATED_STEPS: readonly ["doctor", "cache_fresh"];
+export declare const GATED_STEPS: readonly ["agent_hooks", "doctor", "cache_fresh"];
+export type GatedStepName = (typeof GATED_STEPS)[number];
 /** Env opt-in for optional session:start network (release probe + triage cache hydrate) (#2991). */
 export declare const ENV_SESSION_START_NETWORK = "DEFT_SESSION_START_NETWORK";
 /** Human-readable skip notice when optional network is off the hot path (#2991). */

package/dist/session/session-start.js

@@ -1,6 +1,8 @@
 import { randomUUID } from "node:crypto";
 import { runningInsideDeftRepo } from "../doctor/paths.js";
 import { emitSessionEvalReadback } from "../eval/readback.js";
+import { bindSessionGeneration } from "../freshness/bind.js";
+import { readLiveGeneration } from "../freshness/generation.js";
 import { MIGRATE_COMPLETION_NUDGE, shouldEmitMigrateNudge } from "../init-deposit/migrate.js";
 import { detectEnvironmentContext, environmentContextToDict, formatEnvironmentContext, } from "../platform/shell-context.js";
 import { DEFT_DIRECTIVE_DISABLE_FLAG_NAME, DEFT_DIRECTIVE_DISABLE_STATUS, detectDeftDirectiveDisable, formatDeftDirectiveDisableMessage, isDeftDirectiveDisableActive, } from "../policy/deft-directive-disable.js";
@@ -20,6 +22,7 @@ import { defaultGitRunner, gitHead, gitIsAncestor, worktreePath } from "./git.js
 import { emitSessionStartProcessCost } from "./process-cost.js";
 import { probeSessionReleaseAvailability, } from "./release-availability.js";
 import { newRitualStatePayload, readRitualState, ritualStatePath, ritualStep, writeRitualState, } from "./ritual-sentinel.js";
+import { timestampIso } from "./time.js";
 export const SESSION_POSTURES = ["read-only", "mutation"];
 export const READ_ONLY_POSTURE = "read-only";
 export const MUTATION_POSTURE = "mutation";
@@ -30,7 +33,7 @@ export const SESSION_CEREMONY_TIERS = ["cold", "rearm"];
 export const COLD_CEREMONY_TIER = "cold";
 export const REARM_CEREMONY_TIER = "rearm";
 export const QUICK_STEPS = ["alignment", "branch_policy", "triage_welcome"];
-export const GATED_STEPS = ["doctor", "cache_fresh"];
+export const GATED_STEPS = ["agent_hooks", "doctor", "cache_fresh"];
 /** Env opt-in for optional session:start network (release probe + triage cache hydrate) (#2991). */
 export const ENV_SESSION_START_NETWORK = "DEFT_SESSION_START_NETWORK";
 /** Human-readable skip notice when optional network is off the hot path (#2991). */
@@ -148,6 +151,10 @@ export function parseDeferrals(rawValues) {
         const name = raw.slice(0, eq);
         const reason = raw.slice(eq + 1);
         const stepName = normaliseStepName(name.trim());
+        if (stepName === "agent_hooks") {
+            errors.push('ritual step "agent_hooks" is not deferrable');
+            continue;
+        }
         if (!allowed.has(stepName)) {
             errors.push(`unknown ritual step ${JSON.stringify(name)}; expected one of ${JSON.stringify([...allowed].sort())}`);
             continue;
@@ -454,10 +461,11 @@ function runSessionRearm(projectRoot, options, instant, environment) {
     };
     const gatedSteps = restampSteps(eligibility.state.gatedSteps, instant);
     const writeStarted = performance.now();
+    const rearmSessionId = (options.newSessionId ?? randomUUID)();
     // Fresh payload (no rearm_needed / compact_resume_at) clears compact markers (#2992).
     const writePayload = {
         ...newRitualStatePayload({
-            sessionId: (options.newSessionId ?? randomUUID)(),
+            sessionId: rearmSessionId,
             gitHead: eligibility.currentHead,
             worktreePath: eligibility.currentWorktree,
             startedAt: instant,
@@ -502,6 +510,32 @@ function runSessionRearm(projectRoot, options, instant, environment) {
         .filter(([, step]) => !step.ok && !step.deferred_reason)
         .map(([name]) => name);
     const code = failed.length > 0 ? 1 : 0;
+    // #3117: bind live deposit generation into session context on re-arm (host-agnostic).
+    let freshnessBind = null;
+    try {
+        const bound = bindSessionGeneration(projectRoot, {
+            sessionId: rearmSessionId,
+            nowIso: timestampIso(instant),
+            payloadLoaded: true,
+        });
+        freshnessBind = {
+            bound_generation: bound.bound.boundGeneration,
+            live_generation: bound.live.generation,
+            content_version: bound.live.contentVersion,
+            path: bound.path,
+        };
+        lines.push(`[deft freshness] bound generation ${bound.bound.boundGeneration} ` +
+            `(live deposit v${bound.live.contentVersion})`);
+        lines.push(`[deft freshness] set DEFT_SESSION_ID=${rearmSessionId} for bare freshness:report/bind ` +
+            `(or pass --session-id; required for multi-agent trusted readiness)`);
+    }
+    catch {
+        const live = readLiveGeneration(projectRoot);
+        if (live !== null) {
+            lines.push(`[deft freshness] live generation ${live.generation} present; session bind deferred ` +
+                `(run \`deft freshness:bind\` after loading payload surfaces)`);
+        }
+    }
     // #2994: local process-cost event (best-effort; never blocks ceremony).
     emitSessionStartProcessCost({
         ceremonyTier: REARM_CEREMONY_TIER,
@@ -519,6 +553,7 @@ function runSessionRearm(projectRoot, options, instant, environment) {
             ceremony_tier: REARM_CEREMONY_TIER,
             rearm_eligible: true,
             state_path: statePath,
+            ...(freshnessBind ? { freshness: freshnessBind } : {}),
             quick_steps: quickSteps,
             gated_steps: gatedSteps,
             steps: stepTimings,
@@ -829,8 +864,9 @@ export function runSessionStart(projectRoot, options = {}) {
         lines.push(consentPrompt.trimEnd());
     }
     const writeStarted = performance.now();
+    const coldSessionId = (options.newSessionId ?? randomUUID)();
     const payload = newRitualStatePayload({
-        sessionId: (options.newSessionId ?? randomUUID)(),
+        sessionId: coldSessionId,
         gitHead: gitHeadValue,
         worktreePath: worktreePath(projectRoot, runGit),
         startedAt: instant,
@@ -860,11 +896,38 @@ export function runSessionStart(projectRoot, options = {}) {
         .map(([name]) => name);
     const code = failed.length > 0 ? 1 : 0;
     const totalMs = elapsedMs(overallStarted);
+    // #3117: bind live deposit generation when payload surfaces load (cold path).
+    let freshnessBind = null;
+    try {
+        const bound = bindSessionGeneration(projectRoot, {
+            sessionId: coldSessionId,
+            nowIso: timestampIso(instant),
+            payloadLoaded: true,
+        });
+        freshnessBind = {
+            bound_generation: bound.bound.boundGeneration,
+            live_generation: bound.live.generation,
+            content_version: bound.live.contentVersion,
+            path: bound.path,
+        };
+        lines.push(`[deft freshness] bound generation ${bound.bound.boundGeneration} ` +
+            `(live deposit v${bound.live.contentVersion})`);
+        lines.push(`[deft freshness] set DEFT_SESSION_ID=${coldSessionId} for bare freshness:report/bind ` +
+            `(or pass --session-id; required for multi-agent trusted readiness)`);
+    }
+    catch {
+        const live = readLiveGeneration(projectRoot);
+        if (live !== null) {
+            lines.push(`[deft freshness] live generation ${live.generation} present; session bind deferred ` +
+                `(run \`deft freshness:bind\` after loading payload surfaces)`);
+        }
+    }
     const resultPayload = {
         ready: code === 0,
         exit_code: code,
         ceremony_tier: COLD_CEREMONY_TIER,
         state_path: statePath,
+        ...(freshnessBind ? { freshness: freshnessBind } : {}),
         quick_steps: quickSteps,
         gated_steps: gatedSteps,
         steps: stepTimings,

package/dist/session/verify-session-ritual.d.ts

@@ -1,10 +1,10 @@
 import { type GitRunner } from "./git.js";
 import { type DirectivePosture } from "./posture.js";
-import { type SessionCeremonyTier } from "./session-start.js";
+import { type GatedStepName, type SessionCeremonyTier } from "./session-start.js";
 export { formatCacheFetchAllRecoveryCommand, recoveryHintForStaleFailure, } from "./cache-recovery.js";
 export declare const ENV_SKIP = "DEFT_SESSION_RITUAL_SKIP";
 export { ENTRYPOINT_TIMEOUT_EXIT_CODE, ENTRYPOINT_TIMEOUT_SECONDS, } from "./ritual-entrypoint.js";
-export declare const GATED_ENTRYPOINT_COMMANDS: Readonly<Record<string, readonly string[]>>;
+export declare const GATED_ENTRYPOINT_COMMANDS: Readonly<Record<GatedStepName, readonly string[]>>;
 export interface VerifyResult {
     readonly code: number;
     readonly message: string;
@@ -37,6 +37,8 @@ export interface VerifySessionRitualOptions {
     readonly posture?: DirectivePosture;
     readonly envPosture?: string | undefined;
     readonly handoffText?: string | null;
+    /** Re-run selected gated prerequisites even when their recorded step is green. */
+    readonly forceGatedSteps?: readonly GatedStepName[];
 }
 export interface InspectSessionRitualOptions {
     readonly tier?: "quick" | "gated";

package/dist/session/verify-session-ritual.js

@@ -11,6 +11,7 @@ export { formatCacheFetchAllRecoveryCommand, recoveryHintForStaleFailure, } from
 export const ENV_SKIP = "DEFT_SESSION_RITUAL_SKIP";
 export { ENTRYPOINT_TIMEOUT_EXIT_CODE, ENTRYPOINT_TIMEOUT_SECONDS, } from "./ritual-entrypoint.js";
 export const GATED_ENTRYPOINT_COMMANDS = {
+    agent_hooks: ["verify:hooks-installed", "--scope=agent", "--live"],
     doctor: ["doctor"],
     cache_fresh: ["verify:cache-fresh"],
 };
@@ -26,16 +27,11 @@ function stepPasses(step) {
 }
 function failedStepMessage(tierName, stepName, step) {
     const coldCmd = formatSessionStartRecoveryCommand("cold");
-    if (step === null || step === undefined) {
+    if (step === undefined) {
         return (`session ritual ${tierName} step '${stepName}' is missing. ` +
             `Run \`${coldCmd}\` before implementation dispatch.`);
     }
-    if (typeof step === "object" &&
-        step !== null &&
-        step.deferred_reason) {
-        return "";
-    }
-    const message = typeof step === "object" && step !== null ? step.message : null;
+    const message = step.message;
     const suffix = typeof message === "string" && message.length > 0 ? `: ${message}` : "";
     return `session ritual ${tierName} step '${stepName}' failed${suffix}`;
 }
@@ -53,9 +49,9 @@ export function formatRitualRecoveryInstruction(tier = "cold") {
         `(one-shot: session:start + gated ritual + cache recovery as needed).`);
 }
 function runGatedStep(projectRoot, payload, stepName, runner, now) {
-    const command = [...(GATED_ENTRYPOINT_COMMANDS[stepName] ?? [])];
+    const command = [...GATED_ENTRYPOINT_COMMANDS[stepName]];
     const { code, stdout, stderr } = runner(command, projectRoot);
-    const message = stdout.trim() || stderr.trim() || `${command[0] ?? stepName} exited ${code}`;
+    const message = stdout.trim() || stderr.trim() || `${command[0]} exited ${code}`;
     const gated = payload.gated_steps ?? {};
     gated[stepName] = ritualStep({
         ok: code === 0,
@@ -354,11 +350,15 @@ export function verifySessionRitual(projectRoot, options = {}) {
         const gated = { ...payload.gated_steps };
         payload.gated_steps = gated;
         const runCmd = options.runner ?? defaultRitualRunner;
+        const forced = new Set(options.forceGatedSteps ?? []);
         for (const stepName of GATED_STEPS) {
             const step = gated[stepName];
-            if (step?.deferred_reason)
+            if (step?.deferred_reason && stepName !== "agent_hooks")
                 continue;
-            if (stepPasses(step))
+            // Hook readiness is a live mutation prerequisite, not a cacheable doctor
+            // result. Re-run it at every gated boundary so registration/shim drift
+            // cannot remain hidden behind an earlier green ritual record.
+            if (stepName !== "agent_hooks" && stepPasses(step) && !forced.has(stepName))
                 continue;
             const writeError = runGatedStep(projectRoot, payload, stepName, runCmd, instant);
             if (writeError !== null) {

package/dist/slash/product-set.js

@@ -109,9 +109,12 @@ export const PRODUCT_COMMANDS = Object.freeze([
     {
         logicalId: "/deft:checkpoint",
         filenameStem: "deft-checkpoint",
+        // description documents the save path; wrappers load the strategy doc (same as continue).
+        // ⊗ Point dispatchPath at xbrief/continue.xbrief.json — that file is the checkpoint *output*,
+        // not the instruction doc; first invoke fails when it does not exist yet (#3105).
         description: "Save session state to xbrief/continue.xbrief.json",
         dispatchKind: "session",
-        dispatchPath: "xbrief/continue.xbrief.json",
+        dispatchPath: "resilience/continue-here.md",
     },
 ]);
 /**

package/dist/swarm/verify-review-clean.d.ts

@@ -1,7 +1,6 @@
-import type { CiGateOptions } from "../pr-merge-readiness/ci-gate.js";
-import type { SlizardGateOptions } from "../pr-merge-readiness/slizard-gate.js";
+import { type ComputeGateOptions } from "../pr-merge-readiness/compute.js";
 import type { RunGhFn } from "../pr-merge-readiness/types.js";
-type ReviewGateOptions = CiGateOptions & SlizardGateOptions;
+type ReviewGateOptions = ComputeGateOptions;
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 export interface CohortResolutionError {
     vbrief_path: string;
@@ -15,6 +14,8 @@ export interface CohortPRResult {
     clean: boolean;
     ci_summary: Record<string, unknown> | null;
     slizard_summary: Record<string, unknown> | null;
+    via?: string;
+    partial_data?: Record<string, unknown>;
 }
 export interface CohortResult {
     repo: string | null;

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/tool-events/classify.js

@@ -212,6 +212,7 @@ const VERIFY_TASK_VERBS = new Set([
     "verify:forward-coverage",
     "verify:story-ready",
     "verify:review-monitor",
+    "verify:l4-owner",
     "pr:watch",
     "pr:merge-ready",
     "coverage:hotspots",

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