DeskPilot

Author(s)

• Raimund Andree

Tags

Copilot GitHubCopilot ShellPilot Agent AI GUI AgenticOperatingModel Windows Linux macOS

Functions

Start-DeskPilot

PSEditions

Core

Dependencies

This module has no dependencies.

Release Notes

## [0.5.0-preview0011] - 2026-08-12

### Added

- **A way to measure whether any of this actually helped.** Everything above
 claims to close a gap against VS Code Copilot; none of it proved anything. A
 new parity eval harness under `tests/live/eval/` runs a corpus of tasks that
 were genuinely attempted — starting with the two failures that began this work
 — against a pinned copy of a real repository, and grades the result against
 facts rather than impressions: did it run the authoritative test gate, did it
 use the search tool instead of the shell, did it leave the working tree alone
 when told to, did it commit when it was not asked to. Speed, tokens and cost
 are reported beside the result but never graded — a cheaper answer that is
 wrong is not better. Two runs can be compared, and a task that used to pass and
 now fails is reported as a regression and fails the run. It costs real credits,
 so it never runs as part of the normal test suite; the grading logic itself is
 unit-tested against recorded examples and makes no calls at all.
- **A job can now keep a record of what it actually did.** Until now nothing
 joined up a job's history: the live progress vanished as it scrolled, the tool
 calls arrived as an unordered set, and the thinking pane was one long string —
 so when a job went wrong there was no way to see the order things happened in.
 A new **Turn transcript** writes one file per job listing every step in
 sequence: each tool call with its timestamp and which round of the job it
 belonged to, when the agent was talking, when it updated its task list, and how
 the job ended. It is deliberately a *summary*, never a copy: a tool call records
 the command it ran or the file it touched and nothing else — never a file's
 contents, never a command's output, and never the agent's own words, which are
 already kept with the message. Each entry says how many characters there were,
 so nothing is silently hidden. Transcripts live in your DeskPilot data folder,
 are pruned automatically once they get old or bulky, and can be fetched back
 through the local API. It is a diagnostic and it writes files, so it is **off**
 by default (`turnTranscript`).
- **The agent can change three lines without rewriting the file.** Until now its
 only way to edit anything was to write the file out whole — so changing a
 couple of lines in a 900-line file meant reproducing the other 898 from memory,
 and whatever it failed to reproduce was simply gone. On a large file that is
 not a risk, it is the expected outcome. A new **replace_in_file** tool changes
 one exact block of text and leaves every other byte alone: your file's
 encoding, its byte-order mark and its line endings all survive, so a three-line
 change shows up in the Changes card as three lines rather than as a whole-file
 rewrite you cannot review. The text it is asked to replace has to appear
 **exactly once** — if it appears twice, or not at all, the tool refuses and the
 file is left untouched, because an edit that lands in the wrong place is worse
 than an edit that does not happen. It is confined to your selected Project on
 the same terms as the search tools, refuses binary files, and follows the
 **File access** permission. Edits made through it appear in the Activity card
 and in the Changes card, so **Undo** still puts everything back.
- **The agent can search your project.** It had no search of any kind: to find a
 file by name, or find where something is defined, it had to fall back to
 running a shell command and reading the console output that came back. That is
 slow and awkward enough that it mostly did not bother, and answered from less
 evidence than it could have. Two new tools make looking things up cheap —
 **search_files** finds files by name or pattern (`**/*.ps1`,
 `source/Private/*.ps1`), and **search_text** finds a string or a regular
 expression inside them and reports the file, the line number and the line. Both
 are confined to your selected Project and cannot be pointed anywhere else: an
 absolute path, a drive letter or a `..` is refused. Both skip whatever your
 `.gitignore` skips, never look in `.git`, `node_modules`, `output`, `bin` or
 `obj`, and skip binary files. Results are capped and time-boxed, and a capped
 result always says so, so the agent is never quietly told that something does
 not exist when it simply did not fit. The tools follow the **File access**
 permission: with file access off they are not offered at all, and with no
 Project selected they ask you to select one rather than searching anything
 else.
- **The agent is told what is in your project before it starts.** It used to be
 given the folder's *path* and nothing else, so it began every job blind: to
 learn which branch you are on, whether you have uncommitted work, or even which
 files exist, it had to go and look — and often it simply did not bother and
 answered from the path alone. Each job now opens with a short description of
 the project: the current branch and what it tracks, whether the working tree
 has uncommitted changes, and a listing of the files. The listing is
 deliberately bounded — it skips anything your `.gitignore` skips, never shows
 `.git`, `node_modules`, `output`, `bin` or `obj`, and where a folder is too
 deep or too large it is summarised as `name/ (12 files)` rather than cut off,
 so the agent knows there is more and can look inside. Gathering it is capped at
 two seconds: a very large or slow folder simply contributes nothing rather than
 delaying the job. A new **Describe the project folder to the agent** setting
 turns it off on a very large repository.
- **A job that runs out of steps now tells you, and keeps its work.** The step
 budget rose from 25 to 50 — 25 cut off real work such as auditing a repository
 or running a build and diagnosing it. **200 is the recommended maximum**, and
 you can go above it, up to 1000, once you have confirmed a warning: every step
 is a paid round trip, and a job that long can outlive its own sign-in token and
 stop with an error it cannot recover from. So a deliberate long job is allowed
 while a typo still cannot start an expensive runaway. The agent is also told how
 many steps it has, so it can spend them deliberately instead of being cut off
 mid-thought.
 When a job does hit the limit it no longer disappears into an error: it ends
 like a stopped job, explains that it ran out of budget, points at the setting,
 and keeps everything it had already said and planned.
- **Workspace-wide instructions now actually apply.** An instruction file that
 applies to everything was only ever *offered* to the agent, which had to decide
 to go and fetch it — and often did not, so rules you had written were quietly
 not in force. Instruction files whose `applyTo` is `**` are now put straight
 into the agent's brief at the start of every job. Instructions scoped to
 particular files are unchanged: the agent still fetches those when they become
 relevant. A new **Always apply workspace-wide instructions** setting turns this
 off if you would rather save the context on a small model.
- **See what the agent said while it worked.** A job that used several tools
 narrated its way through them — "let me check the branch first", "the counts
 differ, so I will find out why" — and every word of it was thrown away the
 moment the job finished, leaving only the final answer. Those notes are now
 kept in a **Steps** section above the answer, one entry per tool the agent
 reached for. It is collapsed by default, it survives a reload, and a job you
 stop keeps whatever it had already said — which is often the only record of
 what it was doing.
- **Watch the files being edited, while they are edited.** Until a job finished,
 the only place that named the file the agent was writing was the thinking
 trace — so with **Show the model's thinking** switched off, nothing named it at
 all. A card now appears under the answer as the job runs and lists each file
 the moment the agent starts writing it. When the job ends, the reviewed card
 you already know — with the `+`/`−` counts, **Keep** and **Undo** — takes its
 place. A job you stop, or one in a folder that is not a repository, keeps the
 list instead of clearing it, so you can still see what was written.
- **Pick the model from your phone.** Intercom could switch the conversation, the
 agent and the project, but not the model, so choosing one still meant walking
 back to the machine. `/models` lists the models your account is offered, marks
 the one your next instruction would run on and gives you a button per model;
 `/model 2` picks one and `/model default` goes back to the standard one.
 `/status` now names the model too. A switch applies to your next instruction —
 it never disturbs a job already running — and it changes both the default and
 the conversation you are in, so the model you were told about is the model that
 actually runs. While a job is running and the list has never been loaded,
 `/models` says so and asks you to try again afterwards rather than freezing
 DeskPilot to go and fetch it.
- **Switch agent and project from your phone.** Intercom could switch
 conversations but not the two things that decide *how* and *where* the agent
 works. `/agents` lists the agents you have, marks the one in use and gives you
 a button per agent; `/agent 2` picks one and `/agent none` goes back to the
 default. `/projects` does the same for your projects and says on every line
 which ones you are allowed to work in from your phone, so you learn that before
 you send an instruction rather than from a refusal. `/project new C:\Git\Notes`
 registers a folder as a project — creating that last folder if it does not
 exist yet — and `/status` now names the agent in use. A project added from your
 phone is deliberately **not** remote-controllable until you