@deftai/directive-core 0.94.0 → 0.96.0

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/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/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/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