ShipAug 25
The Patterns catalog now covers one hundred fifty development problems
The public catalog at pathrule.io/patterns grew from eighty five packages to one hundred fifty. The new set concentrates on problems developers repeatedly search for and debug in production, including SQL performance, mobile lifecycles, browser rendering, queues, cloud runtimes, observability, Git workflows, local and fine-tuned models, enterprise identity and machine credentials. The catalog remains deliberately mixed across framework, frontend, backend, billing, infrastructure, workflow, AI and security work, and every package is still a path-scoped bundle of rules, memories and repeatable skills rather than a generic topic summary. The package, website and offline import bundle move onto the same version so the new patterns are available wherever a Pathrule client imports them.
ShipAug 25
The Patterns catalog now covers eighty five stacks
The public catalog at pathrule.io/patterns grew from fifty eight packages to eighty five. The new bundles deepen security, AI, billing, workflow, frontend and infrastructure coverage, and add focused guidance for file uploads and Spring Boot. Each package carries path-scoped rules, memories and repeatable skills instead of a generic checklist, with dedicated icons or brand marks on the site. The offline bundle that serves pattern imports moves to the same release, so ::pathrule:package:<slug> can reach the full catalog from every client as the release train rolls forward.
ShipAug 25
Past work and the files that change together now actually arrive
Pathrule builds a record of how a problem like the one in front of you was solved before, and a warning about the files that historically change alongside the one you are editing. Neither was reaching anyone. Both sat behind a switch that compared your workspace against an identifier belonging to a workspace that does not exist, so both were off for every account since the day they shipped while their tests went on passing, because comparing two strings cannot tell you whether either of them names a real thing. Underneath that, four more defects on the same chain, each independently fatal and each silent: the store that records a delivery refused every write it ever received, the health report for this area counted episodes built rather than episodes sent and called itself healthy, the cleanup pass deleted the very episodes it had just surfaced because a freshly surfaced episode looks unused, and the score that decides which past work fits gave a perfect mark for matching the root of your project, which is true of every path you have. Studio, meanwhile, ran a second and entirely separate delivery path that had never carried either signal, so the surface most people actually use delivered none of it even when the rest worked. All of it is fixed, and Studio now surfaces past-work episodes and co-change warnings the way external assistants receive them. One safeguard is worth naming: this delivery is contained on its own now, so a failure to fetch an optional signal can no longer cost a turn the memories and rules it was really there to deliver.
ShipAug 25
Pathrule tells you when two memories say the same thing
Duplication was the one gap in knowledge maintenance with no detector at all. Stale knowledge, broken references and missing knowledge each had one, but the same decision written twice in different words was delivered twice, spent your context budget twice, and drifted apart quietly when only one of the two copies was ever updated. Suggestions now carry duplicate knowledge as its own kind, deliberately separate from a conflict, because a conflict is two statements that cannot both be true and a duplicate is two that are both true and identical, and the two resolve in opposite directions, one by deciding and the other by merging. The similarity bar was measured rather than chosen. Across nearly sixty thousand pairs of real entries, the band above ninety five percent is the same fact in different words, and the band just below it is where path-scoped knowledge files legitimately share a shape, so flagging those would only teach people to ignore the detector. A lower bar is refused rather than obeyed. The control mattered as much as the finding: in the workspace this was built in the closest pair of all sits well under the bar, so the detector reports nothing there, which is exactly what it should do on input that has no defect.
FixAug 25
Your conversation history stops going missing
Three separate defects were quietly costing people their transcripts. First, the list of workspaces the desktop app syncs was validated all or nothing, so a single stale entry, a folder someone had deleted months earlier, made every sync reject the whole list. With nothing cached, the bridge subscribed to no conversations at all, and the app went on mirroring only the messages you typed: four hundred and forty four conversations over forty five days were stored with your half of them and nothing else, with no error surfaced anywhere. An entry that fails validation is now dropped on its own and the rest are kept. Second, the local backup capped how many conversations it kept by counting placeholders and real transcripts against the same budget. A placeholder holds nothing and can always be fetched again, a transcript is often the only copy that exists, and placeholders are always the freshest rows, so a plain newest-wins cap let them push real history out. The two hold separate budgets now, and what gets kept is decided by how recently a conversation was touched rather than by its position in a list. Third, restoring a conversation from the cloud could overwrite a longer local copy. It no longer can, and the guard lifts the moment you send a message, so it never stands in the way of new work.
FixAug 25
Continuing a conversation on your phone keeps its context
Picking a desktop conversation back up from the phone was silently starting the engine over. The identifier that lets an engine resume a session was recorded once, at the moment the desktop began watching a conversation, and for two of the engines that identifier does not exist yet at that point, because they only report it with the first thing they stream. Measured across an account, one thousand six hundred and twenty of one thousand six hundred and fifty conversations carried none. A missing identifier does not fail loudly, it simply starts a fresh session, so continuing from the phone lost everything the conversation had built without a word about it. It is now read at the end of each turn, the first moment it is guaranteed to exist, and cleared again wherever switching engines or rewinding deliberately invalidates it.
UXAug 25
Learned this session tells you what it learned
The panel that shows what your assistant taught Pathrule during a session said "Updated" and nothing more, and clicking the row went nowhere. An update is sent as an identifier plus the change, so the call itself names no record, and the row had no target to open. The write tools now answer with the current title or name of whatever they touched, and one shared reader sits in front of every engine, so Codex, OpenCode, Grok, Antigravity and Kimi produce the same rows Claude already did. Deletions and pattern imports and removals show up as well, and a pattern opens the path its pieces landed under. Two things deliberately name nothing and are no longer counted as a learning at all: a write the workspace refused, and a dry-run pattern preview, since neither of them changed anything.
ShipAug 25
The Patterns catalog now covers fifty eight stacks
The public catalog at pathrule.io/patterns grew from forty three packages to fifty eight, adding AI and security alongside the existing framework, frontend, backend, billing, infra and workflow families. Every page's title and description was rewritten in the same pass, because the site had been substituting generic metadata over the ones the packages carried. The offline bundle that serves pattern imports was moved to the same version, so ::pathrule:package:<slug> reaches the new packages from every client rather than only from the website.
UXAug 25
The last-sync time follows the app language
The connection time in the sidebar was formatted with the locale of the machine rather than the language you picked in Pathrule, so a Turkish interface running on an English system read its own timestamp back in twelve-hour form with an AM or PM after it. It now follows the app language, the way the rest of the interface already did.
FixAug 25
Not now dismisses the project scan offer
The card that offers to scan a newly opened project had a Not now button that rendered, looked enabled, and did nothing at all. It now removes the offer and leaves you with an ordinary empty chat.
ShipAug 24
Relevance now decides the form, not just the order
Pathrule now spends context in proportion to how well something fits your request. The closest few entries arrive as full ready-to-use content, and everything else that qualifies arrives as a name, an id and one line, which is about sixty characters and enough for your assistant to recognise it and pull the body when it turns out to matter. The gain is that relevance decides the form rather than only the position in a list, so nothing that fits is left out for want of room. The default keeps the three closest bodies, and that number was chosen by measuring rather than by taste: keeping only two would have saved around a tenth of the context by giving up the third body on every single prompt, and keeping three still costs less than sending every ranked entry whole. Skills are offered by name whatever their rank, deliberately, because a memory is a fact and a rule is a constraint but a skill is a procedure, and handing an assistant a procedure it did not ask for instructs it rather than informs it. Rules now earn their room through the same relevance test as everything else, so a constraint about migrations no longer sits where the memory about your button belonged, while a rule you marked strict keeps its body every time. The cheaper form also turns relevance into something observable for the first time: an offered name that your assistant chooses to pull is a real signal about what the work needed, and the reward for being pulled is a full body next time.
ShipAug 24
Ask two things at once and get knowledge for both
A prompt that asks two separate things is now read as its parts. Each clause is matched on its own, the clauses are matched at the same time rather than one after another, and the results are merged by best match, so a request that covers a migration and a button gets the knowledge for both instead of an average that sits close to neither. Two-part questions went from finding the right knowledge for roughly two thirds of their parts to finding it for all of them in one language and nearly all in another, single-part questions are unchanged, and the time it takes did not move because the parts are matched concurrently. The room available grows with the question rather than with the size of your workspace, so asking two things costs a little more and having ten thousand memories instead of a hundred costs the same. Alongside it, the relevance bar was tuned to hold in every language you write in. The same memory scores differently against a prompt and against a faithful translation of that prompt, so a bar set against English quietly gives a team that writes in another language less context than it earned. The new setting is verified rather than assumed: across seven languages the memory that should have won ranked first in every one of the thirty five case and language pairs tested, and a precisely worded prompt found its entry every time in all seven.
ShipAug 24
Your agents know who is the reference for what
Every person on your team now has a profile that answers one question, who is the reference for which area, and a short version of that answer is compiled into what every agent reads before its first tool call. The areas are derived from evidence your team already produces, the paths a person works at and the knowledge they authored there, counted over a rolling window so an area you left behind fades out instead of following you for years. Your decision scope is the half nobody infers: authority over a product decision does not follow from touching files, so Pathrule asks you to write it rather than guessing it from activity. The new Members panel shows you your own profile exactly as an agent will read it, and a derived list you disagree with is one you replace with your own, which then wins. What reaches the agent is small and deliberate: the team, you and your areas, up to three colleagues with the single area each is the reference for, up to two declared decision scopes, and one instruction, address the user by name and point at an area's owner when a decision touches it instead of deciding for them. The block accepts only names, paths, tags and a declared scope, so there is no field an opinion about a colleague's speed or seniority could travel in, and it rides the instruction file rather than the per-turn channel so a long session pays for it once. Visibility is yours: a profile set to private leaves every team-facing read, the compiled block included, and the database is what enforces that rather than a screen remembering to filter.
PerfAug 24
A branch per task gets its own dependency tree, for almost nothing
Running several agents at once got cheaper and more isolated at the same time. When the lockfile matches, Studio now clones the prepared dependency tree into the new checkout instead of installing a second copy, measured at 17 MB for a tree of 45824 entries against 684 MB to install it again, and the cloned tree belongs to that checkout, so an install one session runs never reaches another. Whether your disk can share blocks is measured with a small probe rather than assumed, because a clone-preferring copy onto a filesystem that cannot clone completes successfully anyway, and a reading that cannot be trusted falls back to a shared tree and says so out loud in the consent line. The numbers Studio reports for all of this are now the space your volume actually gives up rather than the size of a directory walk, which counts shared blocks at full price and overstated a prepared checkout of a large monorepo by a factor of fifteen, and a reading that cannot be separated from other disk activity is reported as not measured rather than as a zero. Housekeeping also learned to reclaim the checkout that actually accumulates, the one whose branch already landed, under five conditions that all have to hold: the work landed, nothing is running in it, a grace period has passed, git reports it clean, and Studio created it. Landing is recognised two ways, from Studio's own merge record, which covers a squash whose commits git can no longer trace, and by asking git whether the branch is already contained in its base, which covers a merge you did in a terminal or a teammate merged in a browser. The branch itself is never deleted for you.
SecurityAug 24
Closing an account clears your name from the record
Account deletion now completes end to end and does the right thing with what you leave behind. Deleting your account removes you and anonymises the attribution on the work entries and comments that remain, rather than deleting rows your teammates still read. That distinction is the point: activity entries feed the rollups, the ranking and the team view that the rest of the team keeps working from, so removing a departing colleague's rows would silently change aggregates nobody asked to change. Anonymising satisfies erasure without editing anyone else's history. The guarantee is pinned as a rule about the whole database rather than as a check on the two places it mattered, so a third place that would block the same path is caught by name instead of waiting for somebody to request erasure and find out the hard way.
SecurityAug 24
Service functions answer only to a signed-in caller
The internal service routines behind Pathrule are now reachable only by a signed-in caller, and the number of privileged routines an anonymous request can even name dropped from 107 to 86 in one pass. Getting there needed one non-obvious step worth recording: withdrawing a permission from anonymous callers does nothing at all where the permission is actually held by everyone, so the sweep names both and the coverage now asserts the resulting permission rather than the withdrawal that was supposed to produce it, which is the difference between a change that looks applied and one that is. Two scheduled routines around billing and account lifecycle were tightened in the same pass, carefully rather than in bulk, because two neighbouring routines legitimately define their own helper of the same shape and a blind sweep would have broken working code.
ShipAug 22
Retrieval learns from every turn, and the selection stays the same size
Pathrule now watches how each delivery turns out and lets that decide what it sends next time. When knowledge reaches an assistant, the turn is measured on its way past: which of the delivered entries the assistant actually read, how many tools it called, how many of those failed and on which files. Nothing is asked of the assistant for this. It does not have to call a tool, remember a session or admit its own mistakes, which is what makes the measurement behave the same across every client you connect. What accumulates is a weight per entry per kind of work, so the same memory can rank high for a migration and low for a small interface change, because the evidence for those two is different. The part worth knowing is what the weight is allowed to do: it reorders the candidates that already fit, and it cannot lift one past the bar that decides whether anything is sent at all. A workspace that has been learning for months delivers a better few entries per turn than it did on its first day, inside the same amount of context. Learning here buys accuracy, not room.
ShipAug 22
Your assistant's dead ends become a map
Some files are simply harder for an assistant to work in, and the reason is rarely the code. A path in your own instructions that moved. A generated file that cannot be edited safely. A directory that needs a permission the agent does not have. Pathrule now records each of those as a count against a file: the kind of tool, the file, and a short code for how it failed, grouped into the files an assistant fails in most often and the way it fails there. Only counts and codes are kept, never the command and never the error text, and the path is made relative to the workspace before anything is stored, so the same file groups across a team instead of once per machine. The same failures feed ranking as a negative signal, so guidance that keeps appearing in turns that go badly gradually stops being chosen. It is observed rather than reported, which matters more than it sounds: an assistant that fails quietly and moves on is recorded exactly like one that announces it.
ShipAug 22
See whether Pathrule pointed your agent at the right place
Every prompt gets a route: the paths the work is most likely in, named before the assistant opens anything. The Summary now carries the number that says whether that helped, the share of routed paths the assistant actually went on to open, next to how much file-tool work a routed session takes compared with one that was never routed. It is the difference between a routing feature that sounds helpful and one you can check, and it is the same reason the rest of the layer reports on itself: a signal that quietly stops arriving returns nothing, which reads exactly like a signal with nothing to say, so each part of the layer now says when it last received work instead of leaving those two cases looking alike.
ShipAug 22
Drop an image on a design and work with it
The Design canvas now takes an image the way you expect. Drag a screenshot or a photo onto a frame and it lands where you dropped it, compressed on the way in rather than measured against a limit an ordinary screenshot would fail. Once it is there you can choose how it sits in its box, so making a picture fill a different shape no longer stretches it, and you can move the visible part of it to the crop you meant. A crop frame wraps an image so you can drag the picture inside its window and release it again when you are done. A dropped SVG arrives as real vector art rather than a picture of itself, so a logo can be recoloured, bound to one of your colour tokens, and stays sharp however far you zoom in.
UXAug 22
Suggestions only speak when they have something to say
The Suggestions tab is where Pathrule raises knowledge worth a second look, and its value depends entirely on being worth reading. Each check is now measured against how often the findings are acted on, and a check whose findings are consistently ignored is retired rather than left to fill the list. One that flagged entries purely for having gone untouched is gone, since age alone says nothing about whether a memory is still true. Another that flags rules nothing has matched lately now stays quiet when delivery itself has gone silent, because that is one fact about the platform rather than a hundred pieces of advice about your knowledge. A suggestion you would always ignore is not a smaller problem than a missing one, it is the reason people stop opening the tab.
UXAug 20
The live status row stops flickering
The line above a running answer used to disappear and come back ten times in a single turn. It stepped aside for every tool the agent touched, and most tools finish in well under a tenth of a second, so what you saw was a status that could not hold still long enough to be read. It now yields only to a tool that has been running long enough to be worth reading, and below that it stays where it is and names what the agent is doing. It also stops saying "Thinking" during the part of a turn that is not thinking: when a model has committed to a tool and is still writing out the arguments, which on one measured turn took forty five seconds of writing before a file operation that ran in a few milliseconds, the row says so and names the tool. Pressing Escape now asks a second time before it stops a turn, so the key you reach for to dismiss something does not end an answer you wanted. And your replies to an agent question are collected into one quiet row instead of one message bubble per question, with the tab itself flagging a conversation that is waiting on you.
FixAug 20
A queued prompt now cancels the prompt you clicked
A conversation can hold two kinds of waiting message: the ones you typed while a turn was still running, and the ones you sent after switching the conversation to a different engine, which wait outside the engine that is finishing up. Both were counted in one list, and the position of a click was worked out by subtracting the length of the other queue. Removing one prompt could therefore remove a different one, or nothing at all, and send now could claim to cut short a turn that was not running. Each queue is now addressed by name, so remove and send now act on exactly the row you pressed, and the strip stops painting a message that is waiting for an engine switch as though a live answer were holding it up. Send now also confirms itself while it takes effect rather than looking like a click that did nothing.
ShipAug 20
Knowledge updates itself while you watch
When an agent wrote a memory, a rule or a skill, the Knowledge panel was the last to know: it kept its own view of each folder and its own counts, so the record existed everywhere except on the screen you were looking at. It now follows those writes live, from your agents and from your other devices, and a burst of them during a first setup arrives as one refresh instead of a dozen. Your own edits are recognised as your own, so saving no longer reloads the record you are still typing in. Move to has come out from inside an opened record: it is on the right click menu in the tree and on the menu of the record itself, with the same folder picker used everywhere else, and deleting asks first and says what deleting means. A learning listed in the session panel opens the record it named, including titles with an apostrophe in them, which used to arrive cut in half. Agents get one fix too. Writing knowledge no longer requires a workspace id, which a brand new workspace could not supply, so an agent asked to remember something on day one writes it to the right place instead of guessing.
ShipAug 20
Large designs hand over as a folder, not as a wall of markup
A real product screen carries an entry for every layer it contains, and that description rode inside the message along with the markup, so past a certain size a design could not be handed to an agent at all. The handoff now points at the export on disk in your own project, the markup, the picture of what it should look like and the implementation notes, and inlines none of it when that folder is there. The pointer is only claimed for a frame that really has one, so an agent is never sent to open a file that was never written, and if the folder cannot be written the transfer says so and falls back rather than failing silently.
FixAug 20
A plugin that refuses now says why
The connection check already knew why a server would not talk to it and the panel threw that sentence away, so a token that was saved correctly and then rejected looked exactly like a working connection. The reason is kept and shown. Slack is the case that made it obvious: its app has to be switched on for agent access separately from the token, and until it is, every call comes back refused. The catalog now names that second step in the token dialog, so you do the whole setup at once instead of pasting a valid token, being told it saved, and then hearing from your agent that the server is not configured.
FixAug 20
Engine setup problems read in your own language
Installing a coding engine, signing in to one, or finding it too old could produce a sentence that was half translated, because the reason was written once in one language and then wrapped in a translated frame. Every one of those outcomes now travels as a plain fact and Studio writes the whole sentence, so what you read is in your language whichever step failed. The same change reaches crashes. A restartable engine crash used to be recognised by matching the words of its own message, which meant a message worded slightly differently was treated as an unknown failure, and an unknown failure is a dead end you have to answer by hand instead of a session Studio can bring back. Failures now carry what they are, so recovery no longer depends on how a message happened to be phrased.
FixAug 17
Studio keeps working when the cloud does not
A problem on Pathrule's side used to stop Studio rather than slow it down. The app could sit on its opening screen with no way past it, or drop you on the sign-in screen while your session was perfectly valid, or show the waitlist screen to an account that had been admitted for months. All three were the same mistake: treating a request that never came back as an answer. Every request to Pathrule now carries a deadline, and only a real answer from the server can sign you out or turn you away. Studio opens with the account you last used, your organizations and workspaces are listed from the copy kept on your own machine, and the account menu tells you whether your work is backed up. When it is not, Connection status names the reason, so a network you lost reads differently from a service that is down. Agents get the truth too: a coding session is no longer told your Pathrule session expired when the real answer is that Pathrule could not be reached. Writing while you are offline now works as well. Save a memory, a rule or a skill with the connection down and it is written to your own machine and queued, so your agent can read back what it just wrote instead of writing it again. The queue is a file, not a browser tab: it survives closing Studio, and it belongs to your machine rather than to any one window, so writes your agent makes while Studio is shut are delivered on the next launch. When the connection returns everything replays in an order that respects what you actually did, deletions first, so a session where you removed some notes and added others is not measured against a count you already reduced. Nothing is discarded on your behalf. The only case that needs you is a plan that has filled up: those writes stay readable on this machine and wait for your decision, with the room left on your plan stated next to them, and deleting them is the one thing only you can do.
ShipAug 13
Grok 4.6 arrives, and 4.5 stays
Grok Build now serves two models in Studio instead of one. A new Grok conversation opens on 4.6, the model the CLI itself defaults to, and 4.5 remains one pick away in the model menu for anything you would rather keep on it. Both read a 500K context window, so the usage ring and the point at which Studio folds a long conversation are correct for each of them rather than borrowing a number from another engine. Auto ranks 4.6 above 4.5 at the same cost, orchestrated runs and the council pick it as the Grok flagship, and the readiness check Studio runs before your first turn now smoke tests the model you are actually about to use.
FixAug 13
Fable 5 runs on your Claude plan
Picking Claude Fable 5 used to hold your message and ask for an Anthropic API key, even when your subscription already covered it. Anthropic includes Fable 5 on every paid plan through the sign-in you already have, so that gate was refusing turns your account could run. It is gone. Fable 5 sends like any other model, and the model menu states the plan terms in one line instead: on Max it sits inside your weekly limits, on Pro and standard Team seats it spends usage credits. Signing in to an engine works exactly as before, an API key included where you prefer one. A model your plan does not cover now says so in the engine's own words at the moment it runs, rather than being refused in advance by a rule Studio guessed.
FixAug 13
iOS apps run through your framework's own CLI
Studio used to build every iOS target with Xcode's build tool directly, which is right for a plain Xcode app and wrong for a project that ships its own CLI. Expo and React Native projects now run through that CLI, so the environment files your app config depends on are loaded, native folders are generated when they are missing, and pods are synced before the build starts. Projects using Expo's default native generation could not run at all before this and now do. A project whose entry point is its own script can use the embedded simulator too. Studio still owns the device: it boots the simulator, attaches the log stream, then hands the app to the run command. Plain Xcode and Flutter projects keep the paths that already suited them. A target that lives deeper in a monorepo is no longer refused as an unregistered workspace.
FixAug 13
Install a marketplace plugin from anywhere in the catalog
The plus button on a catalog row set everything up and then showed you nothing, so installing a plugin worked from its own page and nowhere else. There is one dialog now, and it opens wherever you press it. Vendor sign-in reaches more of the catalog too: an authorization server may publish its details at either of two legal addresses, and Studio only asked for one, so vendors that answer at the other looked broken. Both are tried now, and the vendors that use the opposite form still work.
ShipAug 12
Run several agents on one repository at once
Turn on the isolated branch chip in the composer and that conversation gets its own branch and its own checkout of the repository. The agent edits, installs and tests in there, so your working copy is never checked out, never stashed and never touched, and five agents can work the same project at the same time without overwriting each other. Arming the chip cuts the branch and starts preparing dependencies while you are still typing, so your first message waits for nothing, and the branch is named in English from that message, in the convention your repo already uses. A fresh checkout has no installed dependencies and none of your ignored files, so Studio reads your lockfile, tells you the exact command it would run and the files it would copy, and runs it only after you allow it once or for good. What makes this more than a git command: your memories, rules and skills reach an isolated checkout exactly as they reach the main one, so a parallel agent is not a context-blind one. Isolation is opt-in per conversation, the default stays the main checkout, and a single task card can be run the same way. See isolated branches.
ShipAug 12
Land an agent's branch without leaving Studio
An isolated agent is only useful if its work can come home. Source Control now switches between your checkouts, so the file list, the per-file diff, staging, commit and push all operate on the one you picked, and a landing bar takes the branch the rest of the way: merge it as a squash, a fast-forward or a merge commit, or open a pull request with the title and body the agent drafted and you edited. Studio runs git and the GitHub CLI itself, never the model, so a conflict stops and names the files it stopped on while your working copy is left exactly as it was, and a missing or unauthenticated CLI says so instead of quietly asking an agent to improvise. Nothing lands on its own. After a merge, Studio asks whether to remove the checkout and tells you how much disk it is holding, and closing a conversation leaves its branch and checkout alone until you say otherwise. See isolated branches.
UXAug 12
One set of permission rules for every engine
Permission requests used to be written by whichever engine raised them, so the same question was worded differently depending on what you were running, and the choices you made in settings only reached some of them. Every gate now travels as plain data and Studio writes the words, so a confirmation reads the same whoever asked, in your language, and one set of rules covers all of them. A request your rules already answer is settled without interrupting you, and anything they do not cover still asks. Running shell commands defaults to automatic now, because asking on every single step only taught people to click through the cards without reading them. Answering a request no longer drops a bare "Yes" into the transcript while your real replies stay where they belong. And when a coding engine's sign-in has expired, Studio signs it out and back in from inside the app instead of sending you to a terminal.
UXAug 12
Move a queued prompt to the front
Anything you type while a turn is still running waits in a queue, and now you can jump one to the head of it: the queued prompt runs immediately and the turn in flight is cut short. Stopping a turn behaves the way you would expect too. It delivers the next queued prompt rather than pushing the queue back into the composer for you to send again. The queue strip owns the space above the composer while there is something waiting, and the engine badge comes back once it drains. The suggestion for your next turn also stays on the caret's own line now, instead of drifting down an empty draft along with its Tab hint.
FixAug 12
Chat rows say what they actually did
Three rows that rendered perfectly well and told you nothing. File edits from some engines never opened, so a change you could not inspect looked like a change that never happened. Every edited file now gets its own row with its own diff preview. When one change touched two files, the two rows could show each other's diff. A finished step now settles against the file it belongs to. And web steps name their target: a search or a page fetch reads as the query or the address it ran, both while it works and after it finishes, so the research panel stops being four identical lines, with the full text available on the row itself rather than only under a mouse pointer.
UXAug 12
Drag a layer back into an auto layout
Moving a layer freely on the design canvas used to be a one-way trip: releasing it over an auto layout pinned it on top of the flow instead of joining it. Now the container under your pointer is resolved as you drag, an insertion line shows the exact slot the release would take, and the sizing that the absolute pin overwrote is restored when the layer rejoins. Holding space still bypasses adoption, as it does for frames. The Layers panel also reads an auto layout the way the canvas does, top to bottom in layout order rather than front to back, and follows reversed rows and columns.
UXAug 12
Edit a vector point from the Inspector
Point editing has moved off the floating canvas bar that kept growing wider than the artwork it was editing. Handle mirroring, bend and delete are properties of the point you have focused, so they now sit in the Inspector's vector section while the overlay keeps the artwork handles and the Done control. A vector layer that is merely selected shows its normal fill and stroke rows again. Two shapes that refused to open in vector editing, or drifted once open, behave now: a vector transferred in from elsewhere can be edited, and resizing one re-emits its path instead of stretching an authored corner radius.
FixAug 12
A paused motion frame no longer ends up in your design
Scrubbing a timeline paints the frame you are looking at onto the live document, so an edit made while the motion dock was open could store a mid-entrance frame as the layer's resting state, and a PNG export rastered a half-faded element. That paint is a loan now: it is suspended before anything is saved or exported and handed back afterwards, so what you keep is the design and not the frame you paused on. Motion coming in from an agent also stopped losing channels. Per-axis scale, 3D rotation, skew, percentage movement and perspective are accepted the way they are advertised, and one mistyped target no longer throws away the other correct animations in the same request.
UXAug 12
Fold the side panels away with one shortcut
Cmd+Shift+. hides the left rail and the Inspector on the design canvas so the artwork has the whole window, and pressing it again restores the same layout. It is a real menu item while Design is active, and it was built to fire on the key that actually produces a full stop, so it works on non-US keyboard layouts instead of only on the one it was written on.
ShipAug 11
The biggest Pathrule update so far
Every surface moves at once: Studio on the desktop, the browser app, the hosted MCP endpoint, the CLI, the VS Code extension and the iPhone app. Most of it is not new surface area. It is 118 fixes and 18 performance changes across chat, tasks, engines, multi-window behaviour and shutdown, plus a security pass that confines every file and workspace action to the folders you actually opened. On top of that, the parts of the product that were promising are now finished: tasks arrive with their context already prepared, designs become clickable prototypes you can verify against the running app, and completed work feeds back into the workspace instead of evaporating. Everything below shipped in this release.
ShipAug 11
Dictate, search and schedule from your phone
The iPhone app catches up with the desk. Dictate a prompt instead of typing it, with transcription handled for you and an on-device fallback when you are offline. Search across your conversations to reach the thread where something was decided, and use the new navigator to jump to a turn instead of scrolling for it. Scheduled tasks are now yours to review, reschedule or pause from the phone, a run in flight shows its live status and why it stopped, and a task card carries its own discussion so the context behind it travels with it.
ShipAug 11
Split Studio into as many conversations as you need
Chat in Pathrule Studio now works like a real workbench. Open conversations as tabs, drag them into side by side panes, group them, and pull one out into its own window when you want it on a second display. The layout you build is remembered, so an arrangement survives a restart instead of collapsing back to a single column. Tabs, splits and detached windows share the same native motion, and each pane keeps its own scroll position and state so switching between two long threads does not lose your place in either.
ShipAug 11
Studio tells you when work finishes
Every run, task and long operation now reports into one place. Active work appears as jobs in the activity bar, with a clear signal when something needs your answer and a notification when a background job completes while you are looking elsewhere. You no longer have to keep a conversation open to know whether a run finished, or walk through your workspaces to find the one agent that is blocked on a question.
ShipAug 11
Run several devices at once, and preview the web build in place
The device stage in Studio is no longer a single simulator. Launch your app on several devices at the same time and interact with each of them, across iOS and Android as well as your native targets, with the running app sitting next to the conversation that is changing it. Web projects get a live preview in the same rail, so a browser build and a phone build can sit side by side. The active agent shares those same sessions, so asking it to check a screen means it drives the real thing instead of guessing from your description.
ShipAug 11
Tasks arrive with their context already prepared
Pathrule now assembles a task's context before the work starts rather than while you wait. By the time a card is ready to run, the memories, rules, skills and related paths it needs have been gathered and checked, and the task opens with a receipt showing exactly what was delivered and what was missing. Preparation is bounded and deterministic, so it cannot quietly consume your allowance in the background, and the autonomous activity is visible and capped from one place.
ShipAug 11
One place for every agent that is working
Studio projects all autonomous activity into a single command center. See which agents are running, in which workspace, on which task, and what each one is currently doing, without opening every conversation to find out. Work an agent started on its own is labelled as such, so you can always tell the difference between what you asked for and what Pathrule did in the background.
ShipAug 11
Finished tasks teach your workspace
When a task completes, Pathrule closes the loop instead of dropping the result. What the work touched, what it settled, and which knowledge actually helped are folded back into the workspace, so the next task on a related path starts from what the last one learned. The loop is deterministic: it records what happened rather than inventing a summary, and anything it proposes is yours to accept or reject.
ShipAug 11
Wire your designs into a clickable prototype
The Design surface now does prototyping. Draw connections between frames with a connect tool, choose the gesture that triggers each one, and pick how the next screen arrives, including overlays, hover states, back navigation and timed transitions. Prototype mode is its own mode on its own canvas layer, so wiring a flow never disturbs the design underneath. Preview plays the whole graph inside a device shell, and the flow travels with the design when you export it, so whoever opens the file gets a working prototype rather than a pile of screens.
ShipAug 11
Your prototype doubles as a UI test
A wired prototype is a description of how your product should behave, so Pathrule can now run it as one. Point the flow at your running app and every connection becomes a step to execute and check: the gesture is performed, the expected screen is asserted, and anything that does not match is reported against the layer that defined it. A flow you drew to explain a design becomes the test that proves the implementation followed it.
ShipAug 11
Check a design against the app you are actually running
Design verification no longer stops at the browser. Compare a design against your running app on web, iOS and Android, using the app's own element tree as the reference instead of a screenshot, and get findings that name the layer and the axis that drifted. It now compares appearance and not only geometry, so a wrong colour, weight or corner radius is caught the same way a misplaced box is. Each screen also reports how much of it is built from your design system, which is where literal values tend to show up.
ShipAug 11
Design handoff points your agent at the right files
Handing a design to an agent used to mean handing over its markup. It now hands over intent: the paths in your project the screen belongs to, the platform it resolved to, and the design's structure and tokens. The agent writes SwiftUI, Compose or your own components instead of translating stored HTML into whatever it can, and a screen built this way binds your token variables rather than baking in literal values.
ShipAug 11
Two-way Figma sync you can rely on
The Figma workflow is production ready. Bring frames, libraries and components in, push changes back out, and get a receipt for every transfer that says what moved and what did not. Conflicts stay open for you to resolve instead of being silently overwritten, a failed transfer closes cleanly rather than leaving a half finished run behind, and link details survive round trips so a frame stays connected to its source. Large libraries import as a plan you can review before anything is written.
ShipAug 11
A shared design link now plays as a prototype
Designs you share from Studio open as a real prototype in the browser rather than a flat frame. Whoever has the link can walk the flow you wired, trigger the gestures, follow overlays and go back, on any device, with no account and no install. The viewer stays a static document by design: content arrives encrypted, is decrypted in the recipient's browser, and the page runs no scripts that came from the design itself.
ShipAug 11
Dictate your prompt
You can now speak to Pathrule Studio instead of typing. Dictation transcribes in the cloud for accuracy and falls back to your Mac's own on device engine when you are offline or past your allowance, so the button keeps working either way. This replaces the speech model Studio used to download on first use, so a few hundred megabytes come back on existing installs. The allowance is pooled across your organization rather than capped per person, which means a team's minutes go to whoever is actually dictating, and a transcription that fails is never counted against you.
ShipAug 11
Pathrule keeps your knowledge fresh, and shows its work
Knowledge maintenance is a proper surface now rather than a list of loose suggestions. Pathrule groups related problems in your memories and rules into cases, proposes a concrete change for each one, and applies only what you approve, with the original always recoverable. Nothing is applied silently. Each proposal explains what it noticed and which paths it affects, so you can clear a batch of small corrections in one pass instead of rereading every memory yourself.
ToolsAug 11
A plugin marketplace inside Studio
Studio has its own marketplace for the services your product depends on. Browse the available integrations, see what each one needs before you commit to it, and wire it in from inside the app instead of following a setup guide in another tab. This release adds RevenueCat to the catalog alongside the existing vendors.
ToolsAug 11
The CLI and the VS Code extension move with the app
Both ship alongside this release. The CLI stays a single binary that serves the account based edition and the no account local edition, and the extension carries the same tool surface the desktop app does, so a workspace behaves the same whether you reach it from your editor, your terminal or Studio. The design and task tools added in this release are available in all three. See install the CLI and the VS Code surface.
UXAug 11
Pathrule no longer takes over your instruction files
Opening an existing project used to mean Pathrule rewriting the agent instruction files it found. It does not any more. Your CLAUDE.md, AGENTS.md and rule files stay yours: Pathrule writes into a clearly bounded region of its own and leaves everything around it untouched, and it can restore that region if it is edited or removed by hand. It also measures what it actually delivered into a turn, so the value it claims is something you can check rather than take on faith.
UXAug 11
A calmer first run
First run was tightened up throughout. The review step stays visible while you work through it and exits cleanly when you are done, plan differences are presented as a short comparison instead of a wall of features, and skipping is an easy target rather than a hunt for a small link. First run is versioned now, so a returning user is not shown a tour they already completed, and a new one is not shown copy from an older release.
UXAug 11
Find your place in a long conversation
Long threads get a navigator alongside the transcript. Markers show where each turn, plan, tool boundary and answer sits, so you can jump back to the point where something changed instead of scrolling for it, and hovering a marker previews what is there. Search now covers your conversations as well, so finding the thread where a decision was made no longer means opening them one at a time.
UXAug 11
Answer or cancel straight from the notch
The notch companion can do more than tell you an agent is waiting. Answer the question inline as before, or cancel the prompt outright when a run has gone somewhere you did not intend, without opening the window it belongs to. Conversation titles no longer trail off mid word, so a glance is enough to tell which thread is asking.
PerfAug 11
Long conversations and big boards stay fast
A broad performance pass over the surfaces that grow with use. Transcripts render only the blocks you can see and stop re-reading the whole conversation on every incoming character, so a thread with thousands of messages types as smoothly as a fresh one. Boards project their columns in a single pass and cache large lanes, hidden surfaces stop rendering entirely while you are not looking at them, and the app no longer pays a scaling cost on every frame. Menus, conversation previews and startup checks were trimmed the same way.
FixAug 11
Several Studio windows behave like one app
Running Studio in more than one window is consistent now. Signing in, signing out and session refreshes reach every window rather than only the one you used, update prompts and download progress appear once and in the right place, and a scheduled task claims its slot so two windows can never run the same one twice. Actions you queue belong to the window you queued them in, and closing a workspace no longer leaves a stale pointer behind.
FixAug 11
A turn that goes wrong no longer leaves the chat stuck
A wide reliability pass across live conversations. A prompt sent while a turn is still running is confirmed as queued instead of assumed delivered, a stream that fails settles into a clear failed state you can retry, and cancelling a turn actually ends it rather than leaving events arriving afterwards. History across tool boundaries survives a recovery, sign-in challenges stay cancellable while they wait, and remote turns settle in order so two devices cannot disagree about what happened.
FixAug 11
Task runs land where they should
Task runs were hardened end to end. A run started by an agent keeps the placement it was given instead of drifting to another column, a run that has already finished cannot be settled a second time, and a failed optimistic move rolls back only the card it touched. Scheduler runs no longer linger without an owner when the window that started them goes away, source snapshots taken on one device stop overwriting another's, and changes stranded in a worktree are reconciled rather than lost.
FixAug 11
An engine that stalls no longer takes the conversation with it
Every coding engine Studio talks to now has a bound on how long it may take to start, answer a control request or finish a handshake, and a startup that fails is rolled back so a retry begins clean instead of on top of a half started process. A stalled local server is recovered rather than leaving the chat waiting indefinitely, an interrupted sign-in replay settles instead of repeating, and one misbehaving listener can no longer break the others. Rotated sessions are merged and stored credentials are held under a lock, so two windows refreshing at the same moment cannot sign you out.
FixAug 11
Quitting Studio really stops everything
Closing Pathrule shuts down cleanly. Runs in flight are terminated instead of being left to finish against a closing app, processes Studio started are stopped with it, and native helpers are released before exit rather than lingering. Termination is bounded, so a process that refuses to go does not hold the quit open forever, and recovery work stops once the surface that owned it is gone.
FixAug 11
Sharper recall of the knowledge that matters
A round of correctness work on the retrieval side means the context Pathrule delivers is closer to what you would have chosen yourself. Path scoped lookups return the right node when several could match, related work from earlier sessions is ranked by how much it genuinely overlaps rather than by how recent it is, and clustering no longer lets one large group pull unrelated paths toward it. Suggestions and semantic matches were corrected too, so fewer near misses reach the top of the list. See how retrieval works.
FixAug 11
Connecting from a cloud client stops re-asking for consent
Using Pathrule from a hosted client no longer reopens the authorization page every time the connection restarts. The approval you already gave is reused, so a cloud agent picks your workspace back up instead of parking on a consent screen. See MCP overview.
SecurityAug 11
Tighter boundaries around your files and credentials
A security pass ran across everything that reaches your machine. File, workspace and project actions are confined to the folders you have actually opened, and a request naming a path outside them is refused rather than trusted. Credentials for your connected servers stay inside the app's protected core and are never handed out to the interface layer. Shared designs render as static documents with any scripts in the content removed, and decrypted content is size bounded so a malformed share cannot exhaust the viewer. None of this changes what you can do. It changes what a malformed or hostile input is able to ask for.
