Changelog

What shipped, newest first. Every release is on the downloads page with its checksum.

v1.3.2Knowledge moves now check every entry before deleting anything, mistyped or risky commands are refused instead of quietly doing more than you asked, and runs survive network blips and stuck services.
  • AddedDeleting a memory or document can be made safe against concurrent edits. Before, toryo-memory forget and toryo-library remove deleted the entry even if someone had changed it since you looked. Now both accept --if-unchanged <updatedAt> and delete only while the entry is still that version. If it has changed, they exit 1.
  • AddedBatch memory imports can skip stray fields. Before, toryo-memory remember-batch refused a whole line that carried an unknown key, and it did not work against a team gateway. Now --drop-unknown-fields drops those keys and keeps the rest, and the command works on a team gateway.
  • Addedforeman doctor finds leftover files from another build. Before, files left beside the toryo binary by a different build went unnoticed. Now the assets-current check names them, and toryo update fixes them.
  • AddedSequence steps can retry through network blips. Before, a command that hit a passing network error failed its step. Now an exec step can set retry: transient to re-run that command up to three times. Code-task uses it for its git and GitHub reads and pushes.
  • AddedHuman gates can label their options. Before, a gate could not mark an option it does nothing with. Now a gate can declare optionLabels, and an option the gate does not act on is marked as such and never recommended.
  • ChangedCode-task stops sending work back for another pass once its attempts run out. Before, a base-branch update or integration review that asked for another implement pass could repeat without limit. Now each of those passes uses up an attempt, and the run pauses at readiness_blocked once the budget is spent. A worker that has been sent back on the same question twice is told to stop asking it.
  • ChangedOn a team gateway, members manage only their own memories. Before, a member seat could pin, unpin or supersede anyone's memories. Now members can do this only to their own.
  • ChangedMistyped flags are refused. Before, toryo knowledge export, toryo knowledge import, toryo-library import and restamp ignored unknown or malformed flags, and an empty --projects list exported everything. Now these commands exit 64 and run nothing.
  • ChangedAgents can run fewer commands that overwrite data. Before, the MCP toryo_run tool let agents run some overwriting commands and flags. Now more of them are withheld, and each refusal names the terminal command to run yourself.
  • Changedtoryo-sequence retry refuses archived runs. Before, it would try to retry one. Now it exits 68, and when a run cancelled itself it tells you why.
  • Changedtoryo settings get refuses a settings file it cannot parse. Before, it printed defaults as if they were your settings. Now it reports the problem. Settings are also written to disk durably, so a crash mid-write no longer loses them.
  • ChangedThe console no longer locks out a machine over a revoked team license. Before, a revoked team default could lock you out even with a valid personal license. Now the console follows the machine's own license, and work outside any team counts against your local license.
  • ChangedCode-task's acceptance check grades more accurately. Before, a test file that failed only on a per-test timeout counted as failed, and a search pattern that matched no files passed. Now timed-out files are re-run, and a search that matches nothing is refused.
  • FixedKnowledge moves no longer lose late changes. Before, an entry written or corrected after export could be deleted from the source, and a project could be pointed at the new store before every entry had moved. Now those entries are kept, and the project moves only after the source holds none of its entries.
  • FixedHosting moves no longer get stuck. Before, a move could stay held for a team that had left its gateway, or wait on a lock whose process had died. Now move-hosting releases that hold and takes over the stale lock.
  • Fixedtoryo runtime refresh updates an outdated browser. Before, it skipped Chromium whenever Node was already current. Now it re-downloads a stale Chromium either way.
  • Fixedrestamp handles a store that was never created. Before, it exited 65. Now it reports zero entries.
  • FixedSession analysis and knowledge setup land in the right place. Before, session analysis could file results outside the project's team, and provisioning could skip your default workspace when TORYO_CONTEXT named another one. Now analysis files under the project's team, and provisioning always migrates the default workspace.
  • FixedThe embedded database no longer throws intermittent errors when several tools use it at once. Before, their queries could interleave and fail. Now each tool's queries stay together. Stopping and checking the embedded database also no longer mistakes an unrelated process for it.
  • Fixedtoryo setup no longer starts services on top of the old ones. Before, it could load the new service manager while the old one was still exiting. Now it waits for the old one to stop first.
  • FixedServices recover cleanly from being stuck. Before, a service whose port was taken kept its lock and database, and a stuck dispatch service ignored a stop request. Now the service releases both and says why, and a stuck dispatch service is reported and stops on request.
  • FixedRestarting everything brings everything back. Before, a full restart could leave some services down, and the monitor did not say why it found the system unhealthy. Now the missing services are restarted and the reason is logged.
  • FixedSettings changed before dispatch first starts are kept. Before, they could be lost. Now they apply.
  • FixedA run that briefly cannot read its project now waits. Before, it failed or was picked up again on every check. Now it is deferred, and a cancel is no longer undone by a late status update.
  • FixedCrashed workers say why they crashed. Before, the reason could be lost, including for a Claude session that ended before its first turn, and Cursor and Copilot API errors were not recognised. Now the crash reason is kept and those errors are named.
  • FixedWorkers are no longer blocked from harmless commands. Before, the guard against skipped checks blocked things like heredocs, running tsc through a package script, and reading named files. Now those run.
  • FixedWorkers cannot merge pull requests, cut releases, publish or deploy. Before, nothing stopped them. Now those actions are refused.
  • FixedCleanup leaves live work alone. Before, it could remove running jobs, running sequence runs or follow-ups not yet filed. Now it spares them.
  • FixedThe console shows library documents safely and names projects clearly. Before, library markdown was rendered unsafely and projects beside the workspace column were hard to read. Now markdown is rendered safely and projects show by name.
v1.3.1Leaving or switching a team gateway now copies the team's knowledge, deleted knowledge can be restored, and research and review runs let you pick the agent and effort.
  • AddedLeaving a team gateway now copies the team down to each seat. Before, leaving a gateway left the team's knowledge behind on it. Now the old gateway stays read-only for 14 days while each seat copies it, and toryo license status shows the progress.
  • AddedSwitching a team to a new gateway now copies the team first. Before, seats moved to the new gateway without the team's knowledge. Now an owner's machine copies the team onto the new gateway, and seats move only once that copy is verified.
  • AddedResearch and review runs let you pick the agent and effort. Before, research-task and review-task gave you no choice of model or effort. Now both accept harness:model and effort. research-task also files its results under its own project, so its projectId input is gone.
  • AddedDeleted knowledge can be restored. Before, deleting a memory or document was final. Now toryo-memory restore and toryo-library restore bring it back. On a team gateway, members can now edit or delete only their own entries.
  • Addedtoryo-library drain-global moves documents that are not tied to any project out of a team store. Before, only memories could be moved this way, with toryo-memory drain-global. Now documents can too.
  • AddedCommands run against a team gateway can use files on your machine. Before, --body-file and --out did not work there, and neither did toryo-project resolve or migrate. Now they all work on a team gateway.
  • Addedtoryo setup --keep-targets keeps the database and Ollama you already have recorded. Before, setup gave you no flag to say so explicitly.
  • AddedBackground services work with an external database. Before, they did not run when TORYO_DATABASE_MODE=external was set. Now they do.
  • ChangedCode-task limits how often it retries failing checks. Before, a run could keep retrying failing checks past its budget, and your own send-backs and grants counted against that budget. Now failing-check retries stop at maxImplementAttempts, and send-backs and grants no longer count. Run toryo sequence install-shipped to get the updated code-task.
  • Changedtoryo project remove shows what it will remove and asks before acting. Before, it acted immediately. Now it previews and asks you to confirm. Pass --yes when there is no terminal, or --dry-run to get the preview as JSON. A removed project is kept as a removed record until you pass --purge, and --no-cleanup now stays in effect.
  • ChangedThe orphan sweep is narrower and reports failures. Before, it could act on projects you had not removed, and it exited 0 even when it declined, could not read its state or failed to delete. Now it acts only on removed projects and exits 68 when it declines, 65 when it cannot read its state and 1 when a delete fails.
  • Changedtoryo update, and changing the database or Ollama with settings set, now restart services. Before, running services kept the old version or settings. Now they restart. These commands exit 68 while work is running (--force overrides) and 69 if the restart fails.
  • Changedtoryo setup keeps your database and Ollama. Before, running setup again could replace them. Now it keeps them, and it stops if your recorded Docker database is not running.
  • Changedtoryo-scheduler delete refuses to delete a schedule while one of its runs is live. Before, the delete went ahead. Now it exits 68, and --force overrides.
  • ChangedSchedules have readable names. Before, schedule listings gave you nothing readable to tell schedules apart. Now each schedule prints a readable label.
  • ChangedA sequence run that cannot read its project now pauses. Before, the run failed. Now it retries, then pauses instead of failing.
  • ChangedAgents can run fewer destructive commands. Before, the MCP toryo_run tool let agents run some destructive commands. Now more of them are withheld.
  • ChangedKnowledge bundles record who wrote each entry. Before, exported bundles did not carry authors. Now they do, in a new bundle format. Bundles in the old format still import.
  • FixedA move no longer deletes source entries that changed after export. Before, an entry edited after export could be deleted from the source. Now changed entries are kept and named, and the move exits 1.
  • FixedHosting moves are all-or-nothing. Before, a move could stop partway, run alongside in-flight work, and leave project settings behind. Now it either finishes completely or changes nothing. It also waits for in-flight work and carries project settings across.
  • FixedFiles toryo cannot read are no longer overwritten. Before, an unreadable file could be replaced. Now the operation stops instead. For license writes, --replace-unreadable lets you overwrite one on purpose.
  • Fixedtoryo knowledge move-runtime refreshes outdated entries on the target. Before, it could leave them stale. Now it updates them.
  • Fixeddrain-global keeps entries whose personal copy was deleted. Before, it dropped them. Now it keeps them.
  • FixedMemory decay leaves memories that are still awaiting approval alone. Before, decay could affect them. Now it skips them.
  • FixedThe service manager no longer stops busy services. Before, it could stop the dispatch service or an embedded database server in the middle of work. Now it leaves them running.
  • FixedThe cleanup service spares work it cannot prove has finished. Before, it could remove that work. Now it leaves it alone.
  • FixedA code-task acceptance command that times out keeps its output. Before, that output was lost. Now it is kept.
  • FixedCode-task reviews every file of a large diff. Before, a review could skip files when the diff was large. Now every file is reviewed.
  • FixedRuns started with scheduler fire survive orphan cleanup. Before, cleanup could cut them off. Now they keep running.
  • Fixedideas list --project finds the project in the workspace you chose. Before, it ignored --context when looking up the project. Now it looks within that workspace.
v1.3.0Teams share a brain, one machine holds your personal and team licenses side by side, and runs record what they cost.
  • AddedTeams share a brain. A team's memories, documents, shared projects and code index can live on a gateway, hosted by toryo or, on Enterprise, by the team itself. Your machine computes embeddings, so the gateway runs no model. Personal knowledge stays on your machine.
  • AddedOne machine holds your personal license and any team licenses side by side. Runs, jobs, schedules and ideas record which one they belong to. Work outside a team project, and knowledge not tied to any project, stays on your machine, with or without a license. Commands follow the project you are in; TORYO_CONTEXT or --context overrides that.
  • AddedProjects can be shared with a team, identified by git remote and subpath. toryo project share moves a project and its knowledge into a team, and toryo project bind --auto links a checkout to the team's matching projects. Seats are owners, admins or members; only owners and admins change shared projects.
  • Addedtoryo knowledge export and import move memories and documents between your machine and a team. Moves go one way, into a team, except that an all-local team's knowledge can come back. toryo license adopt brings an unlicensed install's knowledge under your license.
  • AddedThe Enterprise plan, with self-hosting. The gateway image and Docker Compose bundle ship with each release, linked from the portal's new Self-hosting page. The portal also gains Projects and Knowledge pages for hosted teams.
  • AddedCode-task routes by the kind of work. The planner classes a plan as mechanical, standard or design, and a project can set which agent and effort each class uses. The plan gate shows the route, a cost estimate and each agent's quota before you approve. A spend guard pauses a run that passes its ceiling, and a job whose agent is out of quota moves to an allowed fallback.
  • AddedRuns record what they cost: agent, model, tokens, turns and tool use, rolled up in run listings and status.
  • AddedCode search returns a ranked repository map within a size budget, matches full text over symbol names and doc comments, and can answer from a worktree, uncommitted edits included, without rebuilding the index.
  • AddedSequence gates can ask for structured input through a form, with a live preview of its effect.
  • AddedThe console shows personal and team work side by side, filterable by either, and local projects can be shared to a team from it.
  • ChangedUpgrading: update the gateway before its seats. Every seat and self-hosted gateway on a team must run 1.3.0 before that team moves to Enterprise. Upgrading moves no existing data: knowledge not tied to a project that already sits in a team store stays there until toryo-memory drain-global is run under that team, and projects created in a team stay in it.
  • ChangedSelf-hosting requires the Enterprise plan. A team already self-hosting on Team keeps working.
  • ChangedSelf-hosted gateways: TORYO_GATEWAY_CLI_CONCURRENCY and BRAIN_LICENSE_PUBLIC_KEY are retired, TORYO_GATEWAY_DB_POOL_SIZE now applies per knowledge database, and the packaged server refuses to start with authentication disabled.
  • ChangedThe MCP sequence status tool returns a summary by default; pass detail: 'full' for the whole run. maxSubagents now also limits Claude's workflow agents.
  • FixedA code-task's acceptance step reinstalls dependencies first, so a dependency added on the branch no longer fails as missing.
  • Fixedtoryo setup, update and knowledge move-runtime always migrate this machine's own stores.
  • FixedSeveral reliability fixes in the cleanup service, scheduler and foreman check.
v1.2.1A run warns about sensitive paths only when it could actually edit your project, and the download page is grouped by operating system.
  • FixedA run only warns about sensitive paths it has not seen when it could actually edit your project. Before, if your project had sensitive paths registered, runs of a sequence that takes no sensitive-path input warned about them every time, including research runs, which only write into their own run folder and never touch the project. Now the warning appears only when at least one step of the sequence may write to the project. The decision is based on how the sequence is written, so a run that stays quiet has not been proven unable to edit anything.
  • FixedThe download page is grouped by operating system. Before, installers were listed in an order that put the Mac builds, the most common download, below every Linux and Windows installer. The page now leads with macOS, Apple Silicon first and then Intel, followed by the Windows preview. Linux comes last in a section you can expand, grouped by architecture with the self-updating AppImage first. Each Linux link now names its architecture, so a screen reader no longer reads out the same three package names twice without telling them apart.
v1.2.0The console runs on Windows, Linux has real packages, and a Claude session can outlive a single turn and a single job.
  • AddedThe console runs on Windows. Before, toryo was a Mac app with a Linux deb, and a Windows machine had no way in. On first run the console now sets up WSL2, installs the Linux backend inside it, and drives it from Windows, so every command it runs goes through WSL once a distro is found. The window paints before any WSL work starts, so a slow distro start shows progress instead of a blank screen. Opening a terminal session or an external tool works on Windows too, and setup steps you ticked run without flashing a console window or stopping at a prompt. The Windows installer ships as an unsigned preview, outside the update channel: Windows warns about an unknown publisher, and you update by downloading the next installer. Failures during first-run setup, WSL and licensing are reported back to us, because a machine nobody on the team can reach would otherwise fail unseen. The docs explain the route the CLI takes through Ubuntu.
  • AddedLinux has real packages. Before, the only Linux build was a deb. The console now also ships as an AppImage that updates itself and as an rpm for Fedora. The deb is installed and exercised on each supported distro before release, and the Linux and Windows support claims are checked on those platforms rather than assumed from a Mac. The marketing site and the docs were corrected wherever they overstated or misstated which platforms toryo supports.
  • AddedA Claude session can outlive a single turn and a single job. Before, every turn and every job started Claude from nothing and rebuilt its context from scratch. A worker can now keep one Claude session open across several turns, and a later job can pick up a session an earlier job left behind, so the context is kept instead of paid for again.
  • AddedThe console reads jobs directly from dispatch instead of launching a command for each read. Job reads, job writes and the live event stream now go over a local HTTP connection that requires the dispatch token, so the console does less work per refresh and the stream is no longer open to anything on the machine. The token is always read from your home folder whatever custom toryo home you have set, so the console and dispatch can no longer disagree about which token is in force.
  • AddedDispatch can drain before an update. Before, an update could restart a service underneath a job that was still running. Dispatch can now pause admission so no new jobs start while in-flight work finishes, and updates use that pause, so they never restart a service under a running job. The console shows the pause as a banner on the Sequence screen, next to the runs that are waiting on it.
  • AddedEach agent has a minimum version. Before, a job on an agent too old to support what toryo asks of it would start and then fail partway through. A Claude job on Claude Code older than 2.1.0 is now refused before it starts, and Codex, Copilot and Cursor each carry a minimum version of their own.
  • AddedIdeas can be pinned, grouped by the kind of work, and reviewed for quality. Pinning keeps an idea in view: there is a CLI verb pair and a pinned-only filter, and the console pins or unpins a single row or a whole selection. The backlog used to be grouped by subsystem; it is now grouped by kinds of work drawn from the ideas themselves, and the Subsystem view is reduced to counts and one distribution band. A quality review runs over the registry and both proposes new ideas and closes finished ones. An idea is now flagged when the files it concerns change, rather than after it has sat idle for a set number of days, and it records which run filed it. Its score reflects how much of the code its writer actually read. Nightly verification covers up to 100 ideas and reports any it could not reach, a quarter of each night's budget goes to the oldest unverified ideas, and a selection in the console becomes the batch the next verification takes. Quadrant rank is now bounded, and the new impact ceiling was applied retroactively to the 81 ideas scored under the old one.
  • AddedMemory is recalled where it is used. Before, a session started with a fixed block of memories. It now starts with a recall built from a query that combines several sources, ranked by importance, with each memory included whole. A code-task's implement step recalls memory as well, and rating what it recalled feeds back into future recalls. A memory that has been superseded no longer turns up in recall, and memories can now be written in bulk from a file.
  • AddedA code-task prepares its worktree the way your project does. Before, the worktree was set up the same way whatever the repository used, and it could drift behind its base while a run was underway. Each project now stores its own dependency install command, detected from the repository, and the worktree is installed with it. Right before the worker starts, the worktree is brought up to date with its base, and a base that moved during the run is reconciled. The plan's acceptance commands run as a proper step on a worker, and the reconciliation gate decides from structured check results rather than scanning prose for a success line. The review verdict names its biggest gap, a run that uses up its attempts is escalated to you, and a job held back for a conflict names the overlapping paths. Workers are told to treat a subagent's report as a claim to check, not a fact.
  • AddedSequences have more to build with. A single setup step can now run an ordered list of labelled commands, a step can mark its output as temporary, and a run carries a keyed cache of observations stamped with the host that made them. Every step now reports a duration, including setup and transform steps that used to have none. Research runs capture their reasoning chains and reflect on them, and reflection works from measured facts about the run and from lessons recorded while it ran. Gate picks travel in a structured field. When a model writes an artifact that fails to render, the error now shows the shape it was supposed to have.
  • AddedThe console shows more of what the machine is doing. Runs that are parked waiting on you stay pinned in the Sequence runs table and can be answered in place. The worker feed shows subagents with their tool calls nested beneath them. The Ideas composer scrolls while its footer stays put. Your saved clock format is honored, and a single notification subject pings you at most once an hour. Both of Cursor's Plan and Usage meters are reported.
  • AddedOpus 5 and Sonnet 5 are priced. Cache writes are now priced by how long they are kept, and the console reads the live model catalog rather than a list fixed at build time, so a new model shows up without a release.
  • AddedLicensing: checkout accepts Stripe promotion codes, a trial is named after the email it was started with, and a trial can be extended on request.
  • ChangedCode search is ranked and keeps itself fresh. Before, results were unranked, output could be unbounded, and the index was only rebuilt once a week, so search could miss a week of changes. Search now ranks its results, caps its output, and checks freshness on every query.
  • Changedtoryo foreman check is lighter. It used to probe the database schema on every call, and since the console polls it and every health check starts one, that cost added up. A long-running service now watches for schema drift and check reads its report. Drift is reported on check, up, restart, and when the watcher starts.
  • ChangedA code-task in your repository is no longer steered toward toryo's own tooling. The shipped prompts used to mention toryo and bun, which nudged workers toward tools your project may not use. Those mentions are gone.
  • FixedDispatch no longer deadlocks or loses worker slots. Two running jobs with overlapping claims could wait on each other forever; claims are now taken in a fixed order. Overlapping sequence runs are serialized for the life of the run. A slot whose worker died without reporting is reclaimed, and its result is recovered. Draining no longer stops the heartbeat, so dispatch does not look dead while it finishes work. Agent version checks give up after 3 seconds in total, and when dispatch dies, every process a setup step started is cleaned up with it.
  • FixedThe scheduler and the cleanup service stop acting on stale state. A leftover command run used to pause system schedules; the scheduler now cleans up the leftover and carries on. The cleanup service honors a saved dry-run setting instead of acting anyway.
  • FixedUpdates restart services one at a time and report the problems they worked around. When the update check fails it now says why, and the console states which version is being replaced by which.
  • FixedKnowledge storage is sturdier. An interrupted library upgrade used to leave the library stuck; it now recovers on the next start. Memory decay applies its cutoffs correctly across time zones. Control characters are stripped from knowledge text when it is written and when it is shown. A degraded embedding is reported rather than passed off as normal, and the embedding timeout allows for a model loading cold and is reported as a timeout when it fires.
  • FixedA long sequence run no longer grows without limit. Its recorded state kept every string of superseded history and every line of the review baseline; both are now capped. A parked gate is acknowledged against the version of the sequence it was pinned to, --re-pin decides by comparing the actual step graphs, and a cancelled run can be recovered. Acknowledging a gate now waits, with a limit, for its notification to settle, and logs when it does.
  • FixedRefreshing your checkout after a merge is no longer refused just because the checkout has untracked files.
  • FixedConsole layout and state fixes. A pinned run no longer looks the same as a selected one, the waiting-on-you badge sits under the run status, and a long question stays inside its box. Waiting rows are quieter, and runs are no longer pinned automatically. Notifications asking you to acknowledge something that has since been handled are cleared when the console opens. The Ideas drift states have clearer labels, and both grouped panes show a real loading state instead of looking empty.
  • FixedIdea triage reports when scoring fails, and a rescore goes back to exactly the ideas that failed rather than all of them. A correction to a resolved idea is filed apart from whatever it leaves open. The service check now reports on every agent you have enabled, not only some of them.
v1.1.0Cursor is toryo's fourth agent, you can name any model on any agent, and library search answers with sections instead of whole documents.
  • AddedCursor is toryo's fourth agent. Before, you could put real work on Claude, Codex or Copilot and nothing else. Cursor now appears everywhere the other three do: each of a code-task's five roles, sequence steps, jobs you file yourself, the console's pickers and its own toggle. The service check reports Cursor at recommended severity, so a machine that only runs Claude is not called broken, and it finds Cursor under either name an install uses and reports the installed version, because Cursor updates itself and every claim toryo makes is scoped to a build. A Cursor session gets the same resolved rules stack every other agent gets, delivered on the prompt itself since Cursor has no separate place to put it, and the delivery report now tells you when a rules file was only partly carried because the stack outgrew what one command can hold. Cursor is also the first non-Claude agent that enforces tool policy natively rather than through emulation, and nothing is written into the repository under review.
  • AddedCursor and Copilot both report usage now. Cursor shows included spend against your plan's limit, resetting at the end of the billing cycle, plus an on-demand meter and headroom for an account with a spend cap. Cursor publishes no personal usage API, so this reads the same endpoint Cursor's own dashboard calls with your session token, and anything toryo does not recognise is reported as a failed reading with a reason instead of an invented number. Copilot stops being meterless: your seat pool becomes an included meter and an AI credits budget becomes an on-demand one. That matters beyond the screen, because an agent with no meters at all was treated as unknown, so Copilot had been contributing nothing to the decision about whether a worker may start, even after a full day of real Copilot work. A saturated Cursor or Copilot meter now holds its own jobs the way a saturated Claude meter does. Copilot's meter changed name, so if you had pinned that chip in Settings, pin it again.
  • AddedYou can name any model, on any agent. Before, each agent accepted only the models toryo had been released with, so a model your vendor shipped this morning was unusable until toryo cut a release. Every model field now accepts any non-empty name, and the agent itself validates it and answers an unknown one by naming its own catalogue. Only an empty value is refused, since that is a variable nobody set. The curated lists survive as the offered sets that still drive every picker. Claude Fable 5.1 gets its own pricing rather than sharing Fable 5's, with the same input and output rates but a much cheaper cache read, which dominates an agentic session. A model with no published rate is now priced at the agent's rate ceiling rather than at nothing, so every session carries a cost and never a zero you would read as a free run. New toryo foreman models asks each installed agent what it can run and names the drift in both directions. Two places stay curated on purpose: shell completion and the console's task form.
  • AddedPicking an agent and model is two dropdowns instead of one long list. A per-role picker used to render every agent-and-model combination in a single list, five times over. You now pick the agent, then the model, and a form with several roles grows an "All roles" setter above them while each role stays individually overridable. Re-running an old run that names a model since retired shows a disabled entry marked unavailable rather than a blank select over a value the form would still submit.
  • AddedAn idea's impact is read from the idea. It used to be arithmetic over how often the idea had been re-filed and how recently, which never read a word of what the idea said. On a live registry that put 492 of 618 scored ideas inside one narrow band with a ceiling of 0.6, so the axis ordered nothing. Triage now estimates impact the way it already estimated effort, by reading the idea's text against a five-band rubric, filled once and never re-scored over your own judgment. toryo ideas triage --rescore-impact is a one-time backfill of what the arithmetic wrote, and it refuses to touch a score you set yourself. The number is now a property of the idea rather than of the clock: the same idea scored on two different nights gets the same value, and the console's impact-per-effort ordering starts working.
  • AddedLibrary search answers with sections instead of whole documents. Documents are still the unit you read, edit and export, but a search now returns the strongest section per document with its heading path, its position and a snippet, and leaves out the rest of the body, so a search answer stops filling your context with documents you did not ask to read. Fetch the whole source with get when you want it. Your existing library keeps answering while it upgrades, and re-embedding replaces the placeholder sections with real ones.
  • AddedYou can ask how the last week went. toryo dispatch history --since reports how jobs ended, a reliability ratio, recovery attempts, stalled and refused failures, policy denials, and how much of the log it could actually read. toryo sequence history --since reports terminal runs, how many repeated, and the executions beyond the first. The two are deliberately separate and their overlapping numbers should not be added together, because sequences own retries and resumes while dispatch owns in-place recovery. The console draws both as one collapsed signals panel and marks only the affected half unavailable when an older install lacks one of the commands. A job refused for a missing capability now has its own reason, so it stops looking like a failure to start.
  • AddedA service can say it is starting. Before, a service that had taken its lock but not yet reported a healthy tick looked exactly like one nobody had launched, and the console drew both as a red dot. Each service now reports running, starting, unhealthy or down. Bringing services up no longer bounces one that is mid-launch: it waits out that service's own window and reports it as adopted, which matters because starting a service kills off strays by signalling every matching process. The console polls once a second while anything is converging, draws a starting service yellow, and keeps Refresh usable. Exit codes are unchanged.
  • AddedWaiting for services to come up is much cheaper. Waiting used to spawn a full check every half second, which cost around 110 milliseconds when idle and 290 under load, for the whole of a startup nobody could see into. Every service now answers a cheap health route in about two tenths of a millisecond. It is an extra tier and not a replacement: the cheap route can only shorten a wait, the full check alone decides that a service is green, and a service answering its route while its work loop is wedged stays red exactly as before.
  • AddedThe console keeps you on the screen the work is on. Ideas shows the verification runs it started and, for each finished one, how many ideas were closed, proposed, unresolved and failed, marks the covered rows as verifying and leaves them out of the next sweep, rather than showing one toast and leaving a long paid run visible only from the Sequence screen. The worker feed collapses capability notices into one neutral summary that separates emulated support from a capability the job never used, with the full event history one click away. Re-pin is now offered on a paused run as well as a failed one, and it tries without force first, so you only get a confirmation step when the run actually refuses, and that refusal is the warning you read.
  • Addedtoryo mcp list --json now includes a one-click Cursor install link. Cursor is the only client toryo targets that publishes one, so anything building an "Add to Cursor" button no longer has to know the format. It is emitted whether or not this machine has Cursor. One caveat: the link describes this machine's own entry, so a link generated from a source checkout names that checkout and installs nothing useful anywhere else.
  • AddedOn the hosted and public side: the portal has a signed-in sidebar, the tenant console in admin is reshaped, and each seat machine now reports the toryo version it has installed, so a machine running behind is visible rather than guessed at. The marketing site names the coding agents toryo supports and collapses its changelog by release, and the docs site documents the Cursor usage gauges.
  • ChangedWhich project a knowledge call is about now travels on the call. The environment variable and request header that used to pin a project are removed, and setting either does nothing. That pin was never validated, so a stale or mistyped value quietly returned nothing on reads and filed writes under an id naming no project, and it silently changed what a write meant, since remembering defaulted to project scope when pinned and global when not. Reads now take an optional project as a UUID or a slug, and every answer states the scope it actually ran at, so an unscoped answer is visible rather than merely short. Code search requires a project, because there is no global index to fall back to. Writes require a scope, and a project alongside project scope, with no default either way. A project reference that resolves to nothing is an error naming it, never a silent fall back to global. Claude Desktop, which had no working directory to infer from and so could reach nothing but global, works now. A worker is told its project directly, since it runs in a workspace no registered project contains. The control-plane tools lose their working-directory fallback in the same move: leaving the project out means every project on a list command, and a refusal when filing a job.
  • ChangedA reviewer grades the work, not the builder's account of it. The review used to be handed the implementer's freeform hand-off, which mixes checkable facts about which gates ran with the implementer's own rationale for the change. The hand-off now splits in two: the reviewer sees only which gate commands ran and what they reported, while the hand-off itself keeps its name and its meaning and still reaches you, the merge gate and the run record.
  • ChangedAdding or updating a library document returns a receipt rather than the whole stored entry. It names what was stored: the id, title, scope, project, category, format and the body's size. Pass the id to get when you want the body back. What is stored is unchanged, and the complete body is saved before the receipt is written.
  • ChangedA worker only warns about degraded capabilities its own job could actually hit. It used to announce the agent's entire list of non-native features at startup, including ones the job had no way to request.
  • FixedA read-only Cursor session both runs and stays read-only. Two faults, in opposite directions. A read-only session was started without the flag that unlocks its tool policy, on the reasoning that the deny list decides everything anyway, which is true of the flag alone and false beside the configuration toryo ships with it: the allowlist is deliberately empty, so every shell and tool call was refused. On a planner job, listing a directory was refused while matching no deny rule. The session did not fail. It fell back to reading and grepping and produced a plan it could not verify, which is the quiet version of the bug, and Cursor was usable only for implementing. Meanwhile the deny list named tools and never covered a shell command that wrote without naming one, so a redirection from a reviewer created a file. Writes by redirection are now judged by where they land: refused inside the repository under review, allowed outside it, which is what read-only actually means, and it matters because a planner has to write its own artifacts and redirection is its only route. Destructive commands are refused everywhere, a target that cannot be read fails closed, and a guard that crashes blocks rather than waving the command through. Verified against the live agent: read commands ran, and a redirection, a checkout and a remove were each refused with nothing created.
  • Fixedtoryo foreman restart dispatch --force recovers a dispatch that has stopped ticking. The safety gate looked only at how many jobs were in flight, so a wedged dispatch whose frozen job rows can never drain vetoed the very restart that would clear them. On 2 September that cost two healthy services: dispatch reported its work loop over seven minutes stale against a fifteen second threshold with three jobs in flight, the gate declined, the stop failed, and only killing the process by hand cleared it. The gate now also reads how long since the last tick, which was already in the same health answer. Jobs in flight count as live work only while the loop is progressing; far past its own threshold, that count is a frozen snapshot that can never fall. Every uncertainty still declines, including an unreadable check, a missing process, an unknown count and a service that has never ticked, and a dispatch that is genuinely draining still declines too.
  • FixedA run started with --working-dir carries its project. A project was stamped only from --project, so a run started inside a registered repository was created with no project at all, and every worker it dispatched got an unpinned knowledge server: project-scoped remembering, code search and rules were all refused for the whole run, while the reflection step still reported success. The working directory is now matched against your registered projects when the run is created, which is the one moment the repository path is available. An explicit --project still wins, a registry failure leaves the run unpinned rather than blocking it, and both outcomes are printed, because the whole cost of this was its silence. The same project also supplies the folder searched for sequence files, so a run inside a project that has forked a sequence now uses that fork.
  • FixedA required hand-off file is checked by the worker that wrote it. The check could only confirm the file existed, so a hand-off that was malformed, wrapped in prose or missing a field passed the worker and failed a later step. Retrying re-ran the wrong half, so that later step re-read the same bad file forever and the only way out was writing the file by hand. A code-task's three hand-offs are now checked against their shape at the point of writing, so a bad one fails the worker that can rewrite it, and the error names the file and where parsing broke without echoing its contents.
  • FixedThe memory block injected into a session says what it left out. Recalled project memories were filtered by an importance floor but shown under a heading that read as the complete list, so there was no way to tell a partial block from a whole one. It now names how many were dropped, says the floor is why, and points at the recall tool for the rest.
  • FixedA failed rescore no longer trades a real impact score back for arithmetic. The impact fill fell back to the old recurrence maths whenever the model did not return a row, including when the row already had a score, so a batch that timed out on every retry was counted and reported as rescored. The fallback now only applies where nothing is stored, so a rescore whose model was unavailable changes nothing.
  • FixedA database read error keeps its cause instead of being flattened into a generic message on the way out, which is exactly where the message matters.
v1.0.2You decide when a worker is allowed to start, and the Usage screen tells you whether one will start right now.
  • AddedYou now tell toryo when a worker is allowed to start, instead of tuning a number until it behaves. Before, the only control over the usage gate was a threshold, and what that threshold measured depended on what each agent happened to be doing at the time. There is now an explicit policy, set with --usage-gate-policy or in the console, with three choices: included measures your plan's most-consumed meter, paid measures the budget you have purchased as soon as the agent says continuation is available, and disabled turns the gate off. paid is the default, and it no longer waits until you are already spending past your plan before it looks at the paid budget. A change to the policy takes effect on the next check, without restarting anything. An agent whose usage cannot be read is treated as unknown and gated for itself alone, so an unreadable Claude no longer holds up queued Codex or Copilot work, and a held job now says which budget held it.
  • AddedCodex reports whether it has extra usage. It states availability only where the vendor states it: a stated block outranks stated availability, and a missing or malformed answer stays no opinion rather than being turned into a fact. Codex's credit balance, message estimates and reset counts are not treated as a gauge, because none of them says what the budget is measured against, so under the paid policy Codex keeps measuring its most-consumed included meter, per-model limits included. The console now reads a paid balance you have not spent yet as "Extra usage ready" rather than showing nothing.
  • AddedThe Usage screen answers whether a worker will start right now. It used to show gauges and leave you to work out what they meant for the queue. It now opens with a worker admission summary that links straight to Settings, and splits each agent into dispatch status, included usage and paid usage. A chip at the top of each agent carries the actual result, Ready, Held, Ungated or Unknown, and names the budget that decided it. An agent whose usage cannot be read says outright that dispatch keeps admitting workers, instead of leaving you to guess which way it fails.
  • ChangedSetting the threshold to 1 is no longer how you switch the gate off. A meter sitting at exactly full used to slip past a threshold of 1; it is now held. If you were using a threshold of 1 to disable usage gating, set the policy to disabled instead, which is what it is for.
  • FixedA scheduled maintenance command no longer stalls every other schedule. It ran inside the scheduler's own tick, so a pass that took minutes held everything else that was due behind it, for as long as ten minutes. The command now runs on its own, the schedule's next firing is booked the moment it starts, and the exit code, output and reason are recorded when it finishes. History shows it as running while it is in flight and prints its output or reason where there used to be a dash. Two commands on the same schedule never overlap, even if you have allowed overlap, because a maintenance pass changes shared state. If the machine dies mid-command, the row is marked interrupted and that schedule is paused with the ids named, rather than sitting as pending forever or silently repeating work nobody has looked at. A late tick now fires once and records the firing it skipped as a missed one rather than as an overlap. Firing a schedule by hand still runs in the foreground.
  • FixedCopilot reports what GitHub actually exposes instead of an error blaming the wrong thing. It shipped with no gauge and an error telling you to mint a token with an extra permission, and that permission was never the constraint: GitHub answers with the credential you already have, and what it answers has no plan capacity to measure consumption against and no spend to measure against the budget. Copilot now returns a working snapshot with no gauge, says its paid availability is unknown, and names the fact GitHub does not give it. A report that is empty because billing has not caught up stays blank rather than being shown as zero percent, a nonsensical number fails the reading instead of being rounded down to zero, and a network or sign-in failure keeps its own error.
  • FixedClaude's extra usage counts only where your account actually says it is allowed. Any account mid-spend that had not been explicitly rejected was read as having extra usage available, so an account whose status was missing or unrecognized had the gate's ceiling moved onto its paid budget on the strength of nothing. Availability now requires an explicit yes, an unknown status stays unknown, and a status toryo does not recognize is treated as no answer rather than as a no.
  • Fixedtoryo directives received writes to a file when you ask it to. The option was accepted and then ignored, so the one report carrying every resolved layer's full content, which is the whole reason to send it to a file, could only be printed to the screen.
v1.0.1Your rules reach every agent, reviews grade against a rubric that ships with toryo, and a run can decide the work is already done.
  • AddedYour rules now reach every agent. Codex and Copilot workers used to run without any of your engineering standards while a Claude worker on the same job had all of them, and the rules pack that shipped with toryo described toryo's own code rather than yours. toryo now resolves one layered stack for every job: rules from your library, your project's library, your own global files, your project's files, and nested ones, each layer overriding the one before it. Rules can live in a .toryo/rules folder as well as .claude, so they are not tied to one agent. You can also print the exact set of rules any job started with, layer by layer, including anything that failed to load.
  • AddedThere is one review rubric, and it ships with toryo. Reviews used to point at process and rubric files that shipped with nothing in them; a reviewer that read nothing still produced a review shaped correctly from criteria it invented, and the run reported that as a success. The documents toryo ships are now written into your global library at setup, they survive an upgrade if you have edited them, and a review step stops the run when the rubric is missing or empty rather than grading against nothing. library get accepts a name as well as an ID.
  • AddedA run can decide the work is already done. A code-task started from ideas now checks each one against a fresh copy of your repository first and dismisses the ones already resolved, backed by a citation that has to point at real code. If every idea is already resolved, the run stops before any work begins. Those runs carry their own outcome summary, so a run that correctly did nothing no longer looks, in every list and notification, exactly like one that planned, built, reviewed and merged. The console shows which ideas are mid-check instead of leaving them looking untouched.
  • AddedIdeas now have effort as well as impact, and rank on both. You can set effort when you capture an idea, nightly triage estimates one for anything without it, and each score records whether it came from you or from triage, so triage can revise its own guesses and never overwrite yours. Before this, an idea kept the value a single sighting earned it on the night it was filed, so a backlog of any size stopped ranking usefully. The console sorts by impact per unit of effort by default, shows both scores and where they came from, and can score a whole selection at once.
  • AddedYou can check chosen ideas against your code on demand with toryo ideas verify-sweep, or the new Verify control in the console, which previews the batch before it runs. The nightly pass only looks at ideas idle for 45 days, which is right when nobody is watching and wrong when you are asking. A sweep also closes what it resolves: a confident verdict whose citation checks out dismisses the idea, and every verdict comes with impact and effort estimates. Nothing is destroyed, the idea keeps its original text and the note explaining the verdict.
  • AddedThe console opens on something to do. A first-run chooser offers guided paths, and the one you pick follows you across the app in a dock you can collapse, with each step ticked off by an actual check rather than a checkbox you tick yourself. The paths also live behind the header's ?, now a Help dialog with the docs site alongside them, so dismissing the first-run prompt is no longer a one-way door. The License dialog gained a Manage license button that opens your account in the portal.
  • AddedYou can export a library document as markdown and import it back. The exported file re-imports to an identical entry, and the console's Library panel can copy the markdown or save it to a file. Import also now counts files it rejected for being malformed, which previously reported as a clean success.
  • AddedBackground services know what is optional and what is merely busy. ollama is optional now: a machine that declined it reports the service as unavailable rather than failed, so bringing services up succeeds instead of leaving a watcher respawning a missing program every five seconds forever. Restarting a service while it is mid-job is queued and run once it drains, rather than waiting 30 seconds and exiting with no output at all. And the up, down, restart and check commands each print a short plain-English summary naming what failed, what was left stranded and what was queued, without changing the output anything piping them relies on.
  • AddedCodex and Copilot jobs now show a cost, priced from the same published rate table Claude already used. It is an estimate of what the work would have cost against the model vendor's own API, not a claim about what your subscription was charged. A model with no published rate is left unpriced rather than shown as free.
  • AddedYou pick the model, not just the agent. Each of a code-task's five roles accepts an agent and model pair, and an invalid combination is refused when you file the run, with the valid list, rather than partway through. The console's idea composer gained agent and model pickers with per-role overrides. And on a machine running more than one agent, filing a run, a schedule or a job through your own agent now asks which one to use instead of quietly picking.
  • AddedSequences carry a description you can read and edit. It shows in the catalog and in full on the detail panel, both ways of authoring a sequence ask for one, and cloning a sequence lets you give the copy its own description instead of inheriting one it no longer matches. You can also archive a single run from its detail panel, without having to select a second run you do not care about.
  • AddedOn the hosted side: the portal has password recovery, emails are properly styled, signing up from the marketing site subscribes you to the newsletter, and there is a signups page in admin.
  • ChangedPull request bodies follow one shape. Both the agent writing the change and the one reviewing it work from the same list of things to cover, summary, motivation, design decisions, failure handling, deployment impact and verification with the exact commands and their results, and are told to leave out the ones with nothing to say rather than filling them with N/A. A small change gets a short body.
  • ChangedThe session analyzer stops inventing findings. It flagged any read that overlapped an earlier one, while the rule it models only blocks a read entirely covered by what the session already has, and it missed reads done through the shell. Both gaps manufactured findings for reads nothing would have stopped, and the first pattern it ever filed into your ideas queue was made entirely of them. Re-analyzing a transcript you have already analyzed will now report fewer findings, and its default threshold moves from 2 to 1 to match.
  • ChangedA run's history no longer stores each step's output twice, which was the bulk of what a busy machine kept on disk. Nothing you see changes and there is nothing for you to do.
  • ChangedThe console's Sequence screen dropped its table of registered sequences. The Design screen owns the catalog, so it was duplicate reference detail on the screen you open to find out what is running right now.
  • FixedA reviewer is handed the diff instead of having to go and get one. A failed attempt to fetch the diff looked exactly like a diff with nothing in it, and one run produced three verdicts on a change none of the reviewers had actually seen, with every check below it passing. The diff is now prepared for the reviewer up front and the run fails if it came out empty. Three separate causes are closed with it: a Codex reviewer was denied the network access its own instructions told it to use, a personal diff tool setting silently replaced the real diff for every agent on the machine, and a reviewer with no reliable way to find its own copy of the code wandered into another run's workspace and graded the wrong branch.
  • FixedA review step can now write the file it is required to produce. It was denied every writing tool by name while the thing it had to deliver was a file. Claude worked around it with a trick no rule covered; Codex, which has only one way to write, was refused three times, finished with the review written out in conversation, and failed the step with nothing saved. Writing is now permitted where the file lands inside the job's own output folder.
  • FixedA Codex session can record its commits. Neither of the two locations it needed to write to was permitted, so a session could edit files and then not commit them: one run pushed a commit to its pull request while leaving the local copy on the original branch. Those are now permitted for sessions meant to write, and a code-task stops with a clear message when the branch never landed locally, instead of failing four steps later with nothing to review.
  • FixedRule files that are symlinks are found. They were silently skipped: one person's global rules resolved 1 of 31, and the Codex and Copilot runs that only ever see rules this way were running with no engineering standards at all.
  • FixedAn update brings the database changes and the shipped documents with it, and reports a failure instead of finishing green over a database that was never updated.
  • FixedSetup refuses stale files left over from a previous build. Run over an existing install, setup repaired what it could and stopped, leaving a new build sitting beside the old build's database changes, finding nothing to apply, and printing a green tick over a database that was never updated. The health check agreed, because both halves of its comparison were stale together. Every installed set of files now records which build produced it, setup repairs only from a matching one, and the health check reports the staleness before drawing any conclusion from it.
  • FixedClaude installed through its own installer is no longer reported as missing. That installer publishes Claude in a way that does not look like a normal program on your path, so setup reported it absent on a Mac running Claude Code every day. It is now found, and workers are started with it available.
  • FixedSetup and the service manager say what actually happened. A services failure now reports the per-service detail and the underlying error, which is where a refusal from Docker actually appears, instead of an unconditional "everything else is in place". The startup advice stops guessing. And setup finishes with a still-to-do list built from what each step really returned, including the case of a machine with none of its agents installed, which used to come up green and accept work while every job died at the agent.
  • FixedA clean approval no longer kills the run. A reviewer approving a change with nothing to report failed on the empty findings, after the pull request was already open, and retrying hit the same wall again. The check now only fires where it means something: a demand for changes that names none.
  • FixedA large run stops running out of room. The list of changed files a worker returns grows with the size of the change, so a sweep touching 1,813 files spent 97% of the run's capacity on it and died after it had already built, reviewed and pushed. The list is now capped where it is passed between steps and kept whole where you read it, so a run already stuck recovers on a plain retry.
  • FixedThe check that decides whether an idea is already resolved cannot close one it only partly answered. An agent could cite something narrower than the idea, admit the gap in its own note, and still call it resolved. Every qualifier in the original idea now counts, anything left over goes in its own field, and a resolution that carries one is refused and reported.
  • FixedThe console holds its state where it used to lose it. The ideas brief rebuilds when you change the selection, rather than one hand edit suppressing it for the life of the app. An optional selection can be cleared again. The archive control hides on a run that is still live instead of sitting there disabled next to a reason already on screen. A services banner can be dismissed. And a job filed into a project's folder now carries that project, rather than landing under none and failing the run after its pull request had already merged.
  • FixedAfter a run merges in the latest code, the agent is told to refresh its workspace links. An ordinary refresh can report no changes while the links are stale, which turns a healthy merge into an unexplained failure at the next check.
  • FixedA session that asks for toryo's tools fails when it cannot have them, instead of starting without them and behaving as though they were never meant to be there.
  • FixedThe reviewer's instructions read the pull request context they were written for. All four of the conditional sections had been coming out empty in every real run.
  • FixedA project's library cleanup reads past the first page, so it no longer stops after 50 entries.
  • FixedSigning in to the portal is fast again. It was reported at 10 to 15 seconds; the sign-in itself is measured at 249 to 266ms, and nearly all the rest was the server being started back up after idling. A few sign-ins a day is exactly the pattern that leaves a server idle long enough to be stopped, so signing in once each morning met a cold start most mornings. The server no longer stops, that is pinned by a test, and every leg of the sign-in path is now timed permanently.
v1.0.0You can write your own sequences, design one with the console, and repair a failed run instead of refiling it.
  • AddedYou can write your own sequences. The three that ship with toryo used to be fixed parts of the product: if one of them did not fit how your team works, your only option was to ask for it to change. A sequence is now a plain file you can read, copy and edit, describing the steps a run takes: fetching a fresh copy of your repository, copying in the files a project needs to build, running a command, reshaping data between steps, branching on what the run was asked to do, and stopping for a human. Your own file can stand in for a shipped sequence by name, so you customise rather than fork. sequence import brings a file in behind a review, and sequence validate refuses one that could never run.
  • AddedThe console can design a sequence with you. There is a Sequence Design screen where you lay out the steps, decide which of the run's inputs each step uses, and, if you would rather describe what you want than draw it, talk to an agent that writes the file as you go. Working outside the console, you can ask your agent for the same help.
  • AddedApproval steps are proper forms now. A step that stops for you can show you the files it changed and the questions it wants answered, and you reply by clicking a named decision instead of typing a verdict and hoping it was understood. The form for starting a run hides fields that do not apply to what you are asking for, groups what is left, explains each field, and only insists on the ones your run will actually use. A run is titled from what you wrote, not from a generated string.
  • AddedYou can edit a queued run before it starts. Previously, spotting a wrong input after filing meant cancelling the run and filing it again from scratch.
  • AddedA worker can stop and ask you a question mid-run instead of guessing. The question appears on the run as it happens, and the bell badge reflects how urgent the waiting item is. An unanswered instruction is escalated rather than left sitting, and anything still outstanding is handed to the worker when it next picks up, so an answer you gave between turns is not lost.
  • AddedThere is a Usage screen with a gauge for each coding agent. Claude's weekly windows for your tier sit alongside Codex and Copilot, headroom you have paid for counts as headroom, and a marker shows where your budget runs out. The strip fits the window you have, moving the rest into a flyout rather than cutting it off.
  • AddedRuns that failed or escalated can be repaired instead of refiled. Fix your sequence file and a failed run can be re-pinned to the corrected version and resumed. An escalated run now waits, paused, with an explicit control to release it, rather than ending somewhere you cannot restart it. Runs also carry a triage stamp, and the Sequence screen lets you select several at once and archive them together.
  • Addedtoryo installs on more machines. Linux and Intel Mac builds are published and signed, and the updater offers each Mac the build for its own chip, so an Intel machine is no longer handed an Apple Silicon one. mcp install now sets up Codex, Copilot and Cursor as well, and can set Codex's approval mode at the same time.
  • Addedtoryo ideas drain-followups empties a followups file into your ideas queue, so notes a worker left behind end up somewhere you will see them after the run is over.
  • Changedtoryo is no longer a Claude tool that also runs other agents. Codex and Copilot are first-class choices you pick per job, each with its own usage gauge and its own rules about when it is allowed to start work.
  • Changedcode-task, review-task and research-task are now files on your disk, and the built-in versions are gone. Setting up installs them and updating upgrades them; from there they are yours to read, copy and override. Each step was checked against the old built-in version before it was removed, so runs behave as they did.
  • Changedcode-task plans against a freshly fetched copy of your repository rather than whatever state your checkout happened to be in, and it writes its planning notes beside the run instead of into your work. Those notes are named so you can spot them in a diff and ignore them in one go.
  • ChangedA retry is told why the last attempt failed. Retries used to start over with no memory of the previous attempt and often made the same mistake again.
  • ChangedWhen a run merges, the checkout you are sitting in moves forward with it.
  • ChangedA run whose checkout is behind the branch it builds on is refused up front instead of failing later, and the check costs nothing on a busy queue.
  • ChangedRuns process their steps in parallel, so a queue with several things ready moves faster.
  • FixedFiles a project needs to build now actually arrive in the working copy. The step that copies them in ran after the fresh copy was made and then looked for them inside it, where they had never been, so they silently failed to appear and the build failed for reasons that pointed nowhere useful.
  • FixedA sequence file that no longer works says so, and can be repaired. It used to fail somewhere further down with an error that blamed the run rather than the file, and there was no way to move the run onto a fixed version.
  • FixedInstalling a new build while the background services are running now tells you they are still serving the old code. Nothing used to say so, which is the same quiet mismatch the app itself stopped having in v0.3.1.
  • FixedCodex works properly as a provider rather than almost working. It starts in the right place, can see the run's files, tells you immediately when it is pointed at something that is not a repository, and no longer stalls waiting on an approval prompt nobody can see. Commands you have denied stay denied: one could previously be slipped through as the second line of an allowed command. Copilot's own exclusions and denies now take effect too, where before they were quietly ignored.
  • FixedA check whose failure was being hidden is now treated as a failure. A step could report itself as passed when it had not actually run.
  • FixedCommand output no longer gets cut off partway through when you pipe it somewhere.
  • FixedA run is no longer blocked because the branch it started from was deleted after a merge.
  • FixedThe console keeps its place. Switching views no longer resets the screens you had open, run descriptions render properly and stop repeating their own heading, worker detail shows which agent and model is running, clicking an idea selects one idea (with ctrl and shift for ranges), and a field label no longer steals the click meant for the control next to it. You pick a project by name; nothing asks you to type an ID.
  • FixedTwo things setting up the database at once no longer collide, and doctor now checks a real install correctly rather than only a developer's copy.
v0.3.1Updating from the app now finishes the job.
  • FixedUpdating from inside the app now restarts the background services, so they actually run the new version. Before, the new tools were installed but the already-running services kept serving the old ones, and the app reported itself up to date.
v0.3.0The app notices when its tools are out of date, and an install that gets stuck now says so.
  • AddedReplacing the app now updates the command-line tools. It never did: dragging in a new version replaced the console and left the tools as they were, so an update to pick up a fix showed you the old version’s errors, with nothing saying why. The app now compares the two and offers to update in one click.
  • FixedAn install using the embedded database no longer reports itself healthy while it is only half running. If the database was interrupted while shutting down, some parts kept serving and others stopped, and the console showed everything green while screens failed. It now checks every database rather than one of them, and names the ones that are not serving.
  • FixedA database left in that stuck state is now repaired rather than adopted. Starting the services used to see the false green and do nothing, so the console stayed broken until the process was found and killed by hand.
  • FixedStopping the database now waits for it to actually stop, instead of reporting success while it was still running and losing track of it.
  • FixedA leftover service from a crash is cleared the next time toryo starts. The cleanup only ever matched how services run in a development checkout, so on a normal install it silently did nothing.
  • AddedYou can stop and start the background supervisor from the console — click the supervisor indicator — or with toryo supervisor. There was previously no way to stop it: stopping the services simply let it start them again, which is its job.
  • ChangedTwo toryo installs can now run on one machine without disturbing each other’s files, services or ports.
v0.2.4The console stops erroring on an install that does not use Docker.
  • FixedScreens in the console no longer fail with errors about prepared statements. On an install using the embedded database, everything shares one database session, and two requests arriving together could overwrite each other. Installs using Docker were never affected.
v0.2.3A fresh install now finishes on its own, with no manual steps.
  • FixedSetting up no longer stops needing a hand. v0.2.2 could still fail to start Ollama on a machine where it had just found it, and wanted you to start it yourself before setup would finish.
  • Changedtoryo now records where your tools live when you set it up, and reads that back afterwards. Before, every part of toryo worked out where to find tmux, Ollama and Claude from whatever it happened to inherit, which differed depending on whether it was started by you, by the app, or by the background supervisor, and was wrong in some of those cases.
  • FixedSetup no longer restarts itself endlessly when your toryo folder sits behind a symlink.
  • FixedUninstalling now tells you the app itself is still in Applications. It does not delete applications, and the one left behind will reinstall everything the next time you open it.
v0.2.2A fresh install now starts its services, not just install them.
  • FixedThe background services start on an install that does not use Docker. They were trying to launch a Docker container regardless of the database you chose, which failed on the machines that had deliberately chosen not to have Docker.
  • FixedThe background supervisor can find the tools you have installed. Launched from the app rather than a terminal, it was left without Homebrew on its path, so the agent sessions it runs could not start.
  • FixedSetup finishes rather than restarting itself when your toryo directory sits behind a symlink.
  • FixedSetup now tells you when it skipped installing something, and gives you the command to finish it later. Declining the Ollama models used to leave a "missing" line and no explanation.
  • ChangedThe first-launch screen says what declining the Ollama models costs, search across your brain, memory and library falls back to plain text, instead of only its download size.
v0.2.1First-run setup works from the app, and there is finally a way to uninstall.
  • FixedSetting up from the app now finds the tools you already have. Launched from Applications rather than a terminal, toryo could not see Homebrew, Docker, tmux or Ollama, and reported a machine with none of them installed.
  • FixedSetup no longer fails at its last step when the background supervisor is already running. Everything before it had already worked, so the install was usable and said otherwise.
  • FixedRunning setup again keeps your data where it is. It used to pick the database runtime afresh each time, which could move an install onto a different one and leave everything it had learned behind.
  • AddedThe app asks how to set itself up. Choose the embedded database or Docker, and which extras to install, instead of getting whatever your machine defaulted to.
  • Addedtoryo uninstall removes toryo properly: the background services, the binaries, the shell PATH entry, the skills and the MCP registration. It keeps your databases unless you pass --purge, and tells you what it kept.
  • ChangedThe download page now says Docker is optional. It never was required, the embedded runtime needs nothing else on the machine, and the page did not mention it either way.
v0.2.0Activation, settings and crash reporting land in the desktop console.
  • AddedActivation lives in the app. The console asks for your email and key on first launch, and the same dialog shows which version you are running and signs you out again.
  • AddedA settings screen covering every service in one place, with a detail rail per setting instead of a card per app.
  • AddedStart any registered sequence from the console, and watch its cost and elapsed time climb while it runs.
  • AddedCrash reporting, off with a single toggle. A report carries no source code, no prompts, and no agent output, and the privacy notice states exactly what is in one.
  • ChangedOne screen failing no longer takes the window with it. Every other screen stays reachable, and the failure is reported rather than swallowed.
  • ChangedInstalls re-check their license daily and at startup, so a revoked seat stops working on its own and a purchase reaches the machine without anyone retyping a key.
  • FixedDatabase notices no longer mix into command output, so what toryo prints is parseable again.
  • FixedAn interrupted write can no longer quietly un-configure an install.
  • FixedDetail panels scroll on a short window, and opening an external link no longer leaves a stray process behind.
v0.1.0The first public release.
  • AddedOne download. Toryo.dmg carries the desktop console and the whole command line, and provisions everything on first launch.
  • AddedFour built-in sequences: ship a change, review a pull request, research a question, and grade a codebase.
  • AddedThe knowledge plane: memory, an authored library, a resolved code index, and directives, all reachable from a Claude session.
  • AddedA headless install for CI hosts and servers, verified against SHA256SUMS.
  • AddedPostgres on Docker, or an embedded pglite runtime for machines without it.