x64 debugger tasks, from crash log to tested fix

What StatusRivet does

• Filesread_file, write_file, append_file, edit_file, delete_file, make_dir, move_file, copy_file, list_dir, grep and glob work inside the chat's working folder, and a counter shows the files created, edited and read.
• Shellruns builds, linters, tests and your debugger's command-line mode on Windows, in WSL or over SSH to a server you own; success is judged by the real exit code, and dangerous commands are blocked.
• Webweb_search finds pages and http_get reads one official documentation page, for example to look up what an exception code means before you act on it.
• Screenshots and imagesocr reads text from a saved screenshot, such as an error dialog, and gen_image saves real image files.
• Orchestrationtask runs parallel sub-agents, run_on_model sends a hard step to a bigger model, and skill holds reusable playbooks, including version control.
• Approval modesAuto-run acts at once, Ask first pauses before actions that change something, and Plan only writes a plan and runs nothing.
• Cronruns a prompt on a schedule, for example a test run on a lab machine, and the result appears in the chat like any other action, with the same cards and the same output.
• Modelsa cloud AI provider through a standard API endpoint, a model on your PC, or the built-in model; the Test button checks an endpoint and shows its response time and context window.

Four debugging jobs, step by step

Read a crash call stack

Task: your own app crashed on a test machine and you have a call stack that your x64 debugger saved as text. read_file loads stack.txt, and grep looks for the exception code in the log, for example 0xC0000005 for an access violation. The agent then lists the top frames of the faulting thread and opens the source file that matches the first frame. Each action appears in the chat as a card, and you can expand a card to read the full output. If a boot bsod leaves a kernel error 41 entry in the event log, the dump written around that time, if there is one, holds the state you need. Start at the top. Read the frames yourself, because the agent works from text output, then accept or reject the proposed diff in Ask first mode.

Fix a stack overflow

Task: the log shows 0xC00000FD, the exception code for a stack overflow, and you want the function that recursed. grep searches your source for the function name from the top frames, and read_file opens it so the agent can see how the recursion ends. edit_file proposes a minimal diff, for example a missing stop condition, and shows exactly which lines change. Shell then runs your build command and your test command, and each card reports the real exit code. A bsod with a memory management stop code is a different failure, but the method is the same: find the exception, read the stack, test one change at a time. Keep each change small. Review the diff and the test result before you keep anything, and run the test once more after the final edit.

Check the JIT debugging setting

Task: before you rely on a crash-time debugger, check the JIT debugging value on a test machine. JIT means just-in-time: Windows starts a debugger automatically when an application crashes, and it is a system setting. Shell runs the command you give it to read the current value, and write_file saves that value to settings-before.txt, so the old value is written down. Change it only on a test machine, never on your daily PC, and restore the saved value afterwards. In Ask first mode the agent pauses before each action that changes something, so you approve the change and the restore separately. Write the value down. Read the saved file before you start, and read it again before you restore the value.

Debug a driver on a lab target

Task: a driver you wrote crashes a test target and you need the faulting function. Kernel-level work normally needs two machines or a virtual machine, one running the debugger and one as the test target, linked by a debug connection, and the target stays in a lab. Shell runs commands over SSH on a lab machine you own, read_file reads the text the debugger saved, and grep matches the module name against your source. On a new computer, a dpc watchdog violation bsod can come from a driver you are writing, so the stack of the stuck thread is the first thing to read. Keep it in a lab. You review every finding before you change a line, and you run the test on the target again afterwards.