@doist/doistbot-cli 1.0.7 → 1.0.9

package/sandbox/dist/tasks/review-slice-plan/review-slice-plan.js

@@ -0,0 +1,470 @@
+import { spawnSync } from 'child_process';
+import { SpanStatusCode } from '@opentelemetry/api';
+import { buildReviewHygieneSlicePlanComment, encodeReviewSlicePlanBaseBranch, findReviewSlicePlanSlot, normalizeReviewSlicePlanMarkerValue, replaceReviewSlicePlanSlot, REVIEW_HYGIENE_COMMENT_MARKER, ReviewSlicePlanState, } from 'doistbot-async-routing-contracts';
+import { isKnownDoistbotLogin } from '../../core/bot-logins.js';
+import { recordTaskMetrics } from '../../core/datadog-metrics.js';
+import { logger } from '../../core/logging.js';
+import { DEFAULT_GEMINI_FLASH_MODEL, invokePiPrompt } from '../../core/pi.js';
+import { cloneRepository, createGitHubClients, WORKSPACE_DIR } from '../../core/shared.js';
+import { genAiProviderName, recordEvent, startToolSpan, withPhase } from '../../core/tracing.js';
+import { parseReviewSlicePlanContext } from './context.js';
+import { parseReviewSlicePlanOutput, renderReviewSlicePlan } from './plan.js';
+import { buildReviewSlicePlanPrompt, REVIEW_SLICE_PLAN_SYSTEM_PROMPT } from './prompt.js';
+const REVIEW_SLICE_PLAN_TIMEOUT_MS = 7 * 60 * 1_000;
+const REVIEW_SLICE_PLAN_RETRY_DELAY_MS = 1_000;
+const MAX_COMMENT_BODY_CHARS = 50_000;
+class StaleReviewSlicePlanError extends Error {
+}
+export async function main() {
+    const startedAt = performance.now();
+    const ctx = parseReviewSlicePlanContext();
+    const repository = `${ctx.owner}/${ctx.repo}`;
+    logger.setBaseContext({
+        deliveryId: ctx.deliveryId ?? 'unknown',
+        repository,
+        prNumber: ctx.prNumber,
+    });
+    logger.info('Review slice plan task started', {
+        dryRun: ctx.dryRun,
+        model: DEFAULT_GEMINI_FLASH_MODEL,
+        headSha: ctx.headSha,
+        commentId: ctx.commentId,
+    });
+    let exitCode = 0;
+    let completedSuccessfully = false;
+    let githubClients;
+    await withPhase('review-slice-plan', {
+        task: 'review-slice-plan',
+        'gen_ai.operation.name': 'invoke_agent',
+        'gen_ai.agent.name': 'doistbot.review-slice-plan',
+        'pr.number': ctx.prNumber,
+        dry_run: ctx.dryRun,
+    }, async (span) => {
+        try {
+            const { app, readOctokit, writeOctokit } = await createGitHubClients(ctx);
+            githubClients = { readOctokit, writeOctokit };
+            if (!ctx.dryRun &&
+                !(await ownsPendingSlicePlanSlot({ ctx, octokit: readOctokit }))) {
+                logger.info('Review slice plan task no longer owns the pending comment slot');
+                completedSuccessfully = true;
+                return;
+            }
+            const source = await loadReviewSlicePlanSource({ ctx, octokit: readOctokit });
+            assertExpectedRevision(ctx, source);
+            await cloneRepository({
+                app,
+                owner: ctx.owner,
+                repo: ctx.repo,
+                prNumber: ctx.prNumber,
+                installationId: ctx.installationId,
+            });
+            assertWorkspaceHead(ctx.headSha);
+            const prompt = buildReviewSlicePlanPrompt({
+                repository,
+                prNumber: ctx.prNumber,
+                title: source.title,
+                body: source.body,
+                author: source.author,
+                baseBranch: source.baseBranch,
+                headSha: source.headSha,
+                reviewHygiene: ctx.reviewHygiene,
+                files: source.files,
+                commits: source.commits,
+            });
+            source.files = withoutPatches(source.files);
+            const modelOutput = await invokeSlicePlanner({ ctx, prompt });
+            let plan;
+            try {
+                plan = parseReviewSlicePlanOutput(modelOutput, source.files);
+            }
+            catch (error) {
+                logger.warn('Gemini slice planner output failed validation; retrying once', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                const repairedOutput = await invokeSlicePlanner({
+                    ctx,
+                    prompt: `${prompt}\n\nYour previous response failed schema or changed-file coverage validation. Re-evaluate the evidence and return one corrected JSON object only.`,
+                    maxAttempts: 1,
+                });
+                plan = parseReviewSlicePlanOutput(repairedOutput, source.files);
+            }
+            const slicePlanContent = renderPlanWithinCommentLimit(plan, ctx.baseBranch);
+            if (ctx.dryRun) {
+                printDryRunResult({ ctx, source, plan, slicePlanContent });
+            }
+            else {
+                const latestPr = await readOctokit.rest.pulls.get({
+                    owner: ctx.owner,
+                    repo: ctx.repo,
+                    pull_number: ctx.prNumber,
+                });
+                assertExpectedRevision(ctx, {
+                    ...source,
+                    baseBranch: latestPr.data.base.ref,
+                    headSha: latestPr.data.head.sha,
+                });
+                const updated = await updateOwnedSlicePlanSlot({
+                    ctx,
+                    readOctokit,
+                    writeOctokit,
+                    state: ReviewSlicePlanState.Complete,
+                    content: slicePlanContent,
+                });
+                if (!updated) {
+                    logger.info('Review slice plan result discarded because the comment slot changed');
+                }
+                else {
+                    logger.info('Review hygiene comment updated with contextual slice plan', {
+                        commentId: ctx.commentId,
+                        slices: plan.slices.length,
+                        strategy: plan.strategy,
+                    });
+                }
+            }
+            completedSuccessfully = true;
+        }
+        catch (error) {
+            exitCode = 1;
+            const message = error instanceof Error ? error.message : String(error);
+            span.setStatus({ code: SpanStatusCode.ERROR, message });
+            logger.error('Review slice plan task failed', { error: message });
+            if (!ctx.dryRun && githubClients) {
+                try {
+                    await updateOwnedSlicePlanSlot({
+                        ctx,
+                        ...githubClients,
+                        state: ReviewSlicePlanState.Failed,
+                        content: buildFailureMessage(error),
+                    });
+                }
+                catch (updateError) {
+                    logger.warn('Failed to replace the pending slice plan after an error', {
+                        error: updateError instanceof Error
+                            ? updateError.message
+                            : String(updateError),
+                    });
+                }
+            }
+        }
+    });
+    await recordTaskMetrics({
+        type: 'slice-plan',
+        repository,
+        model: 'gemini',
+        outcome: completedSuccessfully ? 'success' : 'failure',
+        durationMs: performance.now() - startedAt,
+        ...(completedSuccessfully ? {} : { reason: 'exception' }),
+    });
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
+async function loadReviewSlicePlanSource({ ctx, octokit, }) {
+    const [pullRequest, files, commits] = await Promise.all([
+        octokit.rest.pulls.get({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: ctx.prNumber,
+        }),
+        octokit.paginate(octokit.rest.pulls.listFiles, {
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: ctx.prNumber,
+            per_page: 100,
+        }),
+        octokit.paginate(octokit.rest.pulls.listCommits, {
+            owner: ctx.owner,
+            repo: ctx.repo,
+            pull_number: ctx.prNumber,
+            per_page: 100,
+        }),
+    ]);
+    if (files.length < pullRequest.data.changed_files) {
+        throw new Error(`GitHub returned only ${files.length} of ${pullRequest.data.changed_files} changed files; refusing to generate an incomplete plan`);
+    }
+    return {
+        title: pullRequest.data.title,
+        body: pullRequest.data.body,
+        author: pullRequest.data.user?.login ?? 'unknown',
+        baseBranch: pullRequest.data.base.ref,
+        headSha: pullRequest.data.head.sha,
+        files: files.map((file) => ({
+            filename: file.filename,
+            status: file.status,
+            additions: file.additions,
+            deletions: file.deletions,
+            ...(file.previous_filename ? { previousFilename: file.previous_filename } : {}),
+            ...(file.patch ? { patch: file.patch } : {}),
+        })),
+        commits: commits.map((commit) => ({
+            sha: commit.sha,
+            message: commit.commit.message,
+        })),
+    };
+}
+function assertExpectedRevision(ctx, source) {
+    if (source.headSha !== ctx.headSha || source.baseBranch !== ctx.baseBranch) {
+        throw new StaleReviewSlicePlanError(`PR revision changed while planning (expected ${ctx.baseBranch}@${ctx.headSha}, got ${source.baseBranch}@${source.headSha})`);
+    }
+}
+function assertWorkspaceHead(expectedHeadSha) {
+    const result = spawnSync('git', ['-C', WORKSPACE_DIR, 'rev-parse', 'HEAD'], {
+        encoding: 'utf8',
+        stdio: 'pipe',
+    });
+    const actualHeadSha = typeof result.stdout === 'string' ? result.stdout.trim() : '';
+    if (result.error || result.status !== 0 || actualHeadSha !== expectedHeadSha) {
+        throw new StaleReviewSlicePlanError(`Cloned PR head did not match the requested revision (${actualHeadSha || 'unknown'})`);
+    }
+}
+async function invokeSlicePlanner({ ctx, prompt, maxAttempts = 2, }) {
+    return await withPhase('review-slice-plan.model', {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': genAiProviderName('gemini'),
+        'gen_ai.request.model': DEFAULT_GEMINI_FLASH_MODEL,
+    }, async () => {
+        let lastError = 'Gemini did not return a response';
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            const progress = createSlicePlannerProgressHandler();
+            const result = await invokePiPrompt({
+                provider: 'gemini',
+                apiKey: ctx.geminiApiKey,
+                modelName: DEFAULT_GEMINI_FLASH_MODEL,
+                prompt,
+                cwd: WORKSPACE_DIR,
+                timeoutMs: REVIEW_SLICE_PLAN_TIMEOUT_MS,
+                capabilityPreset: 'read-only',
+                thinkingLevel: 'high',
+                systemPrompt: REVIEW_SLICE_PLAN_SYSTEM_PROMPT,
+                noContextFiles: true,
+                onProgress: progress.onProgress,
+            }).finally(progress.close);
+            if (result.ok) {
+                logger.info('Gemini slice planner completed', {
+                    attempt,
+                    durationMs: result.durationMs,
+                    outputChars: result.output.length,
+                    stopReason: result.stopReason,
+                    toolUsage: result.toolUsage,
+                });
+                return result.output;
+            }
+            lastError = result.error;
+            logger.warn('Gemini slice planner request failed', {
+                attempt,
+                durationMs: result.durationMs,
+                timedOut: result.timedOut,
+                stopReason: result.stopReason,
+                error: result.error,
+            });
+            if (attempt < maxAttempts) {
+                const delayMs = REVIEW_SLICE_PLAN_RETRY_DELAY_MS * attempt;
+                recordEvent('review-slice-plan.model.retry', { attempt, delay_ms: delayMs });
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+        throw new Error(`Gemini slice planner failed after ${maxAttempts} attempt(s): ${lastError}`);
+    });
+}
+function createSlicePlannerProgressHandler() {
+    const inFlightTools = new Map();
+    function toolKey(event) {
+        return event.toolCallId ?? event.toolName ?? '';
+    }
+    function onProgress(event) {
+        switch (event.type) {
+            case 'tool_start': {
+                const key = toolKey(event);
+                const displaced = inFlightTools.get(key);
+                if (displaced) {
+                    displaced.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: 'replaced by overlapping tool progress',
+                    });
+                    displaced.end();
+                }
+                const toolSpan = startToolSpan(event.toolName, {
+                    'gen_ai.operation.name': 'execute_tool',
+                    'gen_ai.tool.name': event.toolName,
+                    ...(event.toolCallId ? { 'gen_ai.tool.call.id': event.toolCallId } : {}),
+                });
+                inFlightTools.set(key, toolSpan);
+                return;
+            }
+            case 'tool_end': {
+                const key = toolKey(event);
+                const toolSpan = inFlightTools.get(key);
+                if (toolSpan) {
+                    if (event.isError) {
+                        toolSpan.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: 'tool reported error',
+                        });
+                    }
+                    toolSpan.end();
+                    inFlightTools.delete(key);
+                }
+                return;
+            }
+            case 'thinking':
+            case 'responding':
+                recordEvent('model.heartbeat', { state: event.type });
+        }
+    }
+    function close() {
+        for (const toolSpan of inFlightTools.values()) {
+            toolSpan.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: 'tool span did not receive matching end',
+            });
+            toolSpan.end();
+        }
+        inFlightTools.clear();
+    }
+    return { onProgress, close };
+}
+function withoutPatches(files) {
+    return files.map((file) => ({
+        filename: file.filename,
+        status: file.status,
+        additions: file.additions,
+        deletions: file.deletions,
+        ...(file.previousFilename ? { previousFilename: file.previousFilename } : {}),
+    }));
+}
+function renderPlanWithinCommentLimit(plan, baseBranch) {
+    const full = renderReviewSlicePlan(plan, { baseBranch });
+    if (full.length <= MAX_COMMENT_BODY_CHARS) {
+        return full;
+    }
+    const compact = renderReviewSlicePlan(plan, { baseBranch, compact: true });
+    if (compact.length > MAX_COMMENT_BODY_CHARS) {
+        throw new Error('Validated slice plan is too large to fit in a GitHub comment');
+    }
+    return compact;
+}
+async function ownsPendingSlicePlanSlot({ ctx, octokit, }) {
+    return (await fetchOwnedPendingSlot({ ctx, octokit })) !== undefined;
+}
+async function fetchOwnedPendingSlot({ ctx, octokit, }) {
+    const commentId = requireCommentId(ctx);
+    const response = await octokit.rest.issues.getComment({
+        owner: ctx.owner,
+        repo: ctx.repo,
+        comment_id: commentId,
+    });
+    const body = response.data.body;
+    const slot = findReviewSlicePlanSlot(body);
+    if (!isKnownDoistbotLogin(response.data.user?.login) ||
+        !body?.includes(REVIEW_HYGIENE_COMMENT_MARKER) ||
+        slot?.state !== ReviewSlicePlanState.Pending ||
+        slot.headSha !== normalizeReviewSlicePlanMarkerValue(ctx.headSha) ||
+        slot.baseBranch !== encodeReviewSlicePlanBaseBranch(ctx.baseBranch) ||
+        slot.runId !== normalizeReviewSlicePlanMarkerValue(ctx.runId)) {
+        return undefined;
+    }
+    return { body };
+}
+export async function updateOwnedSlicePlanSlot({ ctx, readOctokit, writeOctokit, state, content, }) {
+    const commentId = requireCommentId(ctx);
+    const initial = await fetchOwnedPendingSlot({ ctx, octokit: readOctokit });
+    if (!initial) {
+        return false;
+    }
+    const latest = await fetchOwnedPendingSlot({ ctx, octokit: readOctokit });
+    if (latest?.body !== initial.body) {
+        return false;
+    }
+    const updatedBody = replaceReviewSlicePlanSlot(latest.body, {
+        state: ReviewSlicePlanState.Pending,
+        headSha: ctx.headSha,
+        baseBranch: ctx.baseBranch,
+        runId: ctx.runId,
+    }, { state, headSha: ctx.headSha, baseBranch: ctx.baseBranch, runId: ctx.runId }, content);
+    if (!updatedBody) {
+        return false;
+    }
+    await updateIssueCommentWithFallback({
+        ctx,
+        commentId,
+        body: updatedBody,
+        readOctokit,
+        writeOctokit,
+    });
+    return true;
+}
+async function updateIssueCommentWithFallback({ ctx, commentId, body, readOctokit, writeOctokit, }) {
+    function update(octokit) {
+        return octokit.rest.issues.updateComment({
+            owner: ctx.owner,
+            repo: ctx.repo,
+            comment_id: commentId,
+            body,
+        });
+    }
+    try {
+        await update(writeOctokit);
+    }
+    catch (error) {
+        const status = error?.status;
+        if (writeOctokit !== readOctokit && (status === 401 || status === 403)) {
+            logger.warn('GitHub token could not update slice plan comment; retrying as app');
+            await update(readOctokit);
+            return;
+        }
+        throw error;
+    }
+}
+function printDryRunResult({ ctx, source, plan, slicePlanContent, }) {
+    const pendingComment = buildReviewHygieneSlicePlanComment(ctx.reviewHygiene, {
+        baseBranch: ctx.baseBranch,
+        headSha: ctx.headSha,
+        runId: ctx.runId,
+        prAuthorLogin: source.author,
+    }).body;
+    const finalComment = replaceReviewSlicePlanSlot(pendingComment, {
+        state: ReviewSlicePlanState.Pending,
+        headSha: ctx.headSha,
+        baseBranch: ctx.baseBranch,
+        runId: ctx.runId,
+    }, {
+        state: ReviewSlicePlanState.Complete,
+        headSha: ctx.headSha,
+        baseBranch: ctx.baseBranch,
+        runId: ctx.runId,
+    }, slicePlanContent);
+    if (!finalComment) {
+        throw new Error('Failed to render the final dry-run hygiene comment');
+    }
+    process.stdout.write([
+        '--- Initial hygiene comment ---',
+        pendingComment,
+        '--- Final hygiene comment ---',
+        finalComment,
+        '--- Structured slice plan ---',
+        JSON.stringify({
+            dryRun: true,
+            repository: `${ctx.owner}/${ctx.repo}`,
+            prNumber: ctx.prNumber,
+            model: DEFAULT_GEMINI_FLASH_MODEL,
+            decision: ctx.reviewHygiene,
+            plan,
+        }, null, 2),
+        '',
+    ].join('\n'));
+}
+function buildFailureMessage(error) {
+    if (error instanceof StaleReviewSlicePlanError) {
+        return 'The PR changed while I was preparing this plan, so I discarded the stale result. Run `@doistbot /review` again on the latest revision to regenerate it.';
+    }
+    return "I couldn't generate a reliable contextual slicing plan for this revision. Please use the generic stacking instructions below or retry the review.";
+}
+function requireCommentId(ctx) {
+    if (ctx.commentId === undefined) {
+        throw new Error('COMMENT_ID is required outside dry-run mode');
+    }
+    return ctx.commentId;
+}
+if (process.env.VITEST !== 'true') {
+    await main();
+}

package/sandbox/src/tasks/review/prompts/review-focus-prompts/efficiency.md

@@ -1,18 +1,16 @@
 ## Review Focus: Efficiency
 
-For this pass, focus only on unnecessary work, hot-path regressions, and avoidable performance or resource overhead introduced by the diff.
+For this pass, focus only on efficiency issues introduced by the diff.
 
-Flag findings for issues such as:
+Review the changes for potential efficiency issues, such as:
 
-- Unnecessary work: redundant computations, repeated reads, or redundant calls, N+1 patterns.
-- Missed concurrency: independent work is done sequentially when batching or concurrency is clearly available
-- Hot-path bloat: new blocking work added to startup or per-request/per-render hot paths.
-- Unnecessary existence checks: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the error.
-- Memory: unbounded data structures, missing cleanup, event listener leaks.
-- Overly broad operations: reading entire files when only a portion is needed, loading all items when filtering for one.
-- Accidental indirection: wrapper chains, adapters, or registries that add repeated runtime work without hiding real complexity. Prefer deletion or consolidation when the local code shows the extra work.
-- Backpressure: treat backpressure handling as critical to system stability; flag unbounded queues, missing flow control, or producer-consumer imbalances.
-
-Prefer concrete, evidenced concerns over speculative micro-optimizations. Do not report theoretical overhead unless the changed path is plausibly repeated, user-facing, queue-backed, or otherwise non-trivial at the PR's expected scale. Avoid theoretical speedups for tiny or one-time work.
+1. Unnecessary work: redundant computations, repeated file reads, duplicate network/API calls, N+1 patterns.
+2. Missed concurrency: independent operations run sequentially when they could run in parallel.
+3. Hot-path bloat: new blocking work added to startup or per-request/per-render hot paths.
+4. Unnecessary existence checks: pre-checking file/resource existence before operating (TOCTOU anti-pattern) — operate directly and handle the error.
+5. Memory: unbounded data structures, missing cleanup, event listener leaks.
+6. Overly broad operations: reading entire files when only a portion is needed, loading all items when filtering for one.
+7. Accidental indirection: wrapper chains, adapters, or registries that add repeated runtime work without hiding real complexity. Prefer deletion or consolidation when the local code shows the extra work.
+8. Backpressure: treat backpressure handling as critical to system stability; flag unbounded queues, missing flow control, or producer-consumer imbalances.
 
 If the diff does not introduce any findings for this focus, return an empty comments array.

package/sandbox/src/tasks/review/prompts/review-focus-prompts/general.md

@@ -1,15 +1,32 @@
 ## Review Focus: General
 
-For this pass, focus only on broad correctness, behavior, and maintainability issues introduced by the diff.
+For this pass, focus only on general issues introduced by the diff.
 
-Flag findings when:
+You are acting as a code reviewer for a proposed code change made by another engineer.
 
-- the change can cause incorrect behavior, crashes, or broken contracts
-- a new edge case or error path is left unhandled
-- the diff introduces a maintainability problem that is directly tied to correctness
+Below are default guidelines for determining what to flag. These are not the final word — if you encounter more specific guidelines elsewhere (in a developer message, user message, file, or project review guidelines appended below), those override these general instructions.
 
-Only report a finding when you can point to the concrete scenario, input, caller, or contract affected by the changed code. If the concern is a possible risk without evidence in the diff or nearby code, omit it.
+## Determining what to flag
 
-Do not spend time on reuse, efficiency, or test-quality concerns unless they are central to a real correctness issue.
+Flag issues that:
+
+1. Meaningfully impact the accuracy, performance, security, or maintainability of the code.
+2. Are discrete and actionable (not general issues or multiple combined issues).
+3. Don't demand rigor inconsistent with the rest of the codebase.
+4. Were introduced in the changes being reviewed and related to the original intent, not adjacent cleanup or opportunistic refactoring.
+5. The author would likely fix if aware of them.
+6. Have provable impact. It is not enough to speculate that a change may disrupt another part, you must identify the parts that are provably affected.
+7. Are clearly not intentional changes by the author.
+8. Call out newly added dependencies explicitly and explain why they're needed.
+9. Apply system-level thinking; flag changes that increase operational risk or on-call burden.
+
+If an issue introduced by the reviewed changes is valid and worth tracking but outside the PR's original intent or merely adjacent, report it only as P3 and clearly frame it as follow-up work. Do not report pre-existing issues unless the changed code makes them newly incorrect. Omit unrelated issues that are speculative, vague, or not worth tracking.
+
+## Finding field guidelines
+
+1. Explain why the issue matters and the concrete scenario/environment where it fails.
+2. Keep each finding brief, matter-of-fact, and easy to understand.
+3. Keep suggestions specific and actionable.
+4. Avoid flattery or filler phrases like "Great job...".
 
 If the diff does not introduce any findings for this focus, return an empty comments array.

package/sandbox/src/tasks/review/prompts/review-focus-prompts/quality.md

@@ -1,28 +1,20 @@
 ## Review Focus: Quality
 
-For this pass, focus only on design quality, architecture, type safety, missed reuse, duplicated logic, and consistency with established patterns.
+For this pass, focus only on quality issues introduced by the diff.
 
-Flag findings when:
+Review the changes for potential quality issues, such as:
 
-- logic lives in the wrong layer or breaks an existing abstraction boundary
-- the diff introduces redundant state, brittle APIs, or stringly-typed code
-- the change deviates from surrounding patterns or documented guidance in a way that creates ongoing maintenance cost
-- a concrete type-safety or design issue should be fixed even if the code “works”
-- the diff reinvents a helper, utility, abstraction, or repeated block that already exists nearby
-- state duplicates existing state, cached values could be derived, or observers/effects could be direct calls
-- the diff adds new parameters to a function instead of generalizing or restructuring existing ones
-- near-duplicate code blocks are copied with slight variation and should be unified with a shared abstraction
-- internal details are exposed that should be encapsulated, or existing abstraction boundaries are broken
-- raw strings are used where constants, enums (string unions), or branded types already exist in the codebase
-- the diff adds wrappers or abstractions without clear reuse value instead of using a simple, direct solution
-- ternary chains, deeply nested if/else blocks, or nested switches obscure distinct cases, duplicate branches, or make error/edge paths easy to miss
-- broad try/catch blocks, fallback/null guard/logging paths, or safe wrappers are added without a real trust boundary or documented failure mode
-- logging-and-continue patterns hide errors where explicit failures or predictable failure modes would be better
-- errors are checked against message strings instead of codes or stable identifiers
-- broad any/type-ignore casts, sleeps/timeouts, fake success returns, removed checks, or path mutation hide a real failure
-
-Only report a design-quality finding when the maintenance cost is concrete: name the abstraction boundary, existing pattern, type contract, caller impact, helper, module, or repeated changed block that makes the change costly. Do not turn a naming, formatting, or preference nit into a [P1] or [P2].
-
-Do not repeat generic correctness bugs already covered by the general pass unless the design concern is distinct.
+1. Redundant state: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls.
+2. Parameter sprawl: adding new parameters to a function instead of generalizing or restructuring existing ones.
+3. Copy-paste with slight variation: near-duplicate code blocks that should be unified with a shared abstraction.
+4. Layering and leaky abstractions: logic that lives in the wrong layer, exposes internal details that should be encapsulated, or breaks existing abstraction boundaries.
+5. Stringly-typed code: using raw strings where constants, enums (string unions), or branded types already exist in the codebase.
+6. Simplicity/YAGNI: prefer simple, direct solutions over wrappers, abstractions, configuration, options, extensibility, or scaffolding without clear reuse value or explicit need. Prefer deletion or direct code until the second use appears.
+7. Shrinkage: flag code that preserves behavior with fewer branches, lines, moving parts, or custom helpers. Do not shrink away input validation at trust boundaries, data-loss error handling, security measures, or accessibility basics.
+8. Nested conditionals: ternary chains, deeply nested if/else blocks, or nested switches should be simplified when they obscure distinct cases, duplicate branches, or make error/edge paths easy to miss.
+9. Over-defensive code: broad try/catch blocks, fallback/null guard/logging paths, or safe wrappers that are not tied to a real trust boundary or documented failure mode.
+10. Fail-fast: favor explicit failures over logging-and-continue patterns that hide errors. Prefer predictable failure modes over silent degradation.
+11. Error classification: ensure errors are checked against codes or stable identifiers, never error message strings.
+12. Band-aid code: broad any/type-ignore casts, sleeps/timeouts, fake success returns, removed checks, or path mutation that hides a real failure.
 
 If the diff does not introduce any findings for this focus, return an empty comments array.

package/sandbox/src/tasks/review/prompts/review-focus-prompts/reuse.md

@@ -0,0 +1,13 @@
+## Review Focus: Reuse
+
+For this pass, focus only on reuse issues introduced by the diff.
+
+Review the changes for potential reuse issues, such as:
+
+1. Search for existing capabilities that could replace newly written code: standard library APIs, native platform features, already-installed dependencies, and existing utilities/helpers. Search for relevant names and behavior, then go beyond string matches by inspecting adjacent files, utility files and directories, and shared modules.
+2. Flag any new function that duplicates existing functionality. Suggest the existing function, API, or feature to use instead.
+3. Flag any inline logic that could use an existing capability — hand-rolled standard-library behavior, string manipulation, manual path handling, custom environment checks, ad-hoc type guards, native platform features, and similar patterns are common candidates.
+4. Flag new dependencies when the standard library, runtime/platform, or an already-installed dependency provides the same capability or behavior.
+5. Flag duplicate modules, thin pass-through wrappers, and manual registries when they duplicate an existing source of truth or local pattern. Prefer deleting, consolidating, or reusing the existing path.
+
+If the diff does not introduce any findings for this focus, return an empty comments array.

package/sandbox/src/tasks/review/prompts/review-focus-prompts/security.md

@@ -0,0 +1,18 @@
+## Review Focus: Security
+
+For this pass, focus only on security issues introduced by the diff.
+
+Review the changes for potential security issues, such as:
+
+1. Auth and permissions: changed routes, commands, jobs, or data access must preserve required authentication, authorization, tenant isolation, and ownership checks.
+2. Untrusted input: SQL or command construction must be parameterized; path, URL, shell, and HTML output must be escaped or encoded for the target context.
+3. Filesystem and process boundaries: user-controlled paths and process arguments must not allow traversal, arbitrary file access, command injection, or unsafe environment changes.
+4. Server-side fetches: server requests to user-controlled URLs must block localhost, private/link-local IP ranges, cloud metadata endpoints, and internal hostnames, including after DNS resolution and redirects.
+5. Redirects and navigation: user-controlled destinations must be same-origin relative paths or explicitly allowlisted origins.
+6. Secrets: new logging, errors, telemetry, files, or API responses must not expose tokens, keys, credentials, cookies, or sensitive identifiers.
+7. Serialization and parsing: avoid unsafe deserialization, dynamic code execution, prototype pollution, XML external entities, YAML custom object construction, and parser modes that load external resources.
+8. Dependencies: newly added dependencies that touch input parsing, networking, auth, crypto, secrets, or code execution need an explicit security reason.
+
+Only flag issues with a concrete exploit path or trust-boundary failure introduced by the reviewed changes.
+
+If the diff does not introduce any findings for this focus, return an empty comments array.