Applies exact text or guarded line-range edits to one file in any strategy owned by the authenticated user and creates a new immutable strategy revision. Requires editHandle from get_file/list_files. For insert_before and insert_after operations, include an exact unique anchor. For replace_text, oldText must match exactly one location unless you explicitly select matchIndex from the returned match locations. If a statement appears in several lifecycle methods, choose the intended match and copy its compact retryOperation unchanged, or include surrounding function context. Use replaceAll=true only when every occurrence is part of the requested change; repeated text does not make unrelated resets or branches interchangeable. For a localized exact replacement, the complete required shape is {"path":"main.py","editHandle":"","operations":[{"type":"replace_text","oldText":"","newText":""}]}. Keep path, editHandle, operation type, oldText, and newText in the same call; omitting any of them fails validation. For the current attached/open strategy, omit strategyId and revisionId after get_file; the server resolves the latest conversation revision, so do not manually transcribe those UUIDs. Pass explicit ids only for a named or different strategy. For replace_range operations, include startLine and endLine. For replacing most or all of main.py after create_strategy, prefer replace_file. Do not use patch_file for a short placeholder or a repair that replaces most of the returned file. Never estimate an endLine beyond the exact returned file. For those rewrites, call replace_file directly with the complete content and latest editHandle. Before any second file mutation, read the first mutation's returned new revisionId with get_file and use that readback's revisionId and editHandle. Never reuse the preceding revisionId or editHandle after a successful mutation. For existing-strategy fixes, this is the action step after get_file identified the concrete change and returned an editHandle. Mutate only the strategy/revision named by the user when it differs from the open page context. After a successful patch, call get_file on the returned new revisionId to read back the final saved code and verify the saved executable code before final-answering; do not verify by re-reading the original/base revisionId from before the edit. When an edit follows a backtest request or result in the same conversation, validate the new saved revision with the established window, capital and data settings after readback, even when the earlier run succeeded and the customer did not repeat the test request. Explicit save-only instructions and disabled automatic-backtest preferences take precedence. A standalone file edit without a backtesting workflow is complete after saving and readback unless testing was requested. Never deploy or trade merely to validate an edit. A successful mutation, compiling/ready analysis, or readback alone does not complete the requested repair. If the saved executable code still uses the faulty causal path the user asked to repair, or new helpers/scaffolding are not connected to it, continue the remaining authorized file edits with the current editHandle. Do not final-answer with a plan, apology, model-upgrade suggestion, or admission that the repair is incomplete while authorization and execution budget permit, the file tools work, and the remaining corrective edit is known. Recover ambiguous anchors with the returned unique context, an exact guarded range, or complete replace_file; a recoverable patch-format error is not a missing capability. Finish the requested change and preserve unrelated behavior and files. For copy/apply-same-rules requests, do not use patch_file after reading only one strategy, and do not use it after reading only the target. A different revision of the named target is still target evidence, not source evidence, unless the user explicitly asked to copy from an older target revision. First read the source strategy code and the named target strategy code, then diff executable assignments/thresholds/cadence/branches within the requested copy scope. Copy only explicitly requested mechanics for a limited transfer; update every differing target value to the source value only for whole-strategy parity. Preserve target-specific identity such as symbol/ticker, strategy name, account/broker identity, and labels unless the user explicitly asks to change them; do not copy the source symbol/name into the target. Build the patch from the target file and selectively copy behavior values into it; do not patch by pasting the whole source file over the target when identities differ. In Python strategy code, self.symbol is target identity when source and target tickers differ; for a TQQQ source applied to an SQQQ target, keep self.symbol as SQQQ while copying behavior rules. Target identity does not include cadence, sleeptime, trigger thresholds, order sizing, entry/exit branches, helper calls, or risk rules; those are behavior and must match the source only when included in the requested copy scope. Do not add settings absent from the source or merge unrelated memory/preferences. Before patch_file in a copy/apply-same-rules edit, preserve the literal target identity line from the target readback in the patch. If your patch would turn target identity into source identity, do not call this tool yet; correct the patch first. After readback for a copy/apply-same-rules edit, if the target file contains source identity such as the source symbol/name/account/broker, edit again before final-answering. Do not list source identity as evidence of success. When the fix replaces an executable setting, guard, helper call, order path, or branch, remove or replace the stale executable code; do not append a competing line and leave the old contradictory behavior in place. When the user says to stop using a value/source, or says that value/source is stale or wrong, remove executable fallback uses of that value/source instead of keeping them as a backup path. If the readback still contains the stale executable value/source/fallback the user asked to remove, the edit is not complete; call patch_file or replace_file again before final-answering. If the user supplied a concrete replacement value for a code-owned setting such as cost basis, entry price, threshold, cadence, market, symbol, or helper path, replace the stale executable literal/path and read it back. For live fill/cost-basis fixes where live order tools fail but the user supplied a concrete bot-owned fill, record/use that exact fill value in executable state/code as the bootstrap latest verified bot-owned fill; do not add only an unset placeholder such as None. For plan-driven first-build work, make the visible implementation item in_progress with update_plan_item before using file tools so the user sees the current plan step while file work runs. If a patch operation fails, no new revision was created: read the current file/editHandle and retry with replace_file or a corrected patch before starting a backtest or ending the strategy build. Default to the active strategy unless the user explicitly asks for another owned strategy.