Aleksandr Nogikh

pkg/aflow: abstract LLM provider Decouple the aflow package from the google.golang.org/genai library to enable future integration with other LLM providers (e.g., Claude). Introduce a generic backend.Provider interface and corresponding types (Message, Part, GenerateConfig, etc.) in pkg/aflow/backend. Move the existing Gemini-specific logic into pkg/aflow/backend/gemini, which now implements this interface. Update the core aflow execution logic and agents to rely solely on the generic backend types. Finally, update syz-agent and tools/syz-aflow to explicitly initialize the Gemini provider and inject it into the workflow execution.

pkg/aflow: support Suggested-by tags in patch iteration workflow Credit reviewers who provide idea suggestions during automated patch review. Support extracting and preserving Suggested-by tags across patch iterations and include them when rendering patch commit descriptions.

dashboard/app: prevent infinite email loops and spurious errors The dashboard previously assumed that any incoming email containing an unknown Bug ID must be a user attempting to issue a command to an invalid bug. Consequently, it would blindly fire off a generic "I see the command but can't find the corresponding bug" error reply without verifying if the email actually contained any actionable commands, or if the email was authored by syzbot itself. This assumption leads to infinite email loops when combined with mailing lists. If syzbot receives an email quoting a missing or fake bug ID (such as the "HASH" placeholder from its own error templates), the parser extracts the fake ID. The dashboard then fails the database lookup and indiscriminately sends another error reply containing the exact same placeholder, repeating the cycle infinitely. Fix this by introducing a `replyError` helper that ensures generic error replies are never sent if the incoming email does not contain any parsed commands or if the email was authored by syzbot.

all: partially enable gocritic Enable diagnostic and some stylistic checkers. Fix the resulting findings.

dashboard/app: allow disabling AI comment replies per stage Automatic comment replying is still an experimental feature. We want to avoid sending unmoderated text replies to public mailing lists, and for now it is cleaner to only allow conversational replies during the moderation stage. This also simplifies the overall implementation of #7671. Add a ReplyToComments configuration option to AIPatchStageConfig. When disabled for a stage, pass the flag to the patch iteration workflow to skip generating text replies and suppress creating external report entries if no new patch version was produced.

dashboard/app: use helper methods for AI job and report polling Reduce boilerplate in dashboard AI test cases by consolidating agent and report polling into helper methods. Manually constructing poll requests and confirmation payloads across test functions makes the test suite verbose and harder to maintain. Replace repetitive agent and report polling checks with pollAIJob, pollAIWorkflow, pollAndConfirmReport, and assertNoPendingReport.

pkg/execbackend: add a common interface for execution backends Abstract the fuzzer execution logic into a new pkg/execbackend.Server interface to put snapshot and non-snapshot implementations under the same umbrella. This abstracts the underlying execution mechanism, allowing syz-manager, syz-verifier, and patch fuzzing (pkg/manager/diff) to easily reuse snapshot functionality without managing the two-phase boot process and queue resets.

pkg/clangtool: fix C++ static constructor interception race Intercepting tool execution via C++ static constructors causes the clang tools (e.g., codesearch) to run before the Go runtime is fully initialized. This early execution leads to unpredictable initialization races when interacting with complex libraries like LLVM. Fix this by moving execution into an auto-intercepting Go registry. Tools now register themselves via `clangtool.Register` in a CGO `init()` function, which immediately executes the tool via `extern "C"` if requested. This guarantees the Go runtime has booted safely. If a requested tool is not compiled in, `runTool` will now return an error before attempting to spawn the subprocess.

syz-cluster: provide on-demand patch testing Enable patch authors to request syz-cluster fuzzing without sending the patch to the public mailing lists. Guarantee evaluation and reporting for series explicitly sent to our direct mailing list. Introduce a `Direct` flag for such sessions. Use this flag to bypass AI triage, prioritize the session in the queue, and ensure an email report is sent even if no bugs are found.

pkg/aflow: support reviewer tags in patch iterations When reviewers reply to AI-generated patches with tags (e.g., Reviewed-by, Acked-by), these tags are often lost in subsequent patch versions because the LLM handles them inconsistently. Introduce a new tag-extractor LLM agent to explicitly parse supported tags from review comments. These tags are then validated, persisted in the database job arguments, and correctly formatted into the patch trailer during generation. The verdict agent is also explicitly instructed not to generate a new patch version solely for tag updates.

pkg/aflow/flow/patching: add patch refinement loop for formatting Ensure generated kernel patches comply with kernel coding standards and checkpatch.pl before completion or resubmission. Add checkpatch and clang-format tools. Remove mandatory clang-format-diff.py from crash.TestPatch in favor of tool-based formatting. Introduce patchRefinementLoop in formatting.go to run checkpatch.pl after patch generation and delegate style fixes to a patch-formatter agent. Update verdictAgent to separate StyleItems from CodeItems. Export sandboxed patchdiff.Diff.

pkg/execbackend: add RunLocal testing helper and rpc test Introduce execbackend.RunLocal along with a local VM implementation to allow running tests natively using the execbackend abstraction. This simplifies the setup by handling VM creation and server setup under the hood. Update TestFuzz in pkg/fuzzer/fuzzer_test.go to use execbackend.RunLocal instead of rpcserver.RunLocal, making the test much simpler and validating the new execbackend abstraction. Add TestRPCBackendLocal in pkg/execbackend/rpc_test.go to directly test the execbackend execution loop and connection handshake with the executor.

all: introduce #syz unreject command Allow users to undo a patch rejection by sending a `#syz unreject` command. This clears the rejected state, allowing the patch to be upstreamed subsequently. Add parsing in pkg/email and relay logic in pkg/lore-relay.

dashboard/app: set Signed-off-by for AI patches Track the name and email of the user who invokes the `#syz upstream` command on an AI-generated patch. Save this information in the new `UpstreamedBy` column of the `JobReporting` table. Pass this information to `lore-relay` so that it can be formatted into a standard `Signed-off-by:` tag in the generated patch email. When a patch is iterated on (e.g. producing a v2 patch), ensure the `UpstreamedBy` field is inherited from the parent reporting so the tag is preserved across iterations.

dashboard/app: prohibit rejecting an already rejected patch If a patch is already rejected, reacting to another #syz reject command is redundant and can cause unnecessary emails. Prohibit this state transition inside RejectReportCommand and record the failure in the journal to prevent further processing.

dashboard/app: journal failed commands When lore-relay encounters a logical command failure (e.g. attempting to upstream an iteration without a patch), it replies to the user. Because these failures were never recorded in the dashboard's Journal, lore-relay would re-process them upon restart, resulting in an endless loop of duplicate error emails. Fix this by recording logical command rejections in the Journal. Add a new Error column to the Journal table and UI to surface the failure reasons. This ensures `aidb.IsCommandProcessed` correctly identifies failed commands as processed, breaking the retry loop.

pkg/vcs: dynamically bound commit search by date Update GetCommitByTitle to accept a `since` parameter to dynamically bound the git log search. Currently, git log searches are hardcoded to a 5-year limit for performance, which causes the system to miss older fix backports and erroneously attempt to cherry-pick them again. This breaks bisections with errors such as: failed building 49e02880ec0a8c378e811bc9d85da188d7c6204c: failed to run ["git" "-c" "core.hooksPath=/dev/null" "cherry-pick" "--no-commit" "1d489151e9f9d1647110277ff77282fe4d96d09b"]: exit status 1. Fix this by passing a custom cut-off date when searching for Linux backports, set to 1 year before the original upstream commit date. All other callers continue to use the 5-year default.

syz-cluster: evaluate with AI during triage Integrate the aflow patch triage workflow into the triage phase. This avoids expensive kernel builds and fuzzing activity for non-functional or purely decorative patches. Store the resulting LLM reasoning and trajectory HTML.

pkg/aflow: support dynamic target architectures The aflow framework previously hardcoded targets to linux/amd64. Make it configurable.

dashboard/app: allow manual triggering of AI patch iterations Add a "Process Comments" button to the bug page to allow authorized users to manually trigger iterations for pending comments. This is needed for stages where AddressComments is false, as incoming comments are stored but do not automatically trigger a new patch iteration.