Repository navigation
Releases
v0.12.1 — the hook path keeps 0.12's promises
0.12.0's promises now hold on the path most blocked edits actually take. An audit
after release found that tower guard — what the PreToolUse hook and the pre-commit
guard run — never reached the code 0.12.0 added. Everything below is a fix or a
correction; no protocol changes, still 20 tools.
Fixed
- A hook-blocked agent was promised a message it never got.
tower guard
pre-checked withcheck_collisionand returned beforeclaim_intent, so the blocked
agent was never registered as a waiter, never sawalternatives, and the collision
never reachedtower stats— while the prompt printed "[w] wait — Tower messages you"
and 0.12.0's notes said the same.guardnow goes straight throughclaim_intent
(a refusal registers nothing, so the pre-check bought nothing). - An edit built on a moved declaration went through unclaimed. The same pre-check
ignored the agent's recorded reads; the claim that followed was refused over them, and
the refusal was dropped. It now blocks. - Claims from the CLI and the hooks carried no signatures.
path#namesymbols were
sent without their declaration fingerprint, so on the hook path there was no hard
write_read, no heartbeat invalidation and no landed-signature notice on complete —
only MCP clients that sentsigthemselves got any of it. They are now fingerprinted
from the working tree. tower statscounted a retry as a new collision. A hook retries a blocked edit each
time the agent reaches for it. A refusal is now counted once per agent per blocking
claim.init --hooksnever upgraded an existing install. It skipped any event already in
.claude/settings.json, so an install from before 0.11 kept aPostToolUsematcher
withoutRead— no recorded reads, none of 0.12's read-time warnings — and re-running
the documented command said "already wires every Tower hook". It now rewrites Tower's
own entries, moves Tower's command out of a group it shares with yours rather than
editing that group, adds Tower's entry beside your own hooks for the same event, and
never changes your hooks. Upgrade: in your Tower clone,
git pull && npm install && npm run build && npx tower-mcp init --hooks..claude/settings.example.jsonhad the old matcher too; a test now holds it equal to
whatinit --hookswrites.tower initprinted a hand-copied pre-0.12 rule; it now prints the onetower setup
writes.tower <command> --helpexited 1 with "Unknown option"; every command now prints help
and exits 0. New:tower --version. Help now listswork's--agent,--repo,
--cmd,--interval,--max-minutes,--no-push,--no-prandserve's--host.- The UserPromptSubmit nudge hook fell back to
npx -y tower-mcp nudge— a registry call
on every prompt, contradicting "no network calls you didn't configure". Like every
other hook it now needs the built CLI, and says so on stderr if it is missing. tower-anywherehad the same guard bug; itsguardnow goes throughclaim_intent
too, and both commands print what is still free when refused.- Docs: SECURITY.md described one hook on one machine; team.md and enforcement.md said
repo identity comes fromorigin(it is the root commit sha); worker.md never said what
happens when a headless run hits a conflict; the site's tool grid listed 19 of 20
tools. Sample repo ids and agent names in tests and on the site are now made up.
Added
site/logo.png(listed as the registry icon) andsite/og.png, the link preview.glama.json, for claiming the Glama directory listing.
v0.12.0 — nobody waits
Nobody waits. Before this release a hard conflict ended in stand_down and
nothing else, and the rule tower setup writes said "stop and ask the user" — so a single
conflict parked an agent until a human noticed. Each of the four places an agent could
stall now has an answer on the wire. All of it is additive and optional: a client that
ignores the new fields behaves exactly as on 0.11. Still 20 tools.
Added
- A refusal says what to do instead. A refused
claim_intentcarries
alternatives:avoid(what the blocking claims hold, plus code inferred to depend on
it),nextTask(a sequencer task, when.tower/policy.yamldefines modules),
notifyOnRelease, and one line ofadvice.tower claimprints it under the refusal. - Dependencies inferred from reads, not configured. A claim that wrote
checkout
having readverifyis evidence thatcheckoutdepends onverify, so whileverify
is heldcheckoutis inavoidtoo. One hop, the last seven days of claims, capped at
50 — nopolicy.yamlrequired. - The refused agent is messaged when the block ends. Refusal registers a waiter on
each blocking claim; completion, release or expiry sends it a message fromtower
naming what freed up. No retry loop. - Warned at read time.
record_readsreturnsconflicts— anyone changing what you
just read — and takes an optionalbranch, so work on another branch warnssoft. The
PostToolUsehook delivers this to Claude Code asadditionalContexton everyRead
(plain stdout from that hook never reaches the agent). - Contract-first:
declares. ASymbolRefyou claim may carry the declaration it
will have once your change lands. Readers get asoftwrite_readwith
declaredSigTextand build against it in parallel; a declared contract is neverhard,
and a reader already on it is not warned.heartbeatdelivers a declaration to readers
that claimed first. complete_claimreports the contract that landed. It takes the claimedsymbols
as they stand after the change (tower completeand the post-commit hook fill them
from the working tree). Every agent that read a declaration which moved — or was
declared — is messaged the landed signature and whether it matches the declaration. The
output is now{ ok, notified }.tower setup --keep-goingwrites a rule that routes around a conflict instead of
stopping: work outsideavoid, and ask the human only when nothing safe is left. The
default rule still says stop and ask.
Fixed
- On Windows, a blocked edit was not blocked. The hooks ended with
process.exit(),
which aborts in libuv (!(handle->flags & UV_HANDLE_CLOSING)) while V8 is still
compiling tree-sitter's WebAssembly in the background. The PreToolUse hook printed its
refusal and exited127instead of2, which Claude Code treats as a non-blocking
error — so the edit went ahead. The same crash discarded everyPostToolUsecontext.
The hooks now setprocess.exitCodeand let the process end, with an unref'd timer as
a backstop; measured 0/10 correct exit codes before and 10/10 after. Re-run
npm run buildin your Tower clone — the hooks run from there, not from npm. cmdRecordReadsdid not fall back to derivingrepoIdthe waycmdClaimdoes, so a
caller that omitted it recorded reads in a different partition from its own claims. The
shipped hook always passed one; this closes the gap for every other caller.- A
declareswritten with a leadingexportfingerprints the same as the parsed
declaration, which never includes it. [w] waitin the collision prompt said "retry in a few minutes"; Tower now messages you.- Docs: the protocol tool table omitted
propose_intent, the README and site still said
the hook claims at file granularity (it has claimed the enclosing function since
0.10), and the protocol's "current limit" described heartbeat delivery as unshipped.
0.11.1 - listed on the official MCP Registry
Listed on the official MCP Registry. The registry is upstream of the directory
ecosystem — Glama, PulseMCP and mcp.so sync from it — so one listing reaches further
than filling in each of their forms by hand.
Added
server.json— the registry manifest, validated against the live registry rather
than a schema file. (The schema served at2025-07-09is stale and snake_case; the
current one is2025-12-11and camelCase, and validating locally against the old
copy reports "valid" for a document the registry rejects with a 422.)mcpNamein the published package. The registry proves npm ownership by fetching the
package and matching this field against the server name. This is the only functional
reason for this release — npm versions are immutable, so the field cannot be added
to one already published.- A workflow that publishes the manifest on every release, authenticating with GitHub
Actions OIDC.mcp-publisher login githubis broken in every published build
(modelcontextprotocol/registry#1543, fixed by #1588 but unreleased as of v1.8.1);
OIDC is a separate code path. Publishing from CI also means the listing cannot drift
from the release, which hand-publishing does the first time anyone forgets a step.
Fixed
- The landing page claimed 429 tests; the suite was at 433. Now states
430+, which
stays true as tests are added — a precise number that is wrong reads worse than an
approximate one that is right.
No API, protocol or tool changes. Still 20 tools.
0.11.0 - a claim is only as fresh as the read that produced it
A claim is only as fresh as the read that produced it. Comparing write sets catches
two agents editing one symbol and is structurally blind to the more common failure: A
moves AuthService.verify in auth.ts while B, having read the old signature, writes a
caller in payments.ts. Different file, different symbol, so the collision check exited
on its first line and told both agents to proceed. B found out at CI.
Added - version-aware claims
readsonclaim_intentandcheck_collision- the declarations the work was
written against. A second detection pass compares them against what other agents hold
open, and reportskind: "write_read"when one is moving or has already moved.- Signature fingerprints.
SymbolRefcarries an optionalsig- a digest of the
symbol's declaration, body excluded - andsigText, the readable form. A rewritten
body, a renamed local, a comment or aprettierrun never move it; an added parameter
or a changed return type always does. That precision is the point: a staleness warning
that fires on a reformat gets muted, and a muted tool is worth nothing. - Tower watches reads rather than asking for them. The PostToolUse hook now also
matchesReadand records what the agent looked at, with each declaration's signature
at that moment. An agent that never learns to sendreadsis covered anyway.
Re-runtower init --hooksfrom a clone to pick this up. PreToolUse stays
write-only on purpose - it blocks edits, and a Read must never be blocked. heartbeatreports what moved after you claimed. Claim-time detection only sees
claims already open, so an agent that claimed first was never told when a declaration
moved under it later.HeartbeatOutputnow carriesinvalidations, riding the call
agents already make every ~60s - no push channel, no polling.record_reads- the twentieth tool. Normally called by the hook, not by an agent.
A hard write_read conflict carries the delta:
[HARD] AuthService.verify moved under you - alice changed the declaration you read
was: verify(token: string)
now: verify(token: string, opts: Opts)
Two lines instead of "your context may be stale, re-read the file", which costs a whole
module back in context to discover one parameter moved. Tower exists to spend fewer
tokens, so a staleness signal that costs a file read is worse than silence.
Added - tower stats
Tower detected collisions for four versions and forgot every one, so "which kind actually
happens, and how often" had no answer. A conflicts table now records kind, severity and
whether it was forced - no file names, no symbol names, no code, and nothing is sent
anywhere. tower stats reads it locally.
Compatibility
Every new field is optional and every new behaviour is additive. A client that sends no
reads gets exactly 0.10.1's behaviour, and there is a test that says so. Calling
record_reads against an older hosted Tower fails harmlessly - the hook swallows it, and
a missed read costs a warning, never correctness.
Known limits, stated rather than left to be found
Behavioural changes under an identical signature are invisible. That is deliberate: it is
the trade that keeps false positives near zero. Cross-file inference is not attempted -
Tower knows what an agent read because it watched, not because it resolved a dependency
graph.
429 tests, 89.9% statements, 81.5% branches.
0.10.1 - six things that were silently broken for every user
tower setup --url ... --token ... wrote your team token into a file teams commit.
0.10.0 moved the token out of an Authorization header and into the env block of
.mcp.json, and a test named "keeps the token out of an Authorization header written to
disk" locked that in. Both were true. Neither mattered: .mcp.json is shared project
config - Tower's own repo tracks it - so anyone following the documented setup command
and committing their config published a live team token.
Fixed
-
setup --tokennow adds.mcp.jsonto.gitignoreand says plainly that the file
holds a secret, including thegit rm --cached .mcp.jsonneeded when git already tracks
it. Without a token the file stays out of.gitignore, because then it is ordinary
shared config a team is right to commit. -
The local-mode warning no longer recommends the bug 0.10.0 fixed. When
TOWER_URL
was set,serverefused to start and told you to point your agent at a
"type": "http"entry - the exact shape that leaves no process on your machine to
computerepoId, which is how a fork and its upstream split in silence. It now shows
theserve --remoteproxy form. -
tower doctorgreen-lit machines Tower cannot run on. 0.9.1 fixed the Node floor in
requireModernNode, butdoctorcarried its own copy of the naive>= 22.5check - so
the command whose entire job is "is this machine ready?" passed 22.5-22.12 and 23.0-23.3,
the two windows wherenode:sqliteis still behind a flag, and the real command then
died onERR_UNKNOWN_BUILTIN_MODULE. It now callsrequireModernNodedirectly. Its
tests had encoded the wrong floor too, including a "healthy machine" fixture pinned to
v22.5.0. -
init --hooksinstalled five hooks that could never fire. The hook scripts live in
hooks/in a clone; the npm package shipsdist/only. Run from npm, the command wrote
five entries pointing at files that were not there, printed
✔ .claude/settings.json — installed …, and told the user to runnpm run buildin a
project where that script does not exist. Nothing errored, so thePreToolUsehook that
is supposed to block a conflicting edit simply never ran — and the user had every reason
to think they were covered. It now refuses when the scripts are absent and gives the
clone-first steps. The git guards, which shell out tonpx -y tower-mcp, are unaffected
and still work straight from the package. -
The PR collision action had never read a single input. GitHub exposes an input as
INPUT_<NAME>, uppercased with spaces mapped to underscores — hyphens are kept. The
action mapped hyphens too, so it readINPUT_GITHUB_TOKENwhile the runner had set
INPUT_GITHUB-TOKEN;github-token,tower-urlandtower-tokenwere all undefined.
It failed on the token before reaching any collision logic, caught its own throw, printed
::warning::and exited 0 — a green check on an action that did nothing. Surfaced by
opening the repository's first-ever pull request. -
tower --helpexited 1.--help,-handhelpall fell through to the unknown-
command branch: the right text printed, then a failure code.tower --help && …broke,
and so did every smoke test. They are real commands now and exit 0. Baretowerwas
already correct. Caught on the first run of the new packaged-tarball CI job.
0.10.0 - one project, one coordination space
A fork and its upstream coordinated in separate spaces, in silence. Two agents on one
project — one on rohanxmalik/nimbus-demo, one on their own fork — both claimed the same
work, both got recommendation: "proceed", and no conflict was ever reported. Nothing
errored. Found in a live two-machine session.
0.9.0 shipped repoId to fix exactly this. It did not work, for two reasons.
Fixed — identity now reaches the server
- Nothing on the MCP path ever sent
repoId. No tool description mentioned it, and
with.mcp.jsonpointing atype: "http"entry straight at the hosted URL, there is no
process on the developer's machine to compute it.tower setup --urlnow writes a
local proxy instead —tower serve --remote <url>— which resolves this repo's
identity once fromcwdand stamps it onto every call before forwarding. The agent
never learns the concept exists. - Only 4 of 19 tools accepted
repoId.send_message,fetch_messages,pending,
list_tasks,next_taskandheartbeat_workerdid not, so messaging and delegation
split even when claims matched. All repo-scoped tools now carry identity. messages,tasksandworkerswere keyed on the raw repo string — there was no
repoKeyon those tables at all. Every repo-scoped table now carries and queries the
same key, with a migration that backfills existing rows.projectId— setprojectId: <name>in.tower/policy.yaml(orTOWER_PROJECT_ID)
and every clone converges regardless of git history, remote URL, or whether it is a git
repo at all. Resolution order isprojectId→repoId→ normalized remote.claim_intentstored claims without theprojectIdit had just used for the lookup, so
a claim could be written under a key no reader would compute. Caught by a new test.
Fixed — it never fails silently again
claim_intentreturnsprojectWarningwhen another active agent is on a repo with
the same name under a different owner. Advisory only — the claim still succeeds, and
matching on name is deliberately never used to partition, because two teams can both own
a repo calledapi. The original failure was the silence, not the mismatch.
Fixed — presence and duplicate detection
- Presence came only from
heartbeat_worker, which thetower workdaemon calls and
an ordinary agent session never does. An agent claiming and messaging all day read as
"seen earlier" forever. Any authenticated tool call now refreshes presence. propose_intentignored delegated work. It matched other stated intents but not
open or accepted tasks, so it returnedproceedwhile the same job sat in the queue. It
now matches against both.
Fixed — the blocker is finally symbol-level
hooks/pretooluse-tower.mjspassedsymbols: []. Symbol-level detection is the
headline claim, and the one layer that actually blocks an edit ignored it — so two
agents in different functions of one file blocked each other. The hook now locates the
edit'sold_stringin the file, asks tree-sitter which declaration encloses that
offset, and claims that symbol. NewSymbolExtractor.extractRanges()and
symbolAt()back it. Falls back to a file-level claim for aWrite, a new file, an
unsupported language, or an edit between declarations — over-claiming is safe,
under-claiming is not.
Fixed — decisions no longer leak between teams
log_decision/get_decisionswere global. On a shared server one team's
architecture notes surfaced in another team's recall — the same silent cross-partition
leak as the fork bug, one table over. Decisions now carry a project key and are scoped
when the caller names one. Rows written before scoping stay visible to everyone, which
is what they already were.
Fixed — the proxy can no longer take the editor down
cmdServedialled the hosted server before serving stdio. A cold host (Render's
free tier sleeps and takes ~50s to wake), a stale token or a dropped network killed the
process before it spoke MCP, leaving the editor with a dead server and no Tower tools
at all — worse than the bug it replaced. The connection is now lazy, retries once on
a fresh socket, and survives sleep and redeploys. An unreachable server surfaces as a
loud per-call error saying coordination was not enforced, never as silence.
Board
Split "who's connected" into three live tables, all from data the snapshot already
carried: Live agents (status / runner / last seen), Active claims (agent / file /
symbol / purpose / ETA) and Active work (task / from / to / status / size).
Upgrading
Re-run tower setup --url <your-server> --token <token> --hooks on every machine so
.mcp.json switches to the proxy form. A direct type: "http" entry still works but
cannot supply identity, which is the bug. Teams whose clones share no git history should
also commit projectId to .tower/policy.yaml.
0.9.1 - the Node check that cost a user their first command
The Node version check was wrong, and it cost the first outside user their first command.
node:sqlite landed in Node 22.5, but stayed behind --experimental-sqlite until
23.4 (backported unflagged to 22.13). The guard only checked >= 22.5, so two
whole windows — 22.5–22.12 and 23.0–23.3 — passed the check and then died on
require("node:sqlite") with a raw ERR_UNKNOWN_BUILTIN_MODULE stack trace instead of
an answer. Reported from a live setup on Node 23.3.0.
Fixed
requireModernNodenow gates on the versions wherenode:sqliteis actually
unflagged: 22.13+, 23.4+, or 24+. The error names your version, the upgrade, and
the flag.- A flagged Node is now accepted when you have opted in yourself, via either
--experimental-sqliteinexecArgvorNODE_OPTIONS. Running
NODE_OPTIONS=--experimental-sqlite tower <command>on 23.3 is a supported path, not a
workaround that trips the guard. engines.nodeis now>=22.13 <23 || >=23.4, so npm warns on the flagged window
rather than claiming those versions work.- Corrected the "Node 22.5+" claim in the README badge, quickstart, CONTRIBUTING,
CLAUDE.md and the launch/demo docs.
Note
This makes the failure legible; it cannot make node:sqlite exist. On 22.5–22.12 or
23.0–23.3 you still need NODE_OPTIONS=--experimental-sqlite, or an upgrade to Node 24.
0.9.0
Collision detection fires for the first time. A live two-agent session against a
hosted instance found that every collision check returned conflicts: [] — including
two agents editing the same file at the same moment. The matching engine was correct all
along; the lookup key meant it never ran. This release is that fix, plus the things
testing found around it.
- One repo means one coordination space. Claims are partitioned on a key resolved
server-side, not on whatever string the caller happened to send.repoId— the
repository's root commit sha — is identical across every clone, fork and mirror, so
a fork and its upstream now coordinate; previously they were modelled as unrelated
projects, which is precisely the case where coordination matters most (participants
share no working tree). Callers that send norepoIdfall back to the normalized URL,
sogit@…vshttps://…vs different casing no longer splits one team into isolated
groups that never see each other. Existing databases are backfilled on open. - Agents on different branches can finally see each other. Branch was part of the
lookup key, so detection was disabled by default in the common case — agents normally
work on separate feature branches, and two of them rewriting one function still produce
a single merge. Cross-branch overlaps now report assoftrather than as silence. - A hard conflict is actually refused.
claim_intentused to return conflicts and
register the claim anyway, which made severity decorative: an agent that ignored the
response behaved exactly like one that never checked. It now returns
blocking: true,recommendation: "stand_down"and writes nothing. Pass
force: trueto override; the override is recorded so the board can show who forced
past what. Breaking:claimIdis now nullable. propose_intent— catch duplicated work before the tokens are spent. The session's
real loss was not a merge conflict: two agents independently researched and wrote the
same article under different filenames, git merged them cleanly, and the result was two
full research-and-write cycles for one deliverable. The new 19th tool takes a plain
English description of what you're about to do and matches it against what everyone
else is doing — so it catches a duplicate even when the file paths differ, and it
fires before the research rather than after. Matching is lexical and dependency-free:
no model, no embeddings, and no network call, because Tower makes no network calls you
didn't configure.- The board stops claiming nobody is there. Presence used a single 30-second window
refreshed only by an explicitheartbeat_workerthat interactive sessions never call,
so the board read 0 agents online during active multi-agent work. There are now two
windows — "working" and "still here" — three states (working/idle/offline),
and the roster is joined to each agent's live claims, so you can see what everyone
is doing. The self-contradictingconnected — 0 worker(s) onlineheader is split into a
link-state indicator and an agent roster. - Claims track their owner's liveness. A heartbeat extends the claims that agent
holds, so a live agent on a slow task no longer has its claim expire underneath it, and
the newSessionEndhook releases claims when an editor closes instead of leaving
phantom blocks until the TTL lapses. - stdio
serveno longer writes locally in silence. It calledbuildService()
unconditionally and never consultedTOWER_URL, so a team could believe it was
coordinating on a shared server while every write went to a SQLite file on one laptop —
with no visible symptom. It now explains the problem, asks when there's a TTY, and
refuses when there isn't (an MCP client spawns it with no TTY, so there's nobody to
ask).--httpis unaffected; it is the shared server. accept_tasksays why it failed —not_found/already_accepted/
awaiting_approval/rejected. Losing a race is the normal outcome of a broadcast
and must not look like an error. It also accepts a unique id prefix, since the CLI and
board both print ids truncated.- Hooks: three new, and silence now means something.
SessionStartregisters the
session,PostToolUsekeeps presence and claims alive,SessionEndreleases them. The
two existing hooks still fail open — a Tower outage must never brick editing — but they
now say so, because a silent pass was indistinguishable from a check that never ran.
tower init --hookswrites all five into.claude/settings.json, merging with what
you already have; the hooks shipped in the repo before but nothing installed them, and
an unwired hook enforces nothing. - The test suite no longer talks to production.
remoteConfig()readsprocess.env,
so on any machine withTOWER_URLexported — the normal state for anyone running a
worker — unit tests silently hit a live server and failed against real claims. The
suite is now hermetic. - 325 tests (up from 262), 80% coverage gate green.
0.8.0
- Your agent gets tapped on the shoulder. New 18th MCP tool
pending— a
read-only count of unread messages + open tasks waiting for an agent, marking nothing
read. It powerstower nudge [--agent <id>] [--json](local or remote; silent when
nothing's waiting) and a UserPromptSubmit hook (hooks/userpromptsubmit-nudge.mjs,
wired in.claude/settings.example.json), so an interactive Claude Code agent sees
"2 tasks waiting" on its next prompt. MCP has no push channel; this closes the gap
without running a worker daemon. - Delegated tasks can finally run git, tests, and builds. The headless
clauderunner
defaults to--permission-mode acceptEdits, which gates Bash behind a TTY that isn't
there — so a task could write code but never verify or commit it, then report a
misleading "I couldn't push".tower work --permission-mode bypassruns the runner
with--dangerously-skip-permissionsso an approved task can run commands (acceptEdits
stays the default; unknown values are rejected). The task prompt now also states that
the worker owns commit and push, so the runner stops attempting git itself. - A run that changed nothing no longer shows green. The worker reports
filesChanged; a 0-file run renders an amber "done · no changes" chip on the
board and says so in thetask_update. Stored in a new nullabletasks.filesChanged
column, migrated in place — existing databases upgrade cleanly. setup --hooksinstalled a post-commit hook that could never run. It was hardcoded
tonode packages/cli/dist/index.js, a path that only exists inside this monorepo, and
the failure was swallowed — so claims never cleared and teammates saw phantom locks. It
now callsnpx -y tower-mcp, matching the pre-commit hook.setupadds.tower/to your.gitignore, so the local SQLite db stops showing up
as an unexplained binary ingit status.- Two scary warnings gone from first run. Every command printed Node's
DEP0190
shell-args deprecation ("can lead to security vulnerabilities") and thenode:sqlite
ExperimentalWarningbefore any useful output. Both silenced — the sqlite filter is
scoped to that one warning, everything else still surfaces. - Node requirement stated honestly: 22.5+, not 22.
node:sqlitelanded in 22.5, and
below it you now get a one-line explanation instead of a rawCannot find modulestack
trace.engines,doctorand the docs all agree now. - Board polish — roomier padding, wider right column, focus rings, and the send-form
hint no longer overflows its row on narrow phones. - Repositioning, and a copy audit against the code. Tower now leads with multiplayer
for AI coding agents; collision detection is the safety floor, not the pitch. Every
public claim was re-checked against the implementation and corrected where the code
didn't back it: the board is a live status board refreshed every 2s, not a live
session transcript; the site had advertised "seventeen tools" and omittedpending;
"real-time" and "TTL countdowns" are gone; and the PreToolUse hook's real granularity is
now documented — it claims whole files, so two agents in different functions of one
file still block each other. - The npm package now ships a README and LICENSE (the package page was blank).