Swival 1.0.19 released

Swival 1.0.19 is out.

A few file-editing fixes, clearer errors, a bit of command cleanup, and more /audit parser coverage.

Swival 1.0.19 is about making those edges less slippery.

File edits now notice when reality moved

The biggest everyday safety improvement is checksum-aware editing.

Swival now records a checksum of every file it reads. When the agent later tries to write that file, Swival verifies that the checksum still matches what it saw earlier. If the file changed in the meantime, the write is rejected instead of silently overwriting the newer version.

That sounds like a small guardrail until you hit the failure mode it prevents.

You ask the agent to change a file. It reads the file. You keep poking around in your editor and make a manual fix. Another process formats the file. A watcher rewrites it. Then the agent comes back with an edit based on the older version it saw ten seconds ago.

Without a freshness check, that is a nasty little race. The agent may not know anything changed. It can apply a perfectly reasonable edit to a version of the file that no longer exists, and now your latest change has been blended with stale context or lost entirely.

With the checksum check, the harness catches the mismatch at the boundary where it matters. The model has to reread and reconcile with the current file instead of pretending the old view is still fresh.

This is not flashy. It is just civilized.

Agents should be optimistic when they reason, but conservative when they touch files. Swival 1.0.19 moves that boundary in the right direction.

Failed edits give the model a better clue

There is another file-editing change that feels tiny in the changelog and much nicer in practice.

When edit_file cannot find the old_string, Swival now returns a more useful error. The failure message includes the closest matching line or multi-line window from the file, so the model can see what almost matched.

That is exactly the kind of hint an agent needs.

String-based editing is intentionally strict. If the model says “replace this exact text,” the tool should not guess wildly. Guessing at file edits is how you get charming little disasters. But strictness alone can become annoying when the model is off by one line break, one indentation level, or one sentence that changed during the conversation.

The better answer is strict matching plus good diagnostics.

If the replacement does not apply, Swival can now show the nearby truth instead of just saying no. The model can adjust the search text from the error itself. In many cases, it does not need to reread the whole file, burn more context, and reconstruct the edit from scratch.

That makes the loop feel less like a locked door and more like a useful correction.

No, this does not make text splicing magically semantic. It still matters that the model chooses a precise target. It still matters that file state is fresh. But when the agent misses, the harness now points at the miss in a way the agent can actually use.

That is the pattern I want from agent tools: be strict, then be helpful.

The terminal is a little less ambiguous

There are also two small session-cleanup changes that make Swival easier to trust while it is running.

First, /clear now also clears any pending continuation prompt. If you clear the conversation, the leftover continuation state should not hang around like a ghost from the previous turn. The command should mean what it feels like it means: clear the session surface and move on cleanly.

Second, paths in command output are now quoted. That matters because paths can contain spaces, and agents are very good at treating whitespace as structure. A directory named My Project should not become two imaginary entries named My and Project just because the output was a little too casual.

This is a small thing with a surprisingly concrete effect.

Terminal output is not only for humans anymore. In an agent harness, command output becomes input to the next model turn. If that output is ambiguous, the ambiguity travels. The model may call the wrong path, misread a result, or build a plan around a file that does not exist.

Quoting paths is not glamorous. It is just good manners for a world where another process is going to parse the text.

Swival also now prints its version in the startup banner and shows it in /status. That is another tiny bit of sanity. When behavior changes between releases, you should not have to guess which build you launched. You can ask the session, and the session tells you.

Small visibility beats folklore.

The audit parser ignores more fake code

The largest technical chunk in 1.0.19 is in /audit.

Swival’s symbol and import parsing has been substantially hardened. The extractor now strips comments and string literals before matching, so imports and exports no longer leak out of docstrings, template literals, Zig multiline strings, or comment blocks.

That sounds dry, but it matters.

Audit triage depends on the harness building a decent map of the repository. It needs to know which files import what, which symbols exist, and where the interesting edges might be. If the parser mistakes an example in a comment for a real import, or treats a string literal as a declaration, the map gets noisy.

Noise is not harmless in security review. It can send attention toward fake edges and away from real ones. It can make dependency context look richer or stranger than it is. It can waste model budget on ghosts.

1.0.19 improves coverage across a bunch of language shapes: Go bare-string and grouped imports, JavaScript side-effect imports and re-exports, C# using, Kotlin fun, Rust pub struct, pub trait, and pub enum, Zig pub const, and Python relative imports. It also removes several common false positives around member access and modifier-prefixed declarations.

The new release also adds /audit support for Perl.

I like that combination. One part is about seeing more real structure. The other part is about seeing less fake structure. Both matter because agentic security review is already probabilistic enough. The harness should not add avoidable confusion before the model even starts reasoning.

This does not make /audit perfect. Parsing source code with lightweight extractors has limits, and security findings still depend on model quality, repository shape, and human review. But a cleaner map gives the rest of the pipeline a better starting point.

That is worth doing.

Small release, fewer ghosts

The common thread in Swival 1.0.19 is not spectacle. It is freshness, precision, and less ambiguity.

Freshness means a file edit should know whether the file changed since the agent read it. Precision means a failed edit should show the nearest real text instead of forcing a blind retry. Less ambiguity means newline splices should not invent blank gaps, /clear should clear the state people expect, paths with spaces should stay whole, the running version should be visible, and audit parsing should separate real code from code-shaped text.

None of this turns Swival into magic. It still depends on the model. It still depends on good prompts and sensible review. It still cannot guarantee that every audit path is complete or every edit plan is wise.

But this is exactly the kind of release that makes an agent harness feel steadier.

The best tools do not only add big capabilities. They also sand down the weird little edges that make you hesitate. 1.0.19 sands down a lot of them.

That makes the terminal feel less haunted. I will happily take that.

Upgrading

If you installed Swival with uv, upgrade with:

uv tool upgrade swival

On macOS with Homebrew:

brew upgrade swival/tap/swival

The documentation is at swival.dev.