@humanbased/crosscheck 1.2.0-beta.81 → 1.2.0

package/dist/lib/runner.js

@@ -3,31 +3,21 @@ import { randomUUID } from 'crypto';
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
-import { filterStepsByTypes } from './repo-workflow.js';
 import { runCodexReview } from '../reviewers/codex.js';
 import { runClaudeReview } from '../reviewers/claude.js';
 import { runFixStep, runCodexFixStep } from '../reviewers/fix.js';
 import { runConflictResolveStep, findConflictedFiles } from '../reviewers/conflict-resolve.js';
 import { parseVerdict, prependVerdictToComment, NULL_VERDICT_WARNING, applySeverityGate, SEVERITY_GATE_NOTE } from '../lib/verdict.js';
 import { createGithubClient, postReviewComment, getLastCrossCheckCommentId, getLastCrossCheckReviewComment } from '../github/client.js';
-import { resolveLinearAuth, withWorker } from '../linear/identity.js';
-import { notifyLinear } from '../linear/notify.js';
-import { shouldPostToLinear } from '../linear/comment.js';
-import { getLinearCredentials } from '../config/loader.js';
 import { acquireRemoteLock, releaseRemoteLock } from '../github/review-status.js';
 import { log as fileLog, logError, classifyError } from '../lib/logger.js';
 import { buildCommitTrailers } from '../lib/annotation.js';
 import { resolveClaudeModel, resolveCodexModel } from '../lib/review-models.js';
-import { resolveReviewStrategy, escalate, clampToLevels } from './review-strategy.js';
-import { CLAUDE_EFFORT_LEVELS, CODEX_EFFORT_LEVELS } from '../config/schema.js';
 import { buildStepIdentityFields } from '../lib/event-fields.js';
-import { buildAttributionFooter, buildFixAppliedCommentBody, buildFixFailedCommentBody, buildConflictResolvedCommentBody, buildRetriedReviewBanner } from '../lib/comment-bodies.js';
-import { linearWritePossible, loadWorkflow, loadHarnessSection, evaluateWhen } from '../lib/workflow.js';
+import { buildFixAppliedCommentBody, buildConflictResolvedCommentBody, buildRetriedReviewBanner } from '../lib/comment-bodies.js';
+import { loadWorkflow, loadHarnessSection, evaluateWhen } from '../lib/workflow.js';
 import { isSubscriptionLimitError, isVendorUnavailableError } from '../lib/smart-switch.js';
 import { tierTimeoutMs } from '../reviewers/tier-timeouts.js';
-import { loadSkillCatalog } from '../skills/catalog.js';
-import { createSkillActivationSession } from '../skills/broker.js';
-import { formatSkillAttribution } from '../skills/attribution.js';
 const MAX_CROSSCHECK_COMMITS = 5;
 const FIX_RETRY_DELAY_MS = 2 * 60 * 1000;
 const REVIEW_RETRY_DELAY_MS = 2 * 60 * 1000;
@@ -59,27 +49,33 @@ function isTransientApiError(err) {
 export function getEffectiveStepType(stepType, isRecheckRun) {
     return stepType === 'review' && isRecheckRun ? 'recheck' : stepType;
 }
-export function countCrosscheckCommitsForPRDetailed(tmpDir, baseRef) {
+// Counts crosscheck-authored commits unique to this PR (ahead of base) rather
+// than the branch's full history. Long-lived integration branches like
+// `staging` accumulate [crosscheck] commits from many merged PRs — counting
+// those would trip the per-PR fix-loop guard immediately and skip fix/recheck.
+//
+// Fails closed: when `origin/<base>` isn't available (e.g. clone fetched the
+// base ref with `base_branch_fetch_skipped`), fall back to the full-history
+// count rather than returning 0. Over-counting can stop fix early; returning 0
+// would silently disable the cap and let runaway fix loops keep pushing.
+export function countCrosscheckCommitsForPR(tmpDir, baseRef) {
     const runLog = (args) => execFileSync('git', ['log', '--oneline', ...args], { cwd: tmpDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
     const count = (out) => out.split('\n').filter(l => l.includes('[crosscheck]')).length;
     try {
-        return { count: count(runLog([`origin/${baseRef}..HEAD`])), scoped: true };
+        return count(runLog([`origin/${baseRef}..HEAD`]));
     }
     catch {
         // Scoped range unavailable — fall back to full history so the cap still
-        // applies. Over-counts when the branch has prior merged crosscheck commits,
-        // but that's preferable to bypassing the safety guard.
+        // applies. May over-count when the branch has prior merged crosscheck
+        // commits, but that's preferable to bypassing the safety guard.
         try {
-            return { count: count(runLog([])), scoped: false };
+            return count(runLog([]));
         }
         catch {
-            return { count: 0, scoped: false };
+            return 0;
         }
     }
 }
-export function countCrosscheckCommitsForPR(tmpDir, baseRef) {
-    return countCrosscheckCommitsForPRDetailed(tmpDir, baseRef).count;
-}
 export function buildWorkflowCompleteEvent(inputs) {
     const stepValues = Object.values(inputs.results);
     const lastVerdict = stepValues.reverse().find(r => r.verdict !== undefined)?.verdict ?? null;
@@ -242,173 +238,8 @@ function diffBucket(totalLines) {
         return 'large';
     return 'xlarge';
 }
-/**
- * Builds the input the review strategy classifies on, from the already-cloned
- * working copy rather than the API — the runner has the repo on disk, so this
- * costs one `git diff` instead of a round trip.
- *
- * Returns null when the diff can't be read. Callers then fall back to the
- * configured tier, which is why `quality.tier` stays meaningful under smart mode.
- */
-export function buildPRContext(ctx) {
-    const { tmpDir, pr } = ctx;
-    try {
-        // execFileSync, not execSync: a git ref may legally contain `;`, `$( )` and
-        // backticks, and this value drives routing rather than best-effort logging.
-        const raw = execFileSync('git', ['diff', '--numstat', `origin/${pr.base.ref}...HEAD`], { cwd: tmpDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
-        if (!raw)
-            return null;
-        const files = [];
-        let additions = 0;
-        let deletions = 0;
-        for (const line of raw.split('\n')) {
-            // numstat: <added>\t<deleted>\t<path>. Binary files report '-' for both.
-            const [add, del, ...rest] = line.split('\t');
-            const path = rest.join('\t').trim();
-            if (!path)
-                continue;
-            files.push(path);
-            additions += parseInt(add, 10) || 0;
-            deletions += parseInt(del, 10) || 0;
-        }
-        if (files.length === 0)
-            return null;
-        return {
-            files,
-            additions,
-            deletions,
-            labels: pr.labels?.map(l => l.name) ?? [],
-            title: pr.title,
-            baseRef: pr.base.ref,
-            ...(pr.base.repo.default_branch !== undefined && { defaultBranch: pr.base.repo.default_branch }),
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Folds a resolved strategy into the quality config the reviewers receive, so
- * every downstream `quality.tier` read picks up the per-PR decision without
- * threading a new parameter through each vendor signature.
- *
- * A null strategy — fixed mode, or an unreadable diff — returns the config
- * untouched, which is why `quality.tier` remains the documented fallback.
- */
-export function strategyQuality(quality, strategy) {
-    if (!strategy?.tier)
-        return quality;
-    return { ...quality, tier: strategy.tier };
-}
-/**
- * Applies the class's effort alongside its tier. Without this the strategy's
- * effort was resolved and logged but never sent, so the run line named a level
- * the CLI was never given.
- *
- * `accepted` is the vendor CLI's vocabulary, which is narrower than the model's:
- * the strategy escalates to `xhigh` on round 3 and claude-opus-5 reasons at that
- * level, but the claude CLI has no flag for it, so claudeEffort() mapped the
- * unknown value to `medium` — a round 3 weaker than round 2. Clamp here, where
- * the strategy meets the config, rather than at each CLI.
- */
-export function strategyVendor(vendor, strategy, accepted) {
-    if (!strategy?.effort)
-        return vendor;
-    const effort = clampToLevels(strategy.effort, accepted);
-    if (effort === null)
-        return vendor;
-    return { ...vendor, effort };
-}
-// NOTE on the asymmetry with `model`: an explicit vendors.*.model is honored
-// over the strategy, but vendors.*.effort is not. That is deliberate rather than
-// an oversight — `effort` carries a schema default, so a parsed config cannot
-// distinguish "the user chose medium" from "nobody set it", and treating the
-// default as a user choice would disable effort escalation for everyone. The
-// override is documented in crosscheck.config.example.yml next to the model
-// note; set `quality.mode: fixed` to keep a hand-set effort on every call.
-/**
- * True when the strategy actually determined the model that ran.
- *
- * Judged from the resolved model rather than from config shape, because two
- * different configs defeat the tier map:
- *   - an explicit `vendors.*.model` outranks it, and
- *   - codex under subscription auth with no `model`/`model_tiers` resolves every
- *     tier to the CLI's own `default`, so fast/balanced/thorough are the same run.
- * In both cases the strategy's tier is not what happened, and citing it would
- * assert a routing decision that never took place — the exact auditability
- * property this feature exists to provide.
- */
-export function strategyDeterminedModel(vendor, strategy, resolvedModel) {
-    if (strategy === null || vendor.model)
-        return false;
-    // 'default' means the vendor CLI chose, not us.
-    return resolvedModel !== 'default';
-}
-/**
- * Classifies the PR and resolves the strategy, or returns null under
- * `quality.mode: fixed` so the single configured tier applies unchanged.
- */
-export function resolveStrategyForPR(ctx) {
-    if (ctx.config.quality.mode !== 'smart')
-        return null;
-    const prContext = buildPRContext(ctx);
-    if (!prContext)
-        return null;
-    return resolveReviewStrategy(prContext);
-}
-/**
- * The tier, effort, and vendor configs every step of one round runs under.
- *
- * One function rather than a fold at each use site: the review step ran the
- * escalated strategy while the fix step re-folded the base class, so a promoted
- * round reviewed with the stronger model and then fixed with the weaker one —
- * and took the weaker tier's subprocess timeout with it.
- *
- * Rounds beyond the first escalate: the class tier was already tried and did not
- * resolve the PR, so difficulty is now measured rather than predicted. escalate()
- * raises effort where the model supports it and promotes a tier where it does
- * not, and never weakens the model.
- */
-export function resolveRoundExecution(config, strategy, round) {
-    if (!strategy) {
-        return {
-            strategy: null,
-            quality: config.quality,
-            claudeVendor: config.vendors.claude,
-            codexVendor: config.vendors.codex,
-            roundConfig: config,
-            escalated: false,
-        };
-    }
-    // The vendors that may actually run this round, each with the model it would
-    // use and the vocabulary its CLI accepts. Keyed to the enabled vendors rather
-    // than to claude alone: on a codex-only install the claude tier model is never
-    // called, so judging escalation by its effort ladder promoted a tier every
-    // round while codex sat at the effort it started on.
-    const baseQuality = strategyQuality(config.quality, strategy);
-    const lanes = [];
-    if (config.vendors.claude.enabled) {
-        lanes.push({ model: resolveClaudeModel(baseQuality, config.vendors.claude), accepted: CLAUDE_EFFORT_LEVELS });
-    }
-    if (config.vendors.codex.enabled) {
-        lanes.push({ model: resolveCodexModel(baseQuality, config.vendors.codex), accepted: CODEX_EFFORT_LEVELS });
-    }
-    const escalated = escalate({ tier: strategy.tier ?? config.quality.tier, effort: strategy.effort }, round, lanes);
-    const roundStrategy = { ...strategy, tier: escalated.tier, effort: escalated.effort };
-    const quality = strategyQuality(config.quality, roundStrategy);
-    const claudeVendor = strategyVendor(config.vendors.claude, roundStrategy, CLAUDE_EFFORT_LEVELS);
-    const codexVendor = strategyVendor(config.vendors.codex, roundStrategy, CODEX_EFFORT_LEVELS);
-    return {
-        strategy: roundStrategy,
-        quality,
-        claudeVendor,
-        codexVendor,
-        roundConfig: { ...config, quality, vendors: { ...config.vendors, claude: claudeVendor, codex: codexVendor } },
-        escalated: escalated.tier !== strategy.tier || escalated.effort !== strategy.effort,
-    };
-}
-function emitPRComplexity(ctx, triggerField, effectiveTierForRun) {
-    const { owner, repoName, prNumber, tmpDir, pr } = ctx;
+function emitPRComplexity(ctx, triggerField) {
+    const { owner, repoName, prNumber, tmpDir, pr, config } = ctx;
     try {
         const raw = execSync(`git diff --stat origin/${pr.base.ref}...HEAD`, { cwd: tmpDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
         if (!raw)
@@ -439,7 +270,7 @@ function emitPRComplexity(ctx, triggerField, effectiveTierForRun) {
             diff_bucket: diffBucket(insertions + deletions),
             file_mix: mix,
             languages: [...langSet],
-            quality_tier: effectiveTierForRun,
+            quality_tier: config.quality.tier,
             ...triggerField,
         });
     }
@@ -508,68 +339,12 @@ async function pushWithNonFastForwardHandling(params) {
 export async function runWorkflow(ctx) {
     const { owner, repoName, prNumber, pr, tmpDir, token, config, origin, log, onPhaseChange, trigger } = ctx;
     const triggerField = trigger !== undefined ? { trigger } : {};
-    const configuredSteps = (ctx.steps ?? loadWorkflow(process.cwd())).map(step => {
+    const steps = (ctx.steps ?? loadWorkflow(process.cwd())).map(step => {
         if (!step.harness || step.instructions)
             return step;
         const resolved = loadHarnessSection(step.harness, process.cwd());
         return resolved ? { ...step, instructions: resolved } : step;
     });
-    // Resolved once per runWorkflow call: the fix step pushes commits, so
-    // re-classifying per step could yield a different class and make the review
-    // and recheck comments cite different tiers for the same PR.
-    //
-    // Not once per PR: --crazy/--halfcrazy re-enter runWorkflow per round, and by
-    // then the diff includes crosscheck's own fix commits, so a later round can
-    // legitimately classify differently. Each comment cites the class that
-    // produced it, so the record stays accurate either way.
-    const strategy = resolveStrategyForPR(ctx);
-    if (config.quality.mode === 'smart' && !strategy) {
-        // A smart-mode install quietly behaving as fixed is otherwise invisible.
-        fileLog({ level: 'warn', event: 'strategy_unresolved', repo: `${owner}/${repoName}`, pr: prNumber, reason: 'pr_context_unavailable', fallback_tier: config.quality.tier });
-    }
-    else if (strategy) {
-        // A config written before `mode` existed parses as smart on upgrade, so a
-        // hand-set `quality.tier` can be silently overridden. onboard preserves the
-        // old tier by reading raw yaml, but that only helps users who re-run it —
-        // so record it here for everyone else.
-        //
-        // info, not warn: `config.quality.tier` carries a schema default of
-        // `balanced` on every install, so the parsed config cannot tell a hand-set
-        // tier from an unset one. Five of the eight classes resolve to something
-        // other than balanced, which made this fire on the majority of PRs — and
-        // recommend a `mode: fixed` opt-out to users who never chose a tier at all.
-        // Only the raw yaml can draw that distinction (thoroughnessDefaults), and it
-        // is not available on this path.
-        if (strategy.tier && strategy.tier !== config.quality.tier) {
-            fileLog({ level: 'info', event: 'strategy_overrode_configured_tier', repo: `${owner}/${repoName}`, pr: prNumber, configured_tier: config.quality.tier, applied_tier: strategy.tier, pr_class: strategy.classId });
-        }
-        fileLog({ level: 'info', event: 'strategy_resolved', repo: `${owner}/${repoName}`, pr: prNumber, strategy_version: strategy.version, pr_class: strategy.classId, tier: strategy.tier, effort: strategy.effort, steps: strategy.steps, domain: strategy.domain });
-    }
-    // The class's step set NARROWS the configured pipeline; it never widens it.
-    // A repo set to review-only stays review-only whatever the class says, which
-    // matches how per-repo `crosscheck alter` overrides compose. Reuses
-    // filterStepsByTypes so the conflict-resolve rule (orthogonal to the depth
-    // ladder, kept only when the depth permits code modification) stays in one
-    // place rather than being re-derived here.
-    const steps = (() => {
-        if (!strategy || strategy.steps.length === 0)
-            return configuredSteps;
-        const classTypes = strategy.steps.filter((t) => t === 'review' || t === 'fix' || t === 'recheck');
-        if (classTypes.length === 0)
-            return configuredSteps;
-        const narrowed = filterStepsByTypes(configuredSteps, classTypes);
-        const dropped = configuredSteps.length - narrowed.length;
-        if (dropped > 0) {
-            log(chalk.dim(`  strategy v${strategy.version}: ${strategy.classId} → ${classTypes.join(', ')} (${dropped} step${dropped === 1 ? '' : 's'} dropped)`));
-            fileLog({ level: 'info', event: 'strategy_steps_narrowed', repo: `${owner}/${repoName}`, pr: prNumber, pr_class: strategy.classId, configured: configuredSteps.map((x) => x.type), applied: narrowed.map((x) => x.type), strategy_version: strategy.version });
-        }
-        return narrowed;
-    })();
-    if (strategy && strategy.tier === null) {
-        log(chalk.dim(`  strategy v${strategy.version}: ${strategy.classId} → skipped (${strategy.reason})`));
-        fileLog({ level: 'info', event: 'pr_skipped', repo: `${owner}/${repoName}`, pr: prNumber, reason: 'strategy_class_skip', pr_class: strategy.classId, strategy_version: strategy.version });
-        return { verdict: null, strategySkipped: strategy.classId };
-    }
     const results = {};
     // SHAs the workflow pushed AND set a `crosscheck/review` pending status on.
     // Each one must be released in the finally below — otherwise the pending
@@ -581,47 +356,6 @@ export async function runWorkflow(ctx) {
     // can iterate the same list and release these shas if SIGINT/SIGTERM fires
     // mid-workflow (process.exit there bypasses our finally below).
     const pushedShasNeedingRelease = ctx.pushedShas ?? [];
-    const skillCatalog = config.skills.enabled.length > 0 ? loadSkillCatalog() : [];
-    const skillSessions = new Map();
-    const skillSessionFor = (stepName, stepType) => {
-        if (skillCatalog.length === 0)
-            return undefined;
-        const existing = skillSessions.get(stepName);
-        if (existing)
-            return existing;
-        const session = createSkillActivationSession(stepType, config.skills.enabled, skillCatalog);
-        skillSessions.set(stepName, session);
-        return session;
-    };
-    // Skills were offered and the agent took none. Silent before, which is how a
-    // prompt that never triggered activation ran unnoticed for 336 steps.
-    // `skills_activated: []` on the *_complete events says something similar but
-    // quietly; what is new here is `enabled` (what was actually on offer) and the
-    // warn level, which makes a step that activates nothing greppable on its own.
-    const logSkillsNoneActivated = (session, identity) => {
-        // skillSessionFor hands back a session whenever the catalog is non-empty,
-        // but createSkillActivationSession filters that catalog down to
-        // config.skills.enabled — so a configured name that never resolved (typo,
-        // skill not installed) leaves enabledSkills empty, and then
-        // renderSkillBrokerInstructions renders nothing at all. Nothing was offered,
-        // so nothing was refused: that is broken config, not agent non-compliance,
-        // and logging it here would conflate the two causes the event exists to
-        // tell apart.
-        if (session.enabledSkills.length === 0)
-            return;
-        fileLog({ level: 'warn', event: 'skills_none_activated', repo: `${owner}/${repoName}`, pr: prNumber, ...identity, enabled: session.enabledSkills.map(skill => skill.name) });
-    };
-    // Linear write-back identity. Resolved up front — before any expensive step —
-    // and allowed to throw. The contract is that a configured-but-failing
-    // client_credentials mint ABORTS rather than degrading, because silently
-    // continuing would either drop the write or re-attribute it to a human. This
-    // matches commands/review.ts; the two paths must not disagree.
-    // The contract is one token per command run. runWorkflow is re-entered for every
-    // fix/recheck round under --crazy and max_rounds, so minting here would mint per
-    // round and let a late transient failure abort work already done. The caller
-    // resolves once and passes it in; resolving here is the single-round fallback.
-    // A dry run posts nothing, so it never mints.
-    let linearAuth = ctx.linearAuth ?? null;
     let workflowFailed = false;
     let workflowError = undefined;
     let failedStep = undefined;
@@ -650,42 +384,8 @@ export async function runWorkflow(ctx) {
     const workflowStart = Date.now();
     const stepsRun = [];
     let currentStepName;
-    // Class picks tier AND effort under smart; untouched config under fixed.
-    // Every step of this round reads from here — review, fix, and recheck alike —
-    // so a promoted round cannot review with one model and fix with another.
-    //
-    // Above the try, and above emitPRComplexity, because both the complexity event
-    // and workflow_complete report the tier that ran: an escalated round reporting
-    // the base class tier is the same defect as a comment citing one.
-    const { strategy: roundStrategy, quality, claudeVendor, codexVendor, roundConfig, escalated } = resolveRoundExecution(config, strategy, ctx.round ?? 1);
-    emitPRComplexity(ctx, triggerField, quality.tier);
+    emitPRComplexity(ctx, triggerField);
     try {
-        // Inside the try so a preflight failure still reaches the completion handler in
-        // the finally — resolving above it meant a failed mint skipped workflow_complete
-        // entirely and left no record of the run.
-        // canWriteVerdict here too: the caller passes null deliberately when the selected
-        // steps cannot write a verdict, and this fallback previously read that as
-        // "unresolved" and resolved anyway — defeating the gate one line upstream.
-        if (!ctx.dryRun && !linearAuth && linearWritePossible(config.linear, steps)) {
-            linearAuth = await resolveLinearAuth(config.linear, getLinearCredentials(config.linear.auth));
-            fileLog({ level: 'info', event: 'linear_auth_resolved', repo: `${owner}/${repoName}`, pr: prNumber, mode: linearAuth.mode, actor: linearAuth.actor });
-        }
-        // Logged once per run, not per step: nothing here depends on `step`, and
-        // recomputing inside the loop printed the same line for review and recheck.
-        if (strategy && roundStrategy) {
-            // Report the effort each vendor was actually GIVEN, not the level the round
-            // asked for. The two CLI vocabularies differ, so one round can send codex
-            // `xhigh` and claude `high`; printing the request names a level nobody ran.
-            const appliedEffort = [...new Set([
-                    ...(config.vendors.claude.enabled ? [claudeVendor.effort] : []),
-                    ...(config.vendors.codex.enabled ? [codexVendor.effort] : []),
-                ])].join('/');
-            const escalatedNote = escalated ? ` · round ${ctx.round} escalated` : '';
-            log(chalk.dim(`  strategy v${strategy.version}: ${strategy.classId} → ${roundStrategy.tier ?? 'skip'} tier${appliedEffort ? ` (${appliedEffort})` : ''}${escalatedNote}`));
-            if (escalatedNote) {
-                fileLog({ level: 'info', event: 'strategy_escalated', repo: `${owner}/${repoName}`, pr: prNumber, round: ctx.round, from_tier: strategy.tier, to_tier: roundStrategy.tier, from_effort: strategy.effort, to_effort: roundStrategy.effort, applied_effort_claude: config.vendors.claude.enabled ? claudeVendor.effort : null, applied_effort_codex: config.vendors.codex.enabled ? codexVendor.effort : null, strategy_version: strategy.version });
-            }
-        }
         for (const step of steps) {
             currentStepName = step.name;
             stepsRun.push(step.name);
@@ -748,21 +448,17 @@ export async function runWorkflow(ctx) {
                 let inputTokens;
                 let outputTokens;
                 let model = 'default';
-                let effort;
                 let retried;
-                const skillSession = skillSessionFor(step.name, effectiveType);
-                // Under `quality.mode: smart` the PR's class picks the tier; under fixed
-                // this is config.quality untouched.
                 const runReviewWithVendor = async (candidate) => {
                     if (candidate === 'codex') {
                         ;
-                        ({ review: rawReview, tokensUsed, model, effort, retried } = await runCodexReview(tmpDir, pr.base.ref, pr.title, quality, codexVendor, step.instructions, undefined, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.codex.timeout_sec), log, ctx.issueContext, skillSession));
+                        ({ review: rawReview, tokensUsed, model, retried } = await runCodexReview(tmpDir, pr.base.ref, pr.title, config.quality, config.vendors.codex, step.instructions, undefined, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.codex.timeout_sec), log, ctx.issueContext));
                         inputTokens = undefined;
                         outputTokens = undefined;
                     }
                     else {
                         ;
-                        ({ review: rawReview, tokensUsed, inputTokens, outputTokens, model, effort, retried } = await runClaudeReview(tmpDir, pr.base.ref, pr.title, quality, claudeVendor, config.budget.per_review_usd, step.instructions, undefined, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec), !!ctx.roundMode, log, ctx.issueContext, skillSession));
+                        ({ review: rawReview, tokensUsed, inputTokens, outputTokens, model, retried } = await runClaudeReview(tmpDir, pr.base.ref, pr.title, config.quality, config.vendors.claude, config.budget.per_review_usd, step.instructions, undefined, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec), !!ctx.roundMode, log, ctx.issueContext));
                     }
                 };
                 try {
@@ -819,11 +515,6 @@ export async function runWorkflow(ctx) {
                         }
                     }
                 }
-                const activatedSkills = skillSession?.activations() ?? [];
-                if (activatedSkills.length > 0)
-                    log(chalk.dim(`  skills: ${formatSkillAttribution(activatedSkills)}`));
-                else if (skillSession)
-                    logSkillsNoneActivated(skillSession, stepIdentity);
                 // First attempt timed out but the delayed retry succeeded — surface a
                 // soft notice on the review comment so the author knows it was a transient blip.
                 if (retried) {
@@ -845,17 +536,15 @@ export async function runWorkflow(ctx) {
                 const baseBody = verdict === null
                     ? `${NULL_VERDICT_WARNING}\n\n${clean}`
                     : prependVerdictToComment(gate.downgraded ? `${SEVERITY_GATE_NOTE}\n\n${clean}` : clean, verdict);
-                // Skills are not folded into the body — postReviewComment renders the
-                // receipt beneath the attribution footer.
                 const commentBody = retried
                     ? `${buildRetriedReviewBanner(retried.timeoutMs, retried.delayMs)}\n\n${baseBody}`
                     : baseBody;
                 const commentCount = countComments(rawReview);
-                fileLog({ level: 'info', event: 'review_complete', repo: `${owner}/${repoName}`, pr: prNumber, reviewer, model, ...stepIdentity, verdict, duration_ms: Date.now() - stepStart, tokens_used: tokensUsed, skills_activated: activatedSkills.map(skill => skill.name), ...(inputTokens !== undefined && { input_tokens: inputTokens }), ...(outputTokens !== undefined && { output_tokens: outputTokens }), ...(ctx.round !== undefined && { round: ctx.round }), ...(ctx.roundMode && { mode: ctx.roundMode }), ...triggerField });
+                fileLog({ level: 'info', event: 'review_complete', repo: `${owner}/${repoName}`, pr: prNumber, reviewer, model, ...stepIdentity, verdict, duration_ms: Date.now() - stepStart, tokens_used: tokensUsed, ...(inputTokens !== undefined && { input_tokens: inputTokens }), ...(outputTokens !== undefined && { output_tokens: outputTokens }), ...(ctx.round !== undefined && { round: ctx.round }), ...(ctx.roundMode && { mode: ctx.roundMode }), ...triggerField });
                 // Recheck verdict is stored separately to preserve the original review's commentCount on the board
                 const phaseUpdate = isRecheck
-                    ? { recheckVerdict: verdict, phase: donePhase, recheckTokens: tokensUsed, recheckReviewer: reviewer, qualityTier: quality.tier }
-                    : { verdict, commentCount, phase: donePhase, crTokens: tokensUsed, crReviewer: reviewer, qualityTier: quality.tier };
+                    ? { recheckVerdict: verdict, phase: donePhase, recheckTokens: tokensUsed, recheckReviewer: reviewer, qualityTier: config.quality.tier }
+                    : { verdict, commentCount, phase: donePhase, crTokens: tokensUsed, crReviewer: reviewer, qualityTier: config.quality.tier };
                 if (ctx.dryRun) {
                     onPhaseChange('dry-run — comment not posted', phaseUpdate);
                     log(chalk.dim(`\n--- dry-run: comment that would be posted ---\n${commentBody}\n--- end ---`));
@@ -890,47 +579,9 @@ export async function runWorkflow(ctx) {
                         annotationSha = execSync('git rev-parse HEAD', { cwd: tmpDir, encoding: 'utf8' }).trim();
                     }
                     catch { /* fall back to pr.head.sha if git is unavailable */ }
-                    const commentId = await postReviewComment(octokit, owner, repoName, prNumber, commentBody, reviewer, config.brand, origin, verdict ?? undefined, priorReviewId, isRecheck, model, effectiveType, ctx.round ?? 1, annotationSha, nextStepAnnotation, ctx.trigger === 'kickass' ? 'kickass' : undefined, activatedSkills, effort, 
-                    // Withheld when an explicit vendors.*.model overrode the tier map:
-                    // citing a tier the run did not use would assert a routing decision
-                    // that never happened.
-                    strategyDeterminedModel(reviewer === 'codex' ? config.vendors.codex : config.vendors.claude, roundStrategy, model) && roundStrategy?.tier
-                        ? { version: roundStrategy.version, classId: roundStrategy.classId, tier: roundStrategy.tier, reason: roundStrategy.reason }
-                        : undefined);
+                    const commentId = await postReviewComment(octokit, owner, repoName, prNumber, commentBody, reviewer, config.brand, origin, verdict ?? undefined, priorReviewId, isRecheck, model, effectiveType, ctx.round ?? 1, annotationSha, nextStepAnnotation, ctx.trigger === 'kickass' ? 'kickass' : undefined);
                     const commentUrl = `github.com/${owner}/${repoName}/pull/${prNumber}`;
                     fileLog({ level: 'info', event: 'comment_posted', repo: `${owner}/${repoName}`, pr: prNumber, url: `https://${commentUrl}` });
-                    // Mirror the verdict onto the PR's Linear issue. `run` and `watch` both
-                    // land here, so this is the path that matters — reviews posted from
-                    // commands/review.ts are the exception, not the rule.
-                    if (linearAuth && shouldPostToLinear(verdict ?? null, config.linear.comment_on)) {
-                        {
-                            // Attribute to crosscheck/review, /fix, /recheck rather than a flat actor.
-                            const stepAuth = config.linear.identity.per_step_actor ? withWorker(linearAuth, effectiveType) : linearAuth;
-                            const linearResult = await notifyLinear({
-                                auth: stepAuth,
-                                config: config.linear,
-                                pr: { branch: pr.head.ref, title: pr.title, body: pr.body ?? '', url: `https://${commentUrl}`, sha: annotationSha },
-                                verdict: verdict ?? null,
-                                reviewer,
-                                origin,
-                                model,
-                                stepType: effectiveType,
-                                round: ctx.round ?? 1,
-                                service: config.brand.service_name,
-                            });
-                            fileLog({
-                                level: linearResult.status === 'failed' ? 'warn' : 'info',
-                                event: 'linear_comment', repo: `${owner}/${repoName}`, pr: prNumber,
-                                status: linearResult.status, reason: linearResult.reason, issue: linearResult.identifier,
-                            });
-                            if (linearResult.status === 'posted') {
-                                log(chalk.dim(`  linear: commented on ${linearResult.identifier}`));
-                            }
-                            else if (linearResult.status === 'failed') {
-                                log(chalk.yellow(`  linear: write failed — ${linearResult.reason}`));
-                            }
-                        }
-                    }
                     results[step.name] = { verdict, commentBody, commentUrl, commentId, tokens_used: tokensUsed, input_tokens: inputTokens, output_tokens: outputTokens, vendor: reviewer, model };
                 }
             }
@@ -990,28 +641,17 @@ export async function runWorkflow(ctx) {
                     skipFix('no_vendor');
                     continue;
                 }
-                // The fix step holds the review's tier — this round's, escalation
-                // included: it is generation against an explicit findings list, which
-                // models handle well, but a cheap fixer that introduces a regression costs
-                // a whole extra round. Recheck does not step down either — it decides
-                // whether to spend another round, and a weak judge there is how loops run
-                // away.
-                const claudeFixModel = resolveClaudeModel(quality, claudeVendor);
-                const codexFixModel = resolveCodexModel(quality, codexVendor);
+                const claudeFixModel = resolveClaudeModel(config.quality, config.vendors.claude);
+                const codexFixModel = resolveCodexModel(config.quality, config.vendors.codex);
                 // Guard: don't push more than MAX_CROSSCHECK_COMMITS per PR.
                 // Scope to commits ahead of base so long-lived branches (e.g. staging)
                 // don't count [crosscheck] commits from previously merged PRs.
                 // Crazy/halfcrazy mode doubles the cap since it deliberately loops.
-                const commitCount = countCrosscheckCommitsForPRDetailed(tmpDir, pr.base.ref);
+                const existingCount = countCrosscheckCommitsForPR(tmpDir, pr.base.ref);
                 const effectiveCommitLimit = ctx.roundMode ? MAX_CROSSCHECK_COMMITS * 2 : MAX_CROSSCHECK_COMMITS;
-                if (commitCount.count >= effectiveCommitLimit) {
-                    // Report the count, not the limit. An unscoped count means origin/<base>
-                    // was missing, so this is an over-count from whole-repo history rather
-                    // than a real cap hit — say so, or the next person debugs the wrong thing.
-                    log(commitCount.scoped
-                        ? chalk.yellow(`⚠  PR #${prNumber}: ${commitCount.count}/${effectiveCommitLimit} [crosscheck] commits already — stopping auto-fix`)
-                        : chalk.yellow(`⚠  PR #${prNumber}: cannot scope [crosscheck] commit count (origin/${pr.base.ref} missing; ${commitCount.count} across all history) — stopping auto-fix`));
-                    skipFix(commitCount.scoped ? 'commit_limit_reached' : 'commit_count_unscoped');
+                if (existingCount >= effectiveCommitLimit) {
+                    log(chalk.yellow(`⚠  PR #${prNumber}: ${effectiveCommitLimit} [crosscheck] commits already — stopping auto-fix`));
+                    skipFix('commit_limit_reached');
                     continue;
                 }
                 onPhaseChange(`${vendor} fixing...`, { phase: 'fixing' });
@@ -1019,24 +659,18 @@ export async function runWorkflow(ctx) {
                 let appliedCount = 0;
                 let fixChangedFiles = [];
                 let fixTokensUsed;
-                let fixEffort;
                 let fixErr = undefined;
                 let activeVendor = vendor;
-                // The strategy tier, not the configured one: a risky PR runs the thorough
-                // model here, and the balanced 600s budget would cut it off.
-                const tierMs = tierTimeoutMs(quality.tier);
-                const skillSession = skillSessionFor(step.name, effectiveType);
+                const tierMs = tierTimeoutMs(config.quality.tier);
                 const runFix = async (v) => {
                     if (v === 'codex') {
-                        return runCodexFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', codexFixModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.codex.timeout_sec) ?? tierMs, skillSession, codexVendor.effort);
+                        return runCodexFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', codexFixModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.codex.timeout_sec) ?? tierMs);
                     }
-                    // roundConfig, not config: runFixStep reads vendors.claude.effort and
-                    // quality.tier out of it, and both must be this round's values.
-                    return runFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', roundConfig, claudeFixModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec) ?? tierMs, skillSession);
+                    return runFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', config, claudeFixModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec) ?? tierMs);
                 };
                 try {
                     ;
-                    ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed, effort: fixEffort } = await runFix(vendor));
+                    ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed } = await runFix(vendor));
                 }
                 catch (err) {
                     logError({ repo: `${owner}/${repoName}`, pr: prNumber, phase: 'fix', attempt: 1, vendor }, err);
@@ -1050,7 +684,7 @@ export async function runWorkflow(ctx) {
                         fileLog({ level: 'warn', event: 'fix_vendor_fallback', repo: `${owner}/${repoName}`, pr: prNumber, from: vendor, to: fallbackVendor, ...(isSubscriptionLimitError(err) && { reason: 'vendor_limit' }) });
                         try {
                             ;
-                            ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed, effort: fixEffort } = await runFix(fallbackVendor));
+                            ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed } = await runFix(fallbackVendor));
                             activeVendor = fallbackVendor;
                         }
                         catch (fallbackErr) {
@@ -1071,7 +705,7 @@ export async function runWorkflow(ctx) {
                     onPhaseChange(`${activeVendor} fixing (retry)...`, { phase: 'fixing' });
                     try {
                         ;
-                        ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed, effort: fixEffort } = await runFix(activeVendor));
+                        ({ appliedCount, changedFiles: fixChangedFiles, tokensUsed: fixTokensUsed } = await runFix(activeVendor));
                         fileLog({ level: 'info', event: 'fix_retry_succeeded', repo: `${owner}/${repoName}`, pr: prNumber });
                         fixErr = undefined;
                     }
@@ -1080,20 +714,6 @@ export async function runWorkflow(ctx) {
                         fixErr = retryErr;
                     }
                 }
-                const activatedSkills = skillSession?.activations() ?? [];
-                if (activatedSkills.length > 0)
-                    log(chalk.dim(`  skills: ${formatSkillAttribution(activatedSkills)}`));
-                else if (skillSession)
-                    logSkillsNoneActivated(skillSession, { step_type: 'fix', step_name: step.name });
-                // Every delivery mode (commit card, fix PR, suggested-diff comment) closes
-                // with the same footer as a review comment.
-                const fixAttributionFooter = () => buildAttributionFooter({
-                    action: 'Fixed',
-                    vendor: activeVendor,
-                    model: activeVendor === 'codex' ? codexFixModel : claudeFixModel,
-                    effort: fixEffort,
-                    skills: activatedSkills,
-                });
                 if (fixErr !== undefined) {
                     skipFix(isSubscriptionLimitError(fixErr) ? 'vendor_limit' : 'fix_error');
                     // Only notify for transient failures — auth errors are operator issues, not PR author issues
@@ -1102,13 +722,7 @@ export async function runWorkflow(ctx) {
                             const octokit = createGithubClient(token);
                             await octokit.rest.issues.createComment({
                                 owner, repo: repoName, issue_number: prNumber,
-                                body: buildFixFailedCommentBody({
-                                    prUrl: pr.html_url,
-                                    vendor: activeVendor,
-                                    model: activeVendor === 'codex' ? codexFixModel : claudeFixModel,
-                                    effort: fixEffort,
-                                    skills: activatedSkills,
-                                }),
+                                body: `⚠️ **Auto-fix failed**\n\nThe fix step timed out after retrying. Push a new commit or run \`crosscheck run ${pr.html_url}\` to retry manually.\n\n<!-- crosscheck: fix_failed -->`,
                             });
                             fileLog({ level: 'info', event: 'fix_failed_comment_posted', repo: `${owner}/${repoName}`, pr: prNumber });
                         }
@@ -1127,7 +741,7 @@ export async function runWorkflow(ctx) {
                     // event — NOT `fix_complete` — so status consumers (WORKFLOW_ACTIVITY_EVENTS,
                     // the legacy status fold) don't misread a no-op as real workflow progress and
                     // mark the PR NEEDS_RECHECK or hide it from `scan --tidy` with no fix applied.
-                    fileLog({ level: 'info', event: 'fix_noop', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: 0, no_changes: true, tokens_used: fixTokensUsed, skills_activated: activatedSkills.map(skill => skill.name), duration_ms: Date.now() - fixStepStart, ...triggerField });
+                    fileLog({ level: 'info', event: 'fix_noop', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: 0, no_changes: true, tokens_used: fixTokensUsed, duration_ms: Date.now() - fixStepStart, ...triggerField });
                     results[step.name] = { applied_count: 0, ...(fixTokensUsed !== undefined && { tokens_used: fixTokensUsed }), vendor };
                     continue;
                 }
@@ -1179,7 +793,7 @@ export async function runWorkflow(ctx) {
                         }
                     }
                     onPhaseChange('fixed ✓', { fixCount: appliedCount, phase: 'fixed', fixTokens: fixTokensUsed });
-                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, sha: newSha, delivery: 'commit', tokens_used: fixTokensUsed, skills_activated: activatedSkills.map(skill => skill.name), duration_ms: Date.now() - fixStepStart, ...triggerField });
+                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, sha: newSha, delivery: 'commit', tokens_used: fixTokensUsed, duration_ms: Date.now() - fixStepStart, ...triggerField });
                     // Post a summary comment so the silent commit push is visible on the timeline
                     // as a comment card. Best-effort — a failure here must not fail the run.
                     try {
@@ -1190,9 +804,6 @@ export async function runWorkflow(ctx) {
                             changedFiles: fixChangedFiles,
                             vendor: activeVendor,
                             reviewCommentBody,
-                            model: activeVendor === 'codex' ? codexFixModel : claudeFixModel,
-                            effort: fixEffort,
-                            skills: activatedSkills,
                         });
                         await octokit.rest.issues.createComment({ owner, repo: repoName, issue_number: prNumber, body });
                         fileLog({ level: 'info', event: 'fix_applied_comment_posted', repo: `${owner}/${repoName}`, pr: prNumber, sha: newSha });
@@ -1229,13 +840,7 @@ export async function runWorkflow(ctx) {
                         head: fixBranch,
                         base: pr.head.ref,
                         title: fixPrTitle,
-                        body: [
-                            `Auto-fix by crosscheck for CR issues found in #${prNumber}.`,
-                            '',
-                            `Review: https://github.com/${owner}/${repoName}/pull/${prNumber}`,
-                            '',
-                            fixAttributionFooter(),
-                        ].join('\n'),
+                        body: `Auto-fix by crosscheck for CR issues found in #${prNumber}.\n\nReview: https://github.com/${owner}/${repoName}/pull/${prNumber}`,
                     });
                     if (config.post_review.auto_fix.delivery.label) {
                         try {
@@ -1246,7 +851,7 @@ export async function runWorkflow(ctx) {
                         catch { /* label may not exist in this repo — skip */ }
                     }
                     onPhaseChange('fixed ✓', { fixCount: appliedCount, phase: 'fixed', fixTokens: fixTokensUsed });
-                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, sha: newSha, delivery: 'pull_request', fix_pr: fixPr.number, tokens_used: fixTokensUsed, skills_activated: activatedSkills.map(skill => skill.name), duration_ms: Date.now() - fixStepStart, ...triggerField });
+                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, sha: newSha, delivery: 'pull_request', fix_pr: fixPr.number, tokens_used: fixTokensUsed, duration_ms: Date.now() - fixStepStart, ...triggerField });
                     results[step.name] = { applied_count: appliedCount, tokens_used: fixTokensUsed, vendor: activeVendor };
                 }
                 else {
@@ -1258,11 +863,11 @@ export async function runWorkflow(ctx) {
                     catch { /* ignore */ }
                     if (patch) {
                         const octokit = createGithubClient(token);
-                        const body = `### Suggested fixes (crosscheck auto-fix)\n\n\`\`\`diff\n${patch.slice(0, 16000)}\n\`\`\`\n\n${fixAttributionFooter()}`;
+                        const body = `### Suggested fixes (crosscheck auto-fix)\n\n\`\`\`diff\n${patch.slice(0, 16000)}\n\`\`\``;
                         await octokit.rest.issues.createComment({ owner, repo: repoName, issue_number: prNumber, body });
                     }
                     onPhaseChange('fixed ✓', { fixCount: appliedCount, phase: 'fixed', fixTokens: fixTokensUsed });
-                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, delivery: 'comment', tokens_used: fixTokensUsed, skills_activated: activatedSkills.map(skill => skill.name), duration_ms: Date.now() - fixStepStart, ...triggerField });
+                    fileLog({ level: 'info', event: 'fix_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor: activeVendor, applied_count: appliedCount, delivery: 'comment', tokens_used: fixTokensUsed, duration_ms: Date.now() - fixStepStart, ...triggerField });
                     results[step.name] = { applied_count: appliedCount, tokens_used: fixTokensUsed, vendor: activeVendor };
                 }
             }
@@ -1335,9 +940,7 @@ export async function runWorkflow(ctx) {
                     skipConflictResolve('codex_conflict_resolve_unsupported');
                     continue;
                 }
-                // Conflict-resolve is mechanical text surgery bounded by the markers —
-                // measured at 37s against ~643s for a review — so it always runs fast.
-                const conflictResolveModel = resolveClaudeModel({ ...config.quality, tier: config.quality.mode === 'smart' ? 'fast' : config.quality.tier }, config.vendors.claude);
+                const conflictResolveModel = resolveClaudeModel(config.quality, config.vendors.claude);
                 const isFork = pr.head.repo?.full_name !== pr.base.repo.full_name;
                 if (isFork) {
                     try {
@@ -1348,15 +951,13 @@ export async function runWorkflow(ctx) {
                     skipConflictResolve('fork_pr');
                     continue;
                 }
-                const crCommitCount = countCrosscheckCommitsForPRDetailed(tmpDir, pr.base.ref);
-                if (crCommitCount.count >= MAX_CROSSCHECK_COMMITS) {
+                const existingCount = countCrosscheckCommitsForPR(tmpDir, pr.base.ref);
+                if (existingCount >= MAX_CROSSCHECK_COMMITS) {
                     try {
                         execSync('git merge --abort', { cwd: tmpDir });
                     }
                     catch { /* ignore */ }
-                    log(crCommitCount.scoped
-                        ? chalk.yellow(`⚠  PR #${prNumber}: ${crCommitCount.count}/${MAX_CROSSCHECK_COMMITS} [crosscheck] commits already — stopping conflict-resolve`)
-                        : chalk.yellow(`⚠  PR #${prNumber}: cannot scope [crosscheck] commit count (origin/${pr.base.ref} missing) — stopping conflict-resolve`));
+                    log(chalk.yellow(`⚠  PR #${prNumber}: ${MAX_CROSSCHECK_COMMITS} [crosscheck] commits already — stopping conflict-resolve`));
                     skipConflictResolve('commit_limit_reached');
                     continue;
                 }
@@ -1366,11 +967,9 @@ export async function runWorkflow(ctx) {
                 let appliedCount = 0;
                 let resolvedPaths = [];
                 let resolveTokensUsed;
-                let resolveEffort;
-                const skillSession = skillSessionFor(step.name, effectiveType);
                 try {
                     ;
-                    ({ appliedCount, resolvedPaths, tokensUsed: resolveTokensUsed, effort: resolveEffort } = await runConflictResolveStep(tmpDir, pr.title, step.instructions ?? '', conflictResolveModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec), skillSession, config.vendors.claude.effort));
+                    ({ appliedCount, resolvedPaths, tokensUsed: resolveTokensUsed } = await runConflictResolveStep(tmpDir, pr.title, step.instructions ?? '', conflictResolveModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.claude.timeout_sec)));
                 }
                 catch (err) {
                     logError({ repo: `${owner}/${repoName}`, pr: prNumber, phase: 'conflict-resolve', attempt: 1 }, err);
@@ -1381,11 +980,6 @@ export async function runWorkflow(ctx) {
                     skipConflictResolve(isSubscriptionLimitError(err) ? 'vendor_limit' : 'resolve_error');
                     continue;
                 }
-                const activatedSkills = skillSession?.activations() ?? [];
-                if (activatedSkills.length > 0)
-                    log(chalk.dim(`  skills: ${formatSkillAttribution(activatedSkills)}`));
-                else if (skillSession)
-                    logSkillsNoneActivated(skillSession, { step_type: 'conflict-resolve', step_name: step.name });
                 if (appliedCount === 0) {
                     try {
                         execSync('git merge --abort', { cwd: tmpDir });
@@ -1488,7 +1082,7 @@ export async function runWorkflow(ctx) {
                     fileLog({ level: 'warn', event: 'remote_lock_refresh_failed', repo: `${owner}/${repoName}`, pr: prNumber, sha: newSha, error: err instanceof Error ? err.message : String(err) });
                 }
                 onPhaseChange('conflicts resolved ✓', { fixCount: appliedCount, phase: 'fixed', fixTokens: resolveTokensUsed });
-                fileLog({ level: 'info', event: 'conflict_resolve_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor, conflicts_resolved: conflictedFiles.length, sha: newSha, tokens_used: resolveTokensUsed, skills_activated: activatedSkills.map(skill => skill.name), duration_ms: Date.now() - conflictResolveStepStart, ...triggerField });
+                fileLog({ level: 'info', event: 'conflict_resolve_complete', repo: `${owner}/${repoName}`, pr: prNumber, vendor, conflicts_resolved: conflictedFiles.length, sha: newSha, tokens_used: resolveTokensUsed, duration_ms: Date.now() - conflictResolveStepStart, ...triggerField });
                 // Post a summary comment so the silent merge-commit push is visible on the
                 // timeline as a comment card. Best-effort — a failure here must not fail the run.
                 // Prefer the resolver's actual rewrite set; fall back to the originally-conflicted
@@ -1499,9 +1093,6 @@ export async function runWorkflow(ctx) {
                         owner, repo: repoName, sha: newSha,
                         conflictCount: conflictedFiles.length,
                         files: resolvedPaths.length > 0 ? resolvedPaths : conflictedFiles,
-                        model: conflictResolveModel,
-                        effort: resolveEffort,
-                        skills: activatedSkills,
                     });
                     await octokit.rest.issues.createComment({ owner, repo: repoName, issue_number: prNumber, body });
                     fileLog({ level: 'info', event: 'conflict_resolved_comment_posted', repo: `${owner}/${repoName}`, pr: prNumber, sha: newSha });
@@ -1538,9 +1129,6 @@ export async function runWorkflow(ctx) {
         throw err;
     }
     finally {
-        for (const session of skillSessions.values())
-            session.close();
-        skillSessions.clear();
         if (pushedShasNeedingRelease.length > 0 || fixPushedShaRequiresRecheck !== null) {
             const lockOctokit = createGithubClient(token);
             const outcome = workflowFailed ? 'failure' : 'success';
@@ -1592,11 +1180,7 @@ export async function runWorkflow(ctx) {
             failedStep,
             round: ctx.round,
             trigger: ctx.trigger,
-            // The tier that actually ran, not the configured one and not the base
-            // class tier — under smart mode all three differ, and telemetry naming the
-            // wrong one is the same class of problem as a comment citing a tier that
-            // never reached the vendor.
-            qualityTier: quality.tier,
+            qualityTier: config.quality.tier,
         }));
     }
 }