editor

Root-relative path of the buffer to close.

False when nothing was open at that path.

Newest first, one entry per path.

Initial contents for a file. Ignored for a folder.

What to create. Defaults to a file.

Root-relative path to create. Missing parent folders are created.

Always true on success; the call errors rather than reporting false.

Create a file or a folder.

Root-relative path to remove.

Required to remove a non-empty folder.

Buffers closed because their file is gone. Leaving them open would let the next save recreate a file the user just deleted.

The text as it will be.

The text as it was.

Unchanged lines kept around each hunk (`-U` of `git diff`). Defaults to the worker's `diff_context_lines`.

Path used to label the patch header. Nothing is read from disk — this is presentation only.

Total lines added across every hunk.

One entry per `@@` block, in file order.

True when `before` and `after` are byte-identical.

Unified diff. Empty when the two sides are identical.

Total lines removed across every hunk.

True when either side exceeded `max_bytes` and the diff was skipped. `patch` and `hunks` are empty in that case — a caller that ignores this flag would read "no changes" from a file that was simply too big.

Include files git does not track yet (still honouring `.gitignore`). On by default — a file the agent just created is exactly the one you are looking for. Ignored outside a repository, where the workspace listing is the source of candidates.

Rows to return. Defaults to the worker's `find_limit`.

Fuzzy query. Matched as a subsequence against every tracked path, with basename and word-boundary hits ranked highest. Empty returns the first `limit` paths unranked.

True when candidates came from git's listing (so `.gitignore` was honoured), false when they came from the folder walk.

Paths considered. Compare against `truncated` to know whether the whole repo was ranked.

True when not every path in the workspace was ranked: it held more than `max_find_candidates`, or the folder walk stopped at its visit budget. Either way this ranking is over a prefix of the workspace.

Repository to run in. Defaults to the workspace root.

Commit message. Passed as a single `-m` argument.

Stage every change first (`git add -A`). On by default, matching what an editor's commit command does; pass false to commit only the index.

False when there was nothing staged to commit.

Full SHA of the new commit, when one was made.

git's own summary line, verbatim.

Which comparison to make. Defaults to `worktree`.

Unchanged lines kept around each hunk in `patch`. Defaults to 0, which keeps `hunks` exactly the lines that changed — the ranges a gutter paints. Pass 3 or so for a patch a person will read, and note that the reported ranges widen to include the context you asked for.

Directory to run git in. Defaults to the workspace root.

Repository-relative path to inspect.

Echo of the comparison performed, so a cached response is self-describing.

Changed ranges, in file order. Empty when the file matches.

The rendered unified patch, for showing a person what changed. Empty when there is no difference, and capped by `max_diff_bytes` — a caller that only wants the ranges can ignore it.

True when git reports the path as untracked, in which case there is nothing to compare against and `hunks` is empty.

Repository to run in. Defaults to the workspace root.

Root-relative path.

Revision to read the file at. Defaults to `HEAD`.

The file's contents at that revision. Empty when the path did not exist there — which is what `exists: false` distinguishes from an empty file.

False when the path is absent at that revision (a file being added).

Stash the working tree, or restore the most recent stash.

Repository to run in. Defaults to the workspace root.

Directory to run git in. Defaults to the workspace root. Confined by shell's jail exactly like any other `shell::exec` call.

Commits on this branch the upstream does not have.

Commits on the upstream this branch does not have.

Current branch, or `None` on a detached HEAD.

True when nothing is modified, staged, or untracked.

One row per changed path, in git's order.

Configured upstream, e.g. `origin/main`.

Which remote operation to run.

Repository to run in. Defaults to the workspace root.

Which remote operation to run.

Ahead/behind after the operation, so a caller does not need a second round trip to find out whether it changed anything.

git's output, trimmed. Both streams: git reports progress on stderr.

Repository to run in. Defaults to the workspace root.

Its message, so a caller can put it straight back in a commit box.

SHA that was undone.

Existing root-relative path.

Destination root-relative path.

Open buffers and expanded folders rewritten to the new location. A folder move rewrites everything beneath it, which is the whole reason moves go through this function instead of `shell::fs::mv` directly.

Configuration id that changed (advisory; the handler re-fetches).

Outcome of the call this hook is reporting on. A write that failed did not change anything, and the hook fires either way.

Jail-relative when `shell`'s `fs.host_roots` are set, else absolute — the same path vocabulary as `shell::fs::read`.

File contents as text. Binary files are refused rather than mangled.

Monaco language id for the path, e.g. `rust`, `typescript`, `plaintext`.

Last-modified time, Unix seconds. Pass it back as `expected_mtime` on `editor::save` to get the conflict guard.

True when the file exceeded `max_file_bytes` and `content` holds only its beginning. Saving a truncated buffer back would delete the rest of the file, so `editor::save` refuses one.

Opaque version of the `content` above. Pass it back as `expected_version` on `editor::save` for a guard that does not depend on the filesystem's timestamp resolution: it catches a write that landed inside the same second, which `mtime` cannot. Compare it for equality only — the encoding is this worker's business and may change.

Full new contents. This is a whole-file write, not a patch.

The `mtime` from the `editor::open` this edit started from. When it no longer matches the file on disk, the write is refused and the divergence comes back as a patch. Omit only when deliberately overwriting whatever is there. Resolution is one second, which is all the filesystem reports. Two writes inside the same second are therefore indistinguishable to this field, and the second one wins silently — send `expected_version` instead to close that window.

The `version` from the `editor::open` — or from the previous `editor::save` — this edit started from. It is a version of the *content*, so it catches a write that landed inside the same filesystem second and it does not care whether a clock or a checkout moved the mtime. When this is present it is the guard and `expected_mtime` is ignored. When it is absent the `expected_mtime` comparison applies exactly as before, so a caller that has never heard of a version is unaffected.

Lines this save added relative to what was on disk before it.

True when the write was refused because the file changed underneath.

On conflict: a unified diff from the current disk contents to the contents you tried to write, so the divergence is reviewable without a second round trip.

True when the file did not exist and was created.

What was on disk when a conflict was detected.

Version of the disk contents when a conflict was detected — the value to send as `expected_version` once you have reconciled with them.

Last-modified time after the write. Feed it into the next save.

Lines this save removed.

True when the file was written.

Version of the content this file now holds: what was written on success, what is on disk on a conflict. Feed it into the next save as `expected_version`.

Match case-insensitively.

Glob filters restricting which files are searched, e.g. `["**/*.rs"]`.

Stop after this many matching lines. Defaults to the worker's `search_max_matches`.

Rust regex matched against each line.

Matches grouped by file, in first-match order — the shape a result panel renders, rather than a flat list every caller has to group.

Total matching lines across every file.

True when the search stopped at `max_matches`.

Root-relative folders to collapse. Collapsing takes its descendants with it.

Root-relative folders to mark expanded before listing. Expansion is part of the shared workspace, so it survives a reload and both surfaces agree on it.

Levels to descend. Defaults to 4 — deep enough to navigate, shallow enough that one call does not walk a whole monorepo.

Folder to list, relative to the workspace root. Defaults to the root.

Folders the workspace has expanded, root-relative.

Canonical absolute path of the listed folder, as shell resolved it.

The listing exactly as the shell worker returned it (nested `{name, kind, size, mtime, children}` nodes). Passed through rather than re-modelled so this worker does not pin shell's response shape.

The asset path from the trigger config (e.g. `state/page.js`).

The asset source, verbatim.

MIME type the console should serve the asset with.

Files currently open against this root, shared by every surface.

Folders expanded in the tree, root-relative.

The active root every other path in this response is relative to.

Directory to work in. Jail-relative when shell's `fs.host_roots` are set, else absolute. A plain folder is enough — a git repository is an overlay, never a requirement.

Files currently open against this root, shared by every surface.

Folders expanded in the tree, root-relative.

The active root every other path in this response is relative to.