@humanbased/crosscheck 1.2.0-beta.80 → 1.2.0

package/dist/lib/runner.js

@@ -9,22 +9,15 @@ 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 { 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;
@@ -56,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;
@@ -357,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;
@@ -428,16 +386,6 @@ export async function runWorkflow(ctx) {
     let currentStepName;
     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 });
-        }
         for (const step of steps) {
             currentStepName = step.name;
             stepsRun.push(step.name);
@@ -500,19 +448,17 @@ export async function runWorkflow(ctx) {
                 let inputTokens;
                 let outputTokens;
                 let model = 'default';
-                let effort;
                 let retried;
-                const skillSession = skillSessionFor(step.name, effectiveType);
                 const runReviewWithVendor = async (candidate) => {
                     if (candidate === 'codex') {
                         ;
-                        ({ review: rawReview, tokensUsed, model, effort, 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, 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, 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, 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 {
@@ -569,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) {
@@ -595,13 +536,11 @@ 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: config.quality.tier }
@@ -640,41 +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);
+                    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 };
                 }
             }
@@ -740,16 +647,11 @@ export async function runWorkflow(ctx) {
                 // 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' });
@@ -757,20 +659,18 @@ export async function runWorkflow(ctx) {
                 let appliedCount = 0;
                 let fixChangedFiles = [];
                 let fixTokensUsed;
-                let fixEffort;
                 let fixErr = undefined;
                 let activeVendor = vendor;
                 const tierMs = tierTimeoutMs(config.quality.tier);
-                const skillSession = skillSessionFor(step.name, effectiveType);
                 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, config.vendors.codex.effort);
+                        return runCodexFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', codexFixModel, ctx.overrideTimeoutMs ?? vendorTimeoutMs(config.vendors.codex.timeout_sec) ?? tierMs);
                     }
-                    return runFixStep(tmpDir, pr.base.ref, pr.title, reviewCommentBody, step.instructions ?? '', config, 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);
@@ -784,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) {
@@ -805,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;
                     }
@@ -814,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
@@ -836,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 });
                         }
@@ -861,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;
                 }
@@ -913,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 {
@@ -924,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 });
@@ -963,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 {
@@ -980,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 {
@@ -992,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 };
                 }
             }
@@ -1080,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;
                 }
@@ -1098,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);
@@ -1113,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 });
@@ -1220,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
@@ -1231,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 });
@@ -1270,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';