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.

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.

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: implement token-based context compression Introduce CompressTokens to dynamically truncate agent context histories based on token count rather than message count. Unlike the existing SummaryWindow (which relies on a fixed number of messages), CompressTokens handles the massive variance in message sizes (e.g., small tool replies vs. massive source code searches) predictably. When the threshold is exceeded, the agent uses a cheaper model (GoodBalancedModel) to summarize the history, truncating it down to just the anchor prompt and the new summary. Also add a `patching-compressed` workflow registration (with a 250k token threshold) to allow experimenting with this mechanism.

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/aflow: integrate Fixes tag processing into patch iteration Currently, the patching workflow discovers and emits a Fixes tag, but the patch-iteration workflow loses it. This commit integrates Fixes tag tracking and conditional updating into patch-iteration. The verdict agent now evaluates whether reviewers requested a new Fixes tag. If requested, the fixes-finder agent is invoked to deduce the new guilty commit. Otherwise, the original Fixes tag is propagated to the output.

dashboard/app: manually submit AI jobs Add a form to submit AI jobs that are not tied to specific bugs. Keep the configuration flexible as we may want to add more such jobs later.

dashboard/app: allow manual push of AI jobs to reporting There are edge cases where an AI job correctly completes, but the namespace's AI configuration did not have a reporting stage set up at the exact time of completion. Because jobs only create their first reporting stage during the `apiAIJobDone` hook, such a job gets stuck and will never be reported. To address this, this commit adds a manual 'Push to [Stage]' button to the AI job details page. The button is strictly visible to authorized users and only displays if the job has successfully finished, but has no existing reporting stages. When triggered, it uses the standard `UpstreamReportCommand` logic to safely create the reporting stage. It also cleans up `handleAIJobPagePost` by enforcing that mutations are only accepted via POST.

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.