Everything Girl can call.

Ask the user a focused question and wait for their answer. Provide choices when the answer should be constrained; omit them for free-form text.

Search and load deferred built-in, reusable, and MCP tools. Use a concise capability query, then call a returned tool on the next step.

Get the authoritative structure, supported runtime APIs, permission rules, and examples for reusable Lua tools. Call this before composing source for save_tool. With no topic it returns the complete guide.

Store a reusable Lua tool module. Call tool_authoring_guide before writing source. Use project scope for repository-specific workflows such as build scripts; use global only for generally reusable capabilities. Source must return function(registry) and register one or more tools.

Read a UTF-8 text file. Paths are workspace-relative unless absolute=true, which requires the outside-workspace permission. Large files are paged: every result ends with a machine footer [read_file <path> | lines A-B of N | next_offset=Z|nil | eol=LF|CRLF|mixed|none|binary | <bytes> bytes] — follow next_offset with offset=Z (same limit) until it is nil; no gap, no overlap, lines are never cut mid-line. Tail: pass a negative offset (offset=-N reads the last N lines when no limit is given, else the last <limit> lines) or range="tail". Set numbered=false to drop the 9-char line-number prefixes on wide pages. Editing a file normalizes its line endings to LF, so read text pastes cleanly as edit anchors.

Create or replace a text file. Paths are workspace-relative unless absolute=true, which requires the outside-workspace permission.

Apply a transactional *** Begin Patch change set inside the workspace. Supports Add File, Update File with @@ hunks, and Delete File; all paths must be workspace-relative.

Inspect a supported local image by loading it as a structured data-URL attachment. Paths are workspace-relative; supported formats are PNG, JPEG, GIF, WebP, AVIF, BMP, TIFF, and SVG.

Replace text in a file. Line endings are normalized to LF when the file is touched, so anchors never need CRLF care. Paths are workspace-relative unless absolute=true, which requires the outside-workspace permission.

Append text to the end of a file (creates parent directories; creates the file when missing). Line endings normalize to LF when an existing file is touched; bytes otherwise glue verbatim (no separator newline is invented, supply your own leading newline). For replacing text mid-file use edit_file. Paths are workspace-relative unless absolute=true.

List files below a directory. Paths are workspace-relative unless absolute=true, which requires the outside-workspace permission.

Search text files with path globs, case control, whole-word matching, optional Lua patterns, and surrounding context. Paths are workspace-relative unless absolute=true.

Copy a subagent's worktree changes back into the main workspace. Subagents work in an isolated copy under .girl/worktrees/, so their write_file/edit_file changes never touch the main folder until promoted. Pass the job id returned by spawn_subagent/subagent_wait; an optional path promotes just that workspace-relative file. Files the subagent deleted are ignored (promotion never deletes main state). Returns the promoted file paths.

Run a command and return its combined output and exit code. Two modes: pass command for a shell string, or pass bin with args for structured argv. The shell defaults to cmd; pass "powershell" or "pwsh" for PowerShell syntax. Output streams into the UI as it arrives; a foreground command still running after the configured wait is converted to a background task you can peek at or kill.

Poll one resumable process, returning its current output and exit state.

Write characters to a running resumable process. Set close=true to close its stdin after the characters are delivered.

Terminate a background command that is still running (run background=true), including one blocked in a wait that will never finish (a prompt, `pause`, a hung server). Returns the final status; the task's failure notice reports "process cancelled".

Peek at the output of a background task (run background=true, run_lua background=true, or a task converted to background) while it is still running: list tasks (commands and Lua jobs alike, same ids as lua_status), or read the tail/head/search/count of one task's output so far. Does not wait for the task and does not disturb it.

Maintain the task list for the current session. Ops: init (replace the list with phases; list={"phase",items={...}} entries), start <task>, done <task>, drop <task>, block <task> [reason], unblock <task>, rm <task|phase>, append <phase> <items>, view. Phases order the list; when nothing is in progress the earliest pending task auto-promotes to in_progress; blocked tasks stay blocked until unblocked.

Write (or overwrite) the session's implementation plan. Use for the initial draft or a full rewrite.

Replace exact text in the session's plan. Behaves like edit_file: old_text must match uniquely (or set replace_all).

Read the session's current implementation plan.

Present the session's plan to the user for approval. The user can accept (switching to implement mode), accept and clear context (fresh start with only the plan), or provide feedback to continue planning.

Delegate one task or a parallel tasks[] batch to independent Girl agents. For one task, set task; an omitted or empty tasks array is ignored. For a batch, set non-empty tasks and omit task. Omit agent to use the configured default profile, or the main default model when no profile is configured. Available profiles: explore, implement, review, custom. By default each subagent works in an isolated worktree checked out under .girl/worktrees/ in the workspace -- never in the main folder -- so parallel agents cannot clobber each other. After subagent_wait or completion, call promote_worktree with the job id to copy the changed files back into the main workspace. Results from background agents are delivered automatically. A foreground (non-background) spawn waits at most 60000ms: slower jobs are converted to background tasks and reported to you when they finish, so do not rerun or re-wait for them.

List configured subagent profiles and inspect running or completed subagent jobs.

Wait for subagents. Pass all=true for every current job; ids waits for selected jobs; no selector waits for the next completion. Waits longer than 60000ms are not allowed: pass at most 60000 (0 polls once and returns immediately; infinite waits are not accepted -- stop and continue other work instead, the result is delivered automatically when the jobs finish). Do not rerun or re-wait for them.

Send a message to a running subagent. The subagent receives it as a steering note it can act on, and it appears in the subagent's chat view. Subagents can reach you with their own send_message tool.

Send an explicit follow-up task to a running subagent. The task is injected between its model turns.

Interrupt one running subagent without closing the parent session.

Compact explainable repository map: important files, definitions, signatures, and relationships within a strict token budget. Missing parsers degrade per file; lexical search stays available.

Read-only language-server navigation: status, definition, references, implementation, hover, document/workspace symbols. Lazy server start; configured argv only; outside-workspace results omitted.

Version-aware language-server diagnostics with freshness labels. Explicit call only; never automatic.

Structural code search: definition/call sites in code ranges only (no string/comment false positives for declared languages). Honest per-file degradation.

Preview-only structural rewrite: returns a proposal id and bounded diff, writes nothing. Apply separately with ast_edit_apply.

Apply a previewed structural proposal atomically (all-or-nothing, checkpointed, undoable). Rejects on any stale target.

Drop a previewed structural proposal without writing anything.

Run Lua in an isolated state. Pass code for inline source, or file for a workspace-relative Lua script path (exactly one of the two; use absolute=true for an absolute path). file also accepts args, a dense string array exposed to the script as the global arg (arg[0] is the file, arg[1..n] are the args). Compose any registered tool, including hidden or deferred tools, with tools.name(args), tools.call(name,args), or tools.try(name,args); permissions and hooks still apply. Named states persist globals. background=true starts a job whose completion is reported automatically; long foreground calls may also become background. Output and nested calls are bounded, and sandbox capabilities are configurable.

Inspect persistent Lua states and foreground/background job status. With no id it returns the structured status table (states, jobs with output/error tails, wait tickets). With id (a lua-* or task-* job) it peeks that task exactly like process_output: list tasks, or read the tail/head/search/count of one task's output so far. Both tools share one backend, so ids, headers, and modes match.

Reset a named persistent Lua state, or all states. This discards its globals and loaded values.

Forcibly kill a Lua job or state blocked in native code. The entire state and its globals are discarded; use only when normal cancellation or reset cannot complete.

Watch asynchronous Lua jobs without blocking. This call returns immediately with a wait ticket, so the conversation stays interactive: the watched jobs are detached from this turn and an automatic notification arrives when they finish, or after timeout_ms if they are still running, whichever comes first. Pass all=true to watch every current background job, ids to watch specific jobs, or neither to watch the next job that finishes. If the selected jobs already finished, their results are returned right away. Peek at live progress with process_output or lua_status meanwhile. Nothing must be done to receive the notification, and the jobs must not be started again. The still-running notice deadline is at most 60000ms (longer requests are clamped, the ticket stays armed); 0 disables that notice so only the completion notification arrives.

Show the Git branch and concise worktree status.

Show unstaged or staged Git changes.

Show recent Git commits.

Commit the current staged Git changes.

Save a durable project memory or temporary working memory.

Retrieve relevant working, project, and user memories.

Search the web using configured Lua backends, with retry and fallback support.

Fetch an HTTP(S) resource using LuaXE's network module.