Changelog

This is the human-readable vincent release history. The generated canonical CHANGELOG remains the source used by release automation, while this page removes duplicate commit subjects and keeps the product impact clear.

0.10.0 — Skills and files in chat, and work on an existing branch

Released 2026-09-23.

Added

Run a task or chat on a branch that already exists. --existing-branch on vincent task add and vincent chat start works on that branch instead of cutting a new one — fast-forwarding it from its upstream when it is behind, and blocking instead of touching it when it has diverged. If the branch is checked out in your own copy of the project, the task runs right there, and archiving it removes nothing. In the TUI, the new-task form’s branch rows are now lists of the project’s branches, the new-chat form gains a branch row, and both say before you submit where the work will run. (#541, #543)
See and invoke a chat agent’s skills. tab (or f2) in the chat workspace lists the skills the agent would load, and picking one writes its invocation into your message. The list also opens by itself as you type /name under claude or $name under codex, and never changes what you send unless you pick from it. vincent chat skills prints the same list in the terminal. (#535, #537, #531)
claude and codex report their skills. claude lists its skills without spending a turn and adds its bundled ones (simplify, loop, run) once a chat has had a turn; codex lists repository, user, system and plugin skills. A chat on a containerized task lists the skills inside its container, not on your machine. GET /v1/agents says which agents can list skills and how each one invokes them. (#517, #526, #524, #528, #536, #540)
Skills that ran show in the transcript. A skill claude loaded, or one you invoked in a chat message, is now its own line in the output pane, the chat and vincent task transcript / vincent chat transcript, with its arguments and whether it failed — instead of a raw dump of the skill’s text, or nothing at all. (#518, #527, #532)
Point the agent at a file with @. Typing @ and a few characters in the chat composer opens a ranked list of the files in the chat’s workspace, and picking one inserts the mention exactly as the agent expects it, quoting included. vincent chat files lists the same files in the terminal, and GET /v1/agents says whether each agent reads a mentioned file itself or leaves the model to open it. (#569, #568, #567, #566, #564)
A /clear in a chat is marked where it happened, so the transcript no longer shows earlier turns as if the agent could still see them. (#583)
Send a chat message from a file or stdin. --message-file on vincent chat send and chat start sends the text byte for byte, so a /review or $name invocation survives Git Bash and other shells. (#525)
Bring your global workflows up to date, with approval. update-workflows with global: true rewrites the workflows in your config directory as a proposal and waits at an approve gate before installing it. vincent workflow ls --global and vincent workflow apply list and install such proposals without a daemon. (#495)
Example workflows that take on GitHub issues in bulk. This repository’s own github-resolve-issue-multiple picks the open issues that are ready, waits for your approval and creates one task per issue; github-iterate-work then drives those tasks through to merged. (#523, #563, #588)

Fixed

Chat drafts can contain newlines, with ctrl+j, shift+enter or alt+enter; enter still sends. (#519)
A skill typed as the first message of a chat on a task now runs, instead of being lost in the task’s context. (#520)
A chat on a containerized task sees the agent login mounted for it, instead of running effectively logged out. (#540)
Typing @something in a chat no longer turns skill completion off for the rest of the chat. (#558)
Cleaner agent output. cursor’s echo of your prompt is no longer counted as an unrecognized line, and a claude Skill call names the skill it loads. (#518, #522)
The new-task form no longer keeps the branch name of the last chat you handed off. (#543)
A blank workflow field means the same thing everywhere. An empty or whitespace-only value is treated as not given, in the form and on the API alike. (#582)
Installing vincent’s skills for several agents at once works, from vincent skills install and the daemon view. (#491)
The example DAG issue workflow no longer fails every lane’s check on a parent branch that has not been pushed yet. (#530)
The Windows install docs state which releases reached WinGet and link the open submissions. (#584)

0.9.0 — Event triggers, pull request actions, and agents inside the container

Released 2026-09-18.

Added

Event triggers start work from outside events. A trigger file watches a source — a command the daemon polls, a project’s GitHub issues or pull requests, or a signed push to the daemon — and turns each new event into a task, or into a follow-up, retry or cancel of an existing one. Triggers are off twice (the file and triggers.enabled in config.yaml), switching one on never fires events that already existed, and by default a trigger only proposes: its task lands paused with its agent steps restricted until you resume it. A new triggers view in the TUI creates, edits and enables them, shows each one’s poll health and delivery ledger, and dry-runs one against a sample event or a live poll. (#364, #417)
Scheduled triggers. A trigger can be the clock instead of an outside system — a nightly dependency sweep, a weekday-morning report — with cron: or every: and an optional time zone. A schedule that came due while the machine slept fires once when the daemon is back, however many occurrences it missed. (#482)
Decide what a trigger does when its previous work is still running. overrun: can skip the new event, cancel the running task and fire, keep only the newest event, or queue them in turn, per ticket, pull request or branch. The default is the old behaviour, so existing trigger files are unaffected. (#484)
An agent can write your triggers, and cannot switch one on. The new create-trigger and update-triggers built-in workflows and the vincent-triggers skill do for triggers what their workflow counterparts do for workflows. Their changes go through vincent trigger apply, which refuses anything that would arm a trigger — turning one on stays yours. (#423)
Create a task paused, restricted, or with its own cost cap. A new task, a retry or a follow-up can wait on the board until you resume it; a task can run every agent step restricted; and a task can carry a spend cap tighter than the global one. All three are on the API, vincent task add and the TUI’s forms. (#364)
Chat with a stopped task, in its own worktree. When a task is blocked, waiting at a gate, done or aborted, open a chat on it: a conversation with an agent working on the task’s branch, starting from the task’s context and the failure or gate it stopped at. Nothing can retry or skip the task underneath the chat while it is open. (#477)
Agent steps run inside the task’s container. With container.image set, a containerized task no longer starts its agents on your machine: the image’s own agent CLI runs next to its command steps and checks, with the same transcripts, costs and controls as a host run. (#463, #459)
Merge, close, reopen, comment on and re-run checks of a task’s pull request. From the Pull Request tab, vincent github pr or the API — only when a human asks, and never as an MCP tool. A merge is for the exact head whose checks you are looking at, and is refused up front when the branch is behind, a check is still running or the head moved. vincent github pr link, unlink, show and checks round out the command line. (#447, #453, #448)
Archived boards, and a permanent delete. Archived tasks and archived chats get boards of their own, reached from the command palette, where their full history can be read back. D deletes a row, its attempts and its transcripts for good; a branch carrying commits past its base is never deleted, and no agent can do it. (#351)
Scheduled backups, and one task back from a backup. Set backup.interval and the daemon takes its backup archive on that schedule, keeping the newest few. vincent task import brings a single deleted task back out of an archive — this installation’s or another’s. (#473, #476)
Cap what a whole fan-out tree may spend. max_tree_cost_usd is one ceiling for a task and every lane below it, retries and follow-ups included, and Task Details shows the tree’s spend. (#474)
Rebind the TUI’s keys. tui.keys in config.yaml moves an operation to another key on every screen that has it, and the footer, the palette and help follow. A key that would collide with anything is refused before it is written. (#475)
A Step Details tab showing what each attempt was actually given. The rendered prompt or script, the agent, model and effort with where each came from, and the outcome, recorded when the step ran. vincent task show --step prints the same, and vincent task show now also says when a queued task will be tried again. (#331, #446)
More of vincent from the command line. vincent agents shows each agent CLI’s version, login state and quota; vincent task diff prints a task’s diff, split by lane if you like; vincent project edit changes a project; vincent chat transcript reads and follows a chat turn. (#454, #445, #457, #455)
Clearer agent output. A Claude Code run’s subagents render nested behind a rail instead of reading as the main agent’s words, an edit reports the lines it added and removed (with the patch itself at verbose), and a cursor step shows where it ran and how long it took. Runs already on disk benefit too. (#464, #466, #462)
Vincent tells you when claude is not logged in, in vincent doctor, vincent agents and the new-task form, before a task burns its retries. (#460)
Open, copy and optionally click links in agent Markdown. ctrl+l lists every link in the assistant’s messages to open in your browser or copy, and tui.hyperlinks: true makes them clickable in terminals that support it. (#467, #465)
An in-progress indicator while an agent works, with an elapsed clock, in the chat workspace, the chats board, the task output pane and vincent chat send — so a turn busy running tools no longer looks stalled. (#335)
See whether vincent’s agent skills are installed, and install them. vincent doctor and vincent skills ls say which version you have against the one this build ships, and vincent skills install or S in the daemon view installs them. (#358)
Choose whether a usage-limit stop waits unattended. usage_limit_auto_continue keeps today’s automatic wait, waits only when the CLI named the reset time, or always blocks so nothing spends money while nobody is watching. (#349)
A footer that uses its width, and help from anywhere. The footer shows as many keys as fit and counts the ones it hides, f1 opens help even inside a chat or a form, and the mouse wheel moves the cursor on the chats and archived boards. (#355, #471)
Three example workflows that show control flow, and a lane graph in vincent workflow render. go-checks, ship and split-work join vincent workflow init --from, and render now draws a fan-out’s lanes and waves and checks a derived lane’s templates. (#469, #470, #427)
Search the documentation, and link to any heading. The docs site gains a search panel over every page section and a copy-link button on every heading. Starting tasks from GitHub Actions, Jenkins or TeamCity is now documented too. (#481, #361)

Changed

One key, one meaning across the TUI. Every shared operation now has the same key on every screen, and a few keys moved to get there: archive on the chats board is A, reload is R, the archive’s date window is s, removing a project is D, creating a task from a pull request is a, and opening a check on the Pull Request tab is enter. The help overlay now takes the keyboard while it is open. (#354, #471)
One usage-limit stop holds every task on that agent. Once vincent watches an agent’s usage window close, other tasks wait for the reset instead of each starting a process into the same wall — unless usage_limit_auto_continue is never. (#461)
A new task keeps your local base branch current, and shows what it started from. After fetching, vincent fast-forwards your local base branch when that is safe, and never otherwise; the task’s base commit and what happened to the refresh are shown in the TUI and vincent task show. (#432)
Containers and credentials. A containerized task’s agent credentials are now mounted under a vincent home inside the container, and a no-network container with MCP wiring on is refused only when the workflow has agent steps. On macOS, a containerized claude step needs a token passed through environment. (#463, #420)
The task Workflow tab’s graph is colored by run state, lighting up the path the run actually took. (#419)
parallel and manual steps refuse max_retries and retry_backoff instead of silently ignoring them. A workflow that sets either on those steps must move the value to where it applies; update-workflows does it for you. (#429)

Fixed

A fan-out whose lanes blocked is no longer a dead end. One retry on the parent re-admits every blocked lane beneath it, instead of one retry per lane or a cancel that threw the run away. (#337)
The board header counts every slot in use, and a running fan-out step shows on the timeline. The header could read 0/6 running while lanes held every slot, and a parent whose lanes were working looked stalled. (#329, #333)
Retrying a task blocked inside a loop evaluates its guards again, instead of keeping a stale answer and running a pass the loop should have ended. (#444)
A claude run that succeeded is never mistaken for a usage-limit stop, which could re-queue a task that merely wrote about usage limits, and spend money, again and again. (#347)
Retry and cancel work on the Pull Request tab. The tab used to swallow r and c for itself while the footer offered them. (#354, #425)
A follow-up that names a workflow honors that workflow’s fields, and can supply values of its own. (#422)
vincent task transcript shows a claude run’s header and result, and Task Details shows the task’s cost. (#426, #474)
Agents are told the right thing. The MCP tool descriptions name the request bodies the daemon actually accepts, and create-workflow can now write every workflow key. (#416, #431)
A bot’s pull requests report GitHub’s own login (dependabot[bot]) whichever GitHub credential vincent reads through. (#346)
Built with Go 1.26.8, picking up the standard library fixes the stuck toolchain job had missed. (#428)
Windows. The install docs lead with Scoop, since vincent’s WinGet package is still awaiting Microsoft’s review, and the fix-and-test example is marked POSIX-only instead of accepting tasks it cannot finish. (#435, #469)

0.8.0 — Chat, containers, MCP, and pull requests vincent can open

Released 2026-09-04.

Added

Free chat: conversational agent sessions beside tasks. A chat is a titled conversation with an agent, scoped to a project, running in its own git worktree and branch. Each turn resumes the agent CLI’s own session, so turn 10 still has turns 1 to 9 in context — nothing is replayed as prompt context. Chats are their own thing beside tasks, with their own board, their own workspace, their own lifecycle and their own max_parallel_chats cap, so a running chat never delays an admissible task. Drive one from the TUI, from vincent chat start|send|answer|list|show|archive, or over the API. Until now a conversation held outside vincent left no record at all; a chat’s turns carry the same accounting a step run does and each gets its own transcript. All three agents can hold one. (#259, #274, #286, #284)
A chat can hand its worktree and branch to a task. An idle chat gains a hand off action that creates a task adopting the chat’s worktree, branch, base branch and base SHA exactly as they are. Nothing is copied, renamed, merged or committed, so committed and uncommitted work are both there when the task’s first step runs. Explore a problem in conversation, then turn the result into supervised work without losing the tree you built. (#294)
The daemon speaks MCP, so an AI agent can drive vincent directly. Point any MCP client at http://127.0.0.1:{port}/mcp and it gets the whole API as tools, on the same loopback listener and behind the same token — discovery, argument schemas and typed errors instead of hand-rolled curl. task_wait blocks until a task finishes or parks, so following a run does not mean polling. Vincent’s own agent steps get those tools with nothing to configure, so a step can file follow-up work, read a sibling lane’s transcript or answer a gate. The agent-facing surface is deliberately narrower than the human one: stopping the daemon, reconfiguring it, deleting a project and opening a pull request are not tools. (#250)
Run a task’s steps inside a container. A container: block in config.yaml names an image, and a task’s command steps and checks run inside one container, created with the task’s worktree and removed with it. The image is yours and must already carry your agent CLI and git; vincent builds and bundles nothing. Setting nothing keeps the old behaviour exactly, and a missing runtime or unpullable image blocks the task before a worktree, a branch or a retry is spent. Note that the agent process itself still runs on the host for now, so a containerized task with agent steps is a mixed run. (#258)
Open a pull request from vincent itself, and watch its checks. P in the task workspace opens a form with the title, the body and a draft/ready toggle, and saving pushes the branch and creates the pull request; vincent github pr create does it without the TUI. A new Pull Request tab shows the linked pull request plus one row per CI check on its head commit, fetched live and never stored. A new pull-requests screen lists every open pull request across every project, with the task that claims each one, and opens them in a browser. Tasks are linked to the pull request opened from their branch automatically. This is the only thing vincent writes to GitHub — it never updates, comments on, closes or merges anything, it happens only when a human asks, and it is not reachable by an agent. (#276, #275, #247, #238)
Create a task from a pull request, checked out on its head branch. vincent task add --github-pull N, c on the pull-requests screen, or github_pull on the API. The task’s branch is the pull request’s head branch, so when a workflow pushes, the commits land on the pull request. Fork pull requests run too, and vincent says up front that nothing can be pushed back. (#264)
A workflow editor in the TUI. The workflow was the one first-class thing you could not author from the product — e handed the terminal to $EDITOR on raw YAML and that was the whole story. Now i opens a structured form on the entry under the cursor, a creates a workflow in a scope you pick, and f forks a built-in or global one into a project. The forms are rendered from a schema the daemon serves, so a field that is not legal on the step you are editing is never offered; they read every field the file can carry and change all of it, including adding, deleting and reordering steps, lanes and declared fields. A save preserves everything you did not edit — comments, key order, blank lines, block scalars and CRLF endings all survive. (#266, #326)
A live workflow graph on the task workspace. A new Workflow tab draws the workflow a task is running as a control-flow graph with its run state on it: what is running, what succeeded or failed, what a guard skipped as against what you skipped by hand, which loop pass it is on, and where a parked task is stuck and why. enter opens any node in full — the prompt, the run: body, the timeouts, a group’s bounds — marking values inherited from the workflow’s defaults. It reads with colour turned off, and it shows what actually ran even if the workflow file is edited underneath it. (#237, #240)
Fan-out lanes can depend on each other, and can be worked out at run time. A lane may name the sibling lanes it needs:, and the step runs the resulting graph in rounds, merging what is finished before spawning the lanes those merges made eligible — so a dependent lane’s worktree is cut from a branch that already contains its dependencies’ commits. A step may also derive its lanes rather than declare them: for_each: plus a single lane: template renders one lane per item, so a planning step can decide how many pieces of work there are and which must land first. schedule: eager merges each lane and spawns its dependents as soon as that lane’s own dependencies are done, instead of waiting for unrelated siblings. And a lane that fails mid-graph no longer un-does the rounds that already merged. (#306, #307)
A fan-out is something you can watch. Lanes are real child tasks, and almost none of that used to be reachable from the parent. Now L on the board hangs a parent’s lanes underneath it as indented rows, l in the task workspace opens the lane your selection points at and U goes back to the parent, the output pane grows a lane selector so you can watch a running lane without leaving the parent, and a parent blocked on a failed lane or a merge conflict says which lane. GET /v1/tasks/{id}/diff?by=lane splits a parent’s diff by the lane that produced it, so after the join you can see which lane wrote what instead of one wall of merged hunks. (#319)
A loop says where it is, and its earlier passes open. The rollup on the board and in the task header names the body step the current iteration is on — 3/7 green · loop 4/10 · repair 2/3 — and in the Steps & Attempts tab a folded iteration is no longer unreachable: space, →/← and O/C open and close tiers, so iteration 1 of a loop now on iteration 7 can be opened and its output read. (#318)
The daemon configuration is readable and editable from every client. GET /v1/config now serves every key in config.yaml — a dozen of them were invisible to every client — and PATCH /v1/config changes them. vincent config get and vincent config set do it from a script; the TUI’s daemon view opens a typed editor on the selected key. The daemon validates the whole candidate file before writing anything, edits the key in place so your comments and key order survive, and puts the result into force before it answers. Only listen needs a restart, and every surface says so. (#257)
Vincent tells you when a newer release exists, and can install it. The daemon asks GitHub once a day for the latest stable release and serves the answer; vincent doctor grows an UPDATE group. vincent update applies one and does only what is honest for the way you installed: a binary a package manager owns is never modified and that channel’s upgrade command is printed instead, while one vincent owns is downloaded, verified against the cosign signature and checksums the release notes already tell you to check by hand, and only then swapped. It is an opt-out (update.check: false makes no outbound request), it sends nothing identifying, and applying an update is never automatic. (#246)
The real usage quota, where the agent CLI reports one. The quota block used to be an observation of a wall vincent had already watched a task hit; now it carries a measurement of the window that is still open, with every window the source named. codex answers over codex app-server --stdio with nothing to install, and Claude Code reports through its status line once you let vincent draw it — i in the daemon view shows the exact JSON it would write to ~/.claude/settings.json, runs whatever status line you already had, and the same key puts the file back. Nothing here can fail a probe. (#315)
Assistant prose renders as Markdown, in both the task output pane and chats. Headings, lists, blockquotes, code and horizontal rules become terminal structure instead of literal syntax; tables are laid out to the pane and stacked as records when it is too narrow rather than clipped; links render as prose with a numbered reference block that resolves them, and fenced code shows its language and is tinted. ctrl+o swaps the rendered view for the stored Markdown and ctrl+y copies a message as Markdown, as plain text, or one code block on its own — over the system clipboard, or OSC 52 for SSH. Everything that is not assistant prose stays literal, because Markdown punctuation in a grep hit was never meant as formatting. (#293, #295, #296, #297)
A quiet output level, below compact. The verbosity cycle is four levels now, and quiet shows what the agent said and what went wrong and nothing it narrated about its own machinery — no tool calls, no outcomes, no unrecognized-line count. A two-sentence answer arrives as two sentences instead of buried in file reads and greps. A failure is never hidden by a display level. (#325)
Board groups fold. ← collapses the group the cursor is in and ← again the group around that; C and O do the whole table. Folds survive restarts, filters and reconnects, and can never hide work waiting on you — a collapsed group opens by itself the moment a task inside it needs an answer. (#241)
Enum task fields, and a default for every field type. A workflow’s fields: gains type: enum with its members declared in values:, which a regex pattern never could express to a client. New task opens a filterable list on enter and steps through the members with ←/→; multiple: true accepts more than one. Any field may now carry a default:, so a scripted vincent task add no longer fails for a value the workflow already knows. (#253)
A task-details tab inside the answer, repair and follow-up popups. ctrl+t switches a popup between its form and the same read-only task inspector the workspace shows, without disturbing the draft — so the prompt, the workflow, the step that is asking and the linked issue are all readable while you decide. Previously the only way to the task’s context was esc, which discarded a repair or follow-up draft outright. (#254)
Much more of what an agent run reported about itself. A Claude Code run now opens with a header naming the working directory and the tools it was given — the only place what could this agent actually reach is written down — and closes with its duration, turn count, refused tool calls and, when it is not the ordinary one, why it stopped: max_tokens is the difference between a model that finished and a model that ran out, and both read as a bare success before. A codex step now shows the agent’s running to-do list, what a command printed, file changes named by their paths, and MCP calls named by server and tool, plus its full cache and reasoning token spend. Because transcripts are normalized on read, both improve runs already on disk. (#270, #284)

Changed

Tasks start from the current base branch, not from whatever your last git pull left behind. Before a task’s worktree is created, vincent fetches its base branch from that branch’s own remote and cuts the task branch from the fetched commit. Nothing in your checkout moves. An unreachable remote is a warning, never a block, and fetch_base_branch: false turns it off. (#248)
The board stops spending a wide terminal on the title column, and a cell too long for its column wraps instead of vanishing. TITLE used to take every cell the fixed columns left — mostly trailing blanks — while STEP and STATUS were still being cut. The surplus now goes to those two, and TITLE, STATE, STEP and STATUS wrap across up to three lines of the same row. Narrow boards are unchanged. (#236)
The chat workspace reads as a conversation. Your own message is a right-aligned bubble that keeps its line breaks and is no longer cut off after six lines, the composer sits inside its own titled border, and the mouse wheel scrolls the conversation. The new-chat form uses the same filterable picker every other create form uses, scoped to the agents the daemon actually detected. (#325, #285, #303)
Archiving never deletes a branch vincent did not cut. A task created from a pull request is skipped by both branch-deletion settings — without this, archiving a task made from a merged pull request would have deleted a contributor’s head branch. (#264)

Fixed

A command step’s .Result was its stdout and its stderr, and was cut at the wrong bound. Both are fixed, and the second one mattered: a for_each: list longer than 4 KiB lost its last items and kept a half-written one, and a derived lane list gained an item for every incidental git or curl progress line. Check your own workflows for the other half of this — a prompt that quotes a command step’s .Result back to an agent used to receive that step’s stderr too, and now does not, so print what the prompt needs on stdout. What a human reads is unchanged. (#312, #314)
The chat workspace’s live output was raw agent JSON, and nothing turned it down. A running turn rendered every line as the CLI’s own dimmed stream-json, clipped at 200 characters, and a reconnect silently changed what was on screen. A chat’s output now goes through the same pane a task’s does, at the same verbosity level, with finished turns drawn from their transcripts. Several other chat defects went with it: a footer drawn off the bottom of the screen, a composer that hid what you typed, a turn that could hang forever on a cancel or a timeout, archived chats that never left the board, an event stream that crashed for everyone the first time any chat finished a turn, a new-chat form whose pickers never filled and whose keys leaked to the shell, and n on the chats board opening the new-task form. (#287, #280, #278, #304, #274)
Every text field ran off the right edge of its pane. A title, a branch, a filter, a palette query or a config value longer than its pane was drawn on one row past the edge, taking the cursor with it. Text fields now wrap and the form reflows around them. Editing a prompt: or a run: in the workflow editor was worse than that — the single-line field collapsed newlines, so committing it wrote a 60-line agent prompt back as one line — and those rows now open a full-pane multi-line editor. (#305, #326)
New task fell back to adhoc for a project whose default_workflow lives in its own .vincent/workflows/. The form loads its workflow catalog before a project is selected, so the first listing cannot contain a project-scoped workflow, and the row settled on adhoc and ignored the scoped listing that arrived a moment later. Since the form submits what it displays, a task created without noticing ran adhoc. (#263)
A for_each loop showed a denominator that was never its own. With no count:, the loop’s total fell through to the global loop.max_iterations ceiling, so a 3-item loop rendered loop 2/10. It now reads loop 2/3. Arrow keys in the step timeline could also leave no visible cursor, by walking onto attempts a fold had not drawn. (#318)
Agent-supplied text can no longer drive the terminal. Escape sequences and control characters in a tool result, a command’s output or an error message reached the output pane unfiltered, so an agent that emitted a screen-clear or a window-title sequence could act on your terminal. They are stripped before the pane measures or draws anything. The pane also measures terminal cells rather than runes now, so an emoji, a CJK glyph or a combining mark no longer over- or under-fills a line. (#293)
Crash recovery, diffs and branch cleanup read the commit a task was actually cut from. With a fetched base branch, GET /v1/tasks/{id}/diff had been measuring from the base branch by name, presenting every upstream commit the fetch brought in as the task’s own work, and delete_empty_branch_on_archive had stopped deleting anything for projects whose local base was behind its remote. (#248)

0.7.0 — A command line for every action, notifications and a full-screen task workspace

Released 2026-08-29.

Added

Every human action now has a command line. vincent task gained pause, resume, skip, approve, reject, retry, repair, archive and answer, and vincent project gained rm. The recovery half of the product used to be reachable from the TUI and from curl and nowhere else, so a board full of tasks blocked on an agent auth outage could not be cleared from a script. It can now. (#223)
A full-screen workspace for the task you are looking at. The home view is the board and nothing else; opening a task gives it the whole terminal, with Steps & Attempts, Task Details, Output and Diff tabs, an attempt picker on the output, a metadata sidebar, and timeline entries that jump straight to the output they describe. (#226)
The daemon can tell you it needs a human, with no client attached. A notify: block in config.yaml names the states you care about — blocked, awaiting_gate, awaiting_input, done — and a command to run when a task enters one; the event envelope arrives on that command’s stdin. Until now the only alert in vincent was a terminal bell that rang for awaiting_input alone, and only while a board was open. (#225)
vincent daemon logs and vincent task transcript. The two artifacts a failure is diagnosed from now have command lines, both with -f to follow. daemon logs reads the log file from disk and never contacts the daemon — which is the point rather than a shortcut, because the log is worth reading exactly when the daemon is not there to serve it. (#224)
A step can say what it is doing. vincent status "<message>" from inside a run: body, or from an agent that was asked for it, shows on the board on a wide terminal and on the attempt line in the task view while the step runs, and the last line written stays on the finished attempt as that step’s own account of how it went. A step that has been running for twenty-five minutes no longer has to be silent about it, and a failed attempt now also carries its result summary — the agent’s final message, or the tail of a command’s output. (#205)
Create a task from a GitHub issue. On a project whose origin points at github.com, vincent lists that repository’s issues and prefills a task from the one you pick: the title, the body with a link back to the issue, and any workflow-declared fields whose names match the issue’s labels, assignee, milestone or number. Everything lands in an ordinary editable row — nothing is locked, so a guess is reviewed before the task exists. (#204)
A per-task cost cap. max_task_cost_usd blocks a task with a new cost_limit reason at the next attempt boundary once its rolled-up spend crosses the ceiling. Cost was measured and displayed but never acted on, and an agent that loops productively — quick turns, modest output, no hang — trips neither the attempt timeout nor the transcript bound. Zero, the default, means no cap. (#201)
vincent workflow init and vincent workflow render. init writes a valid workflow into the right registry directory, optionally from one of the shipped examples, and refuses to damage anything already there. render dry-runs one: it executes every template a workflow file carries — prompts, run: bodies, checks, guards, loop items — against a synthetic or a real task, so a misspelled task field or step reference is caught in a second instead of costing a worktree, an admission slot and an agent run to find. (#203, #221)
vincent task add --fields-file reads the task field map from a JSON object in a file, or on stdin with -. That is the form a generator produces, and the one that carries newlines, quotes and spaces without the shell having to survive them first. Repeatable --field still combines with it and wins name by name. (#222)
Creating a task can be retried safely. Send an Idempotency-Key header on POST /v1/tasks and a re-send after a timeout returns the task the first request created, instead of making a second task, a second worktree and a second agent run. The same key with a different body is refused with a 409. Without the header nothing changes: two identical sends still make two tasks, which is what pressing enter twice means. (#218)
Vincent now says whether it has ever been tested against the agent CLI you have installed. Each adapter reports a version_verdict for your build — tested, untested or incompatible — alongside whether it can honor restricted on this machine, in vincent doctor, GET /v1/agents, GET /v1/info and the TUI’s daemon view. It is advisory and blocks nothing; untested is the normal answer a few weeks after any vincent release. (#220)
Every task records which workflow definition it actually ran — the scope that won (builtin, global, project or derived), the file it came from, and a SHA-256 of that file’s bytes as the registry loaded them. It is captured once at creation and never recomputed, so editing a workflow file later does not rewrite the history of the tasks that already ran it. (#217)
The update-workflows built-in, which brings a project’s own workflows up to date with the features a new vincent release added, and the prepare-release workflow this repository uses on itself. (#208)
“Why vincent is awesome” — ten linked articles on the ideas behind the product, plus per-page titles and descriptions, canonical URLs, social cards, a sitemap and a custom 404 across the documentation site. (#211)

Changed

vincent is MIT-licensed again. The separate commercial license is gone, from the repository, the documentation, the release archives and the package-manager metadata alike. (#202)
Releases ship unsigned by design, and a missing certificate can no longer destroy one. macOS code signing, notarization and a stapled vincent_*_darwin_universal.pkg are implemented and run whenever Developer ID certificates are configured; without them every signing step warns and the release publishes unsigned rather than failing at its first step. deb and rpm are unsigned by decision, and Windows Authenticode stays out of scope until a free-for-OSS certificate exists. cosign signatures and build provenance are unchanged, always present, and are not a substitute for either. macOS and Windows therefore prompt on first launch; the README and the platform pages say what to do about it. (#196, #210, #216)
A restricted step bound for an agent that cannot restrict on this machine is now refused when you create the task, not after it has spent a worktree, an admission and a retry. Cursor’s restricted mode needs its CLI sandbox, which exists on macOS and Linux only. Nothing is quietly downgraded to full-auto: a restricted mode that silently is not restricted is worse than none. (#220)
gosec runs on every build, inside the lint gate that already existed, so go run mage.go lint is still one command and still the one CI runs on all three platforms. Every current finding was read individually and either fixed or suppressed with its reason at the site. No runtime behaviour, file permission or directory permission changed. (#219)

Fixed

Crash recovery can no longer kill an unrelated process. The PID-reuse guard compared a wall-clock stamp taken by the daemon against kernel bookkeeping, accepting anything within five seconds as the same process, so in a narrow crash-and-reuse window a process that merely inherited the PID could be killed as an orphan. A spawn now journals a platform-native process identity beside the PID and recovery compares it exactly. (#195)
A question longer than 256 bytes can be answered. A task parked in awaiting_input on a long question refused every answer with a 400, then held its concurrency slot until it was cancelled or the 24-hour input timeout failed the step. The limit belonged to task fields, not to the agent’s own question text. (#198)
vincent doctor no longer times out instead of answering. The report asks the daemon to probe every agent CLI, and those probes carry their own deadlines — up to 145 seconds in total, cursor’s model catalog being an authenticated network call. The client gave up after ten, so on a machine where a probe was merely slow the command printed context deadline exceeded rather than the report that would have named the adapter holding it up. That call and a forced refresh of the agent picker now wait longer than the adapters can; every other call still gives up after ten seconds. (#223)
An earlier v0.7.0 tag was withdrawn and re-cut as this release. That build died at its first signing step and produced no archives, no deb or rpm, no attestations and no Homebrew, Scoop or WinGet metadata; the tag and its empty release were removed. (#213, #216)

0.6.0 — Finished-task operations, backups and durability

Released 2026-08-25.

Added

Follow-up runs on a finished task. A done or aborted task still owns its worktree and branch until you archive it. follow_up uses that window: give the task an agent prompt, a shell command or a workflow, and it runs on that task’s own branch with its own step run, transcript, events and cost accounting. It never changes the task’s verdict, and it is repeatable. Available as F in the TUI, POST /v1/tasks/{id}/follow_up, and vincent task follow-up. (#183)
Ad-hoc repair agents for a blocked task. R on a blocked task runs one throwaway agent in the task’s existing worktree with the blocked step’s failure context. It is the escape hatch for a block that retry, edit and skip cannot clear because the worktree itself is wrong. The repair decides nothing — the task returns to blocked at the same step — and it does not consume the retry budget. (#175)
vincent daemon backup and vincent daemon restore. One archive holds a consistent copy of the database, every transcript, config.yaml and your global workflows. The daemon takes it, so it is safe while tasks are running — unlike copying vincent.db by hand, which under WAL silently omits recent work. Restore runs against a stopped daemon and never deletes existing state. (#191)
Each agent’s usage window is visible. When an agent CLI stops because its quota for the window is spent, the board badges the agent with the reset time, the daemon view names it, and the new-task form warns before you queue more work against it. → marks a reset the CLI stated and ≈ one vincent estimated, so an estimate is never presented as a fact. Advisory only: nothing is refused. (#180)
retry_backoff paces step retries. A step or a workflow’s defaults may carry retry_backoff: 30s. The task returns to queued, gives up its concurrency slot so other work keeps running, and re-runs itself when the wait is over. The default is 0s, so existing workflows are unchanged. (#184)
The create-workflow built-in. A workflow whose deliverable is another workflow, so a first workflow does not have to be written by hand. Its agent step carries the published vincent Workflows authoring skill and writes into a live registry directory — the project’s .vincent/workflows, or the global one. (#171)
The database reports its own footprint. vincent doctor, the TUI daemon view and GET /v1/info now show the on-disk size including the WAL and SHM sidecars, row counts biggest-table-first, stored workflow bytes and how far the event history reaches. Purely informational — nothing prunes and no threshold exists. (#190)

Fixed

Crash recovery no longer re-queues a task it could not close. Recovery ran as two independent sweeps, so a failed step-run finalize was logged and walked past while the task went back to queued anyway — and the scheduler then started a second attempt against one the database still called running. Recovery is now atomic per task and fail-closed: an unreconcilable task is left as found and the daemon refuses to start. (#189)
A step whose output could not be captured is no longer reported as a success. An over-long output line stopped capture dead and left the step succeeded on its exit code alone. Long lines are now captured in bounded pieces that rejoin in order, and genuine evidence loss fails the attempt with transcript_io_error or agent_protocol_error instead. (#178)
Reconnecting to the event stream no longer stalls the daemon. A Last-Event-ID resume read the whole backlog into memory in one query, holding the daemon’s single SQLite connection for the length of the scan. The catch-up now reads in fixed pages; what a client receives is unchanged. (#188)
config.yaml is no longer created world-readable. It held 0644 on Linux and macOS, exposing literal environment.set values to any other local account. It is now 0600 in a 0700 directory, and every daemon start re-tightens an existing installation and says so. (#185)
A request body is now exactly one JSON document, and it is bounded. Trailing content was silently discarded, so a client that framed two documents into one request got a 201 for work vincent never saw. Trailing content is now 400, bodies are read under a fixed bound with a new 413, and a non-JSON Content-Type is 415. (#186)
Workflow loading is bounded and refuses non-regular files. A named pipe in a registered repository’s .vincent/workflows/ could park the loader in open() forever, and a symlink was followed out of the repository. Sources are now capped at 1 MiB and non-regular entries are listed as invalid with a reason. (#172)
A human action racing scheduler admission no longer returns 409. Cancelling or pausing a queued task at the moment the scheduler started it failed, though both actions are valid from running too. An action that loses its compare-and-swap is re-applied once from the state it lost to. (#176)
Simultaneous worktree creation in one project. Tasks admitted at the same moment no longer fail each other’s git worktree add; creation and cleanup are serialized per project. Fan-out was the reliable way to hit this. (#174)
vincent task ls reports each task’s branch, and documentation that promised branches are never deleted was corrected — archiving does delete a branch with no commits past its base. (#177)
The documentation site renders again. Jekyll’s Liquid parser was evaluating the Go-template expressions the reference pages exist to document. Template-carrying pages are wrapped in raw blocks, internal engineering records are excluded from the build, and the changelog and contributing pages are published and linked.

0.5.0 — Workflow authoring and structured task input

Released 2026-08-22.

Added

vincent Workflows agent skill. The portable authoring skill helps agents design cost-aware workflows, prefers deterministic commands and native control flow, and asks about human gates, interaction, acceptance checks, side effects and failure policy before generating a workflow. (#165)
Workflow-declared task fields. Workflows can define ordered inputs with labels, descriptions, required flags, typed values and optional validation patterns. The TUI pre-renders them while still accepting additional undeclared fields. (#163)

0.4.2 — Release verification hardening

RPM verification now normalizes payload paths before extraction, avoiding GNU cpio warning exits while keeping validation isolated. (#161)

0.4.1 — Package validation fixes

Release package verification was hardened so provenance generation and Linux, macOS and Windows smoke tests complete correctly for published packages. (#159)

0.4.0 — Better TUI workflows and broader distribution

Roomier responsive TUI workflows added guided task creation plus persistent navigation for Projects and Workflows. (#153)
More installation channels added WinGet, Scoop, mise, deb and rpm distribution with checksummed native release packages. (#158)

0.3.0 — Workflow language and task operations

Reusable workflow composition with type: include.
Platform restrictions and interactive-agent capability gating.
Configurable task-board grouping, bulk actions and file-grouped diffs.
Workflow graph visualization for structured control flow.
Loops, breaks, conditions and allow_failure for data-driven execution.
Parallel sub-steps and fan-out child tasks with isolated worktrees and merge-back.

Older releases

Earlier releases are available in the canonical changelog and on GitHub Releases. This page is intentionally edited for humans; the canonical file remains complete and machine-maintained.