A lot goes into
a good change.

One honest list of what you changed, and the diff beside it.

The tree and the diff move together, so the file you point at is the file you read. Split or unified, word-level highlighting, per-file collapse, scroll-spy, ⌘F find in diff, ⌥J/⌥K from change to change. A protected branch says so before the commit lands and offers a new branch instead.

Take exactly the lines you mean.

Press on a line number, drag, and stage or unstage just those. Spalt assembles a minimal patch and runs git apply --cached --check before the index is touched; a failed check changes nothing. No-newline-at-EOF, CRLF, deletion-only selections, partial new files — each one a named test against a real git.

Leave the note beside the code, and come back after a rebase.

Hover a line, note it; drag a range, annotate it; note a whole file from the toolbar. Notes live in the repository's .git, invisible to git status. Space marks a file reviewed with a fingerprint of its changed lines, so the mark survives a rebase that merely moves hunks and dies the moment the content changes. A note with ?? is a question; the rest are directives — and one click hands all of them to the assistant, questions answered first, directives returned as proposed diffs.

A database, not a scrolling list.

Lane graph, search by message, author or content (git log -S), file history that follows renames, line history for a selection, blame with a drill-down to the parent. Reword, squash, drop and reorder run in memory: a plan that conflicts aborts with the repository untouched. Every ref-moving operation is journaled, and ⌘Z walks it back.

Look before the leap.

The push dialog lists the commits going out, one at a time, with their files and diffs — and Uncommit is right there for the one that should not go. A branch whose name the remote already owns is refused with the divergence spelled out and both ways out in the dialog. --force does not exist in the codebase: only --force-with-lease, behind a confirm, and never on a protected branch.

Yours, the result, theirs.

A three-pane resolver in the JetBrains mould: per-change arrows on the lane, character-exact word marks that re-measure as you type, resolve automatically where the sides touched different words, whitespace policies, folds, and one undo history for chunk actions and typing alike. The line structure comes from the index's three stages, never from markers in the file.

Read the stash before it lands.

Stash asks for a title in git's own format. Unstash opens the same review frame a push gets: every stash with its age and branch, the files, every line it would write — then Apply, Pop or Drop. Untracked files are in the preview, because they are usually the point.

Spalt connects the Jira issue, branch, commits, checks, and pull request through the issue key in the branch name. The statusbar keeps the issue, checks, and pull request visible throughout.

Start work · Issues

A branch named after the ticket, from origin/main; the ticket moves to In Progress.

Commit · Changes

The key prefixes the commit; the statusbar carries the issue from here on.

Publish · Push

The receipt offers Open pull request; the form arrives prefilled from the issue.

Checks · Actions

A checks segment appears the moment CI starts; red means a fix, from the same window.

Review and merge · Pull requests

Approve, request changes, merge — then one dialog offers the ticket's last transition.

Transition, comment, and link are the only things Spalt writes to Jira, each from a click. A pull request merged elsewhere still shows the ticket’s open status in the strip.

Actions and deployments

Jobs and steps, re-run and cancel, dispatch; Cloudflare Pages previews under the commit.

CI on every commit

A dot in History for every commit GitHub has run something for.

Approve, request changes, merge — then one dialog offers the ticket's last transition.

A shell, or an agent, under the diff.

Tabs and splits in the repository's directory, with Terminal.app's chords. Run Claude Code or Codex there under its own sign-in — or hand a whole Jira issue to one with Send to agent…, the prompt typed in and waiting. Sessions are owned by the Rust core: closing the drawer or switching repositories never ends a process.

Commit messages from the staged diff

⌘G writes the message from what will actually commit — the staged diff, never the working copy — in your style: match the history, conventional, or imperative. It streams into the box and stays a draft.

Explain, review, ask

The assistant panel (⌘J) explains a hunk or a file and takes follow-up questions. Seven review passes over the whole change: summarize, walkthrough, find issues, security, performance, test coverage, a checklist.

Your notes, answered

One click sends every review note: questions answered first, directives returned as proposed diffs — never applied on their own.

Accounts, not a provider

Several Claude Code subscriptions side by side, Codex, OpenCode; API keys for Anthropic, OpenAI, OpenRouter, Gemini, xAI, DeepSeek, Mistral, Groq, Kimi, Z.ai; Ollama and LM Studio locally, or any OpenAI-compatible URL. Assigned per repository, project or app default, with a model picker and a Stop button.

Agents in the terminal, and handed the issue

Claude Code and Codex run in the drawer under their own sign-in. Send to agent… composes the Jira issue — description, comments, links, Confluence pages — into a prompt and types it in. Atlassian's MCP server can be switched on for the agent to read Jira itself.

Off by default. Per repository. Redacted first.

Nothing leaves for a repository you have not enabled. The first send shows exactly what would go and to which account. .env files, keys and certificates, and everything .gitignore matches are stripped before any request; a CLI agent runs from an empty sandbox with its tools off. Under test, not on promise.

A git client that runs shells and coding agents is exactly where a runaway node gets noticed late. The right end of the statusbar carries CPU, memory pressure (the kernel's verdict, not a percentage) and the startup disk, quiet until they have something to say. Click it: tiles with two minutes of history, Activity Monitor's own memory rows, every volume — and the process table, everything Spalt spawned grouped first, then the machine by CPU or memory, with a filter that reaches any process. Quit asks; Force quit arms twice. Numbers are counted the way macOS counts them, so they match Activity Monitor.

A second chip counts the ports listening on this Mac. The panel groups them by how certainly they are yours — per open repository, then what Spalt started, then the rest — one row per port, not per process: a forked server is ten workers on one row, quit together. Each says whether it is reachable from localhost only or from the network, and Open http://localhost:5173 names exactly where the click goes. Read from the kernel, not from lsof, in a couple of milliseconds.

Light, Dark, Midnight, Sand — or follow macOS. Reduced motion respected.

Projects

Repositories grouped and pinned in a sidebar that is a launcher, not a tab mirror.

A local identity

Rename a repository inside Spalt, give it letters, an emoji or its own logo.

Open in…

Finder, your editor, your terminal — with each application's own icon.

Clone, or add a folder

Paste a URL, or point at a folder of checkouts and get a project.

The spalt command

spalt opens the current repository; spalt path another.