Squadra 3+

Static, behavioral and dependency checks, excluding tests/. Passing means no HIGH or CRITICAL findings; lower-severity findings remain in the report. Click the badge for results.

Watch the 80-second tour — turn the sound on in the player:

It installs with /plugin in Claude Code and Codex. Install: see Installation.

3.9.1

• Interface fixes. More room on the System skills page and between its blocks; bold text in skill descriptions shows as bold; the project goal and the reading help appear on the overview only; more badges at the top of this page.
• Plugins: memoranda 1.0.4, Playwright 1.0.5, Sentry 0.1.2.

3.9.0

• System skills that activate on their own. errata brings back the lessons the squad recorded after a failed proof, a read that asked for changes or a closed defect fix, when a new task touches the same files or words. rasoio is a lean-code lens for code reads that declares how many lines could go. previsione compares a new task with similar finished ones and suggests a route. errata and rasoio record each activation in the registry; previsione is computed on demand and records nothing.
• A System skills page in the dashboard lists the three skills with what they do, their recorded activity and the security scan result for their files.
• Faster whole-suite proofs. tools/parallel_tests.py runs the suite across processes and fails if any collected test did not run: about three times faster on our test machine.
• Reviewer pool. A task can name up to four readers; the first to confirm takes the read. Small light changes can be read once at the release gate, and they show as closed but not yet read until then.
• Quick checks before proof and delivery. A project can declare fast checks, such as mirrored files being identical, that run on the exact files before prove and deliver.
• A lighter README. Same sections, about half the reading; the details moved to the guides.
• The release leaves on time. A rule, not a choice: the cut-off is two hours after the scope is fixed; final reads look only at how the lanes were joined when each lane was already read; a read nobody picks up moves to a free reader.
• Plugins: memoranda 1.0.3, Playwright 1.0.4, Sentry 0.1.1.

3.8.0

• Defect fixes show that their test fails without them. Declare a fix with task --defect-fix; before it closes, challenge runs the agreed tests on the original and on the delivered code.
• Sentry plugin (preview). It brings sanitised error summaries into Squadra. FREE · Sponsored by memoranda. Tested with a synthetic connection only.
• A friendlier Reads view. It keeps the table's scroll position, shows cards on phones and loses the blank band; numbered plugin steps show one marker.
• Plugins: memoranda 1.0.2, Playwright 1.0.3, Sentry 0.1.0.

• One registry for every window. Assignments, proofs and decisions stay on your computer, not in a chat's memory.
• Whoever writes it does not review it. Every change is checked by a window that did not write it.
• Proof bound to the exact code. If the code changes after the proof, proof and review no longer count.
• Confirmed before work starts. A task starts only when its recipient confirms receiving it.
• Questions with the sentence ready. When a decision is yours, you get the options, a recommendation and the exact words to answer.
• A dashboard in plain words, in Italian or English, to follow everything live.
• Claude, Codex and Cursor together, and open to community plugins.

Squadra lets several AI agent windows work on one project as a team you can follow: one window coordinates, another makes the change, and a third, never the author, checks it. It is built for where agent work usually goes wrong: an author reviewing its own work, a green test that ran on different code, a decision lost in a long conversation. Three parts work together: the skill, which the agents follow; the CLI, which records each step; the dashboard, where you read the record. Each window can work in its own copy of the code, a checkout, while all of them share one registry.

Cursor windows work interactively only: you open the Cursor agent (cursor-agent) yourself, and it uses the squadra CLI like any other window. Squadra never starts it, because Cursor runs team, user and enterprise hooks outside any sandbox and cannot switch them off.

How it works.

1. Install and tell the first window: “Use squadra for this project. Use the registry at /path/to/registry. Find the other windows and introduce yourself; describe the work in plain words.”
2. Open the other windows on that registry. The first one coordinates; each window confirms its assignment before starting.
3. Open the dashboard with squadra dash --root /path/to/registry --open (with the plugin install, ask the agent to open it) and follow each task: confirmation → work → executed check → another window's review → coordinator closure.
4. When Needs you asks for your input, answer the coordinator; elapsed time is not an answer. Closed work is never published automatically.

Words used below.

More terms, such as log and exit, UTC, PID and cwd: the page guide.

Requirements: Python 3.12+, Git and the Python standard library. Node.js runs the dashboard's JavaScript checks in the test suite and in selftest: without it they fail, they are never skipped. A browser for the dashboard; the Codex or Claude CLI only for the native runners. macOS/POSIX is the tested process environment; Windows process controls and recovery with submodules, LFS or sparse checkouts are not qualified.

In Claude Code:

/plugin marketplace add dagoSte/squadra
/plugin install squadra@squadra

In a terminal, for Codex:

codex plugin marketplace add dagoSte/squadra
codex plugin add squadra@squadra

The plugin brings the skill, its scripts, references and dashboard. It does not put the squadra shell command on your PATH: agents run python3 <skill folder>/scripts/squadra.py. Use either the plugin or the standalone installer, not both, so the skill is not registered twice.

git clone https://github.com/dagoSte/squadra.git
cd squadra
python3 -B scripts/install.py \
  --backup "$HOME/.local/state/squadra/install-backup-001"
export PATH="$HOME/.local/bin:$PATH"
squadra --version

Install from a clean, committed checkout with a new backup directory each time; the installer keeps your previous skills and launcher, so you can roll back. Without installing, run python3 -B scripts/squadra.py <command>. Details and rollback.

With /plugin. In Claude Code, run /plugin marketplace update squadra, then /plugin update squadra@squadra, then restart Claude Code. For Codex, run codex plugin marketplace upgrade, then codex plugin add squadra@squadra again.

With the standalone installer. From 3.6.1 on, releases keep their history: run git pull, then the installer again, with a new backup folder each time. A checkout of 3.6.0 or earlier needs git fetch origin and git reset --hard origin/main instead, which discards any local edit in that checkout.

git pull
python3 -B scripts/install.py \
  --backup "$HOME/.local/state/squadra/install-backup-002"
squadra --version

Every release raises the version number. Plugins installed from the Store keep their version until squadra plugin install <name> runs again from the new release (Plugins bundled in your release). Open windows keep the version they read until they restart, and a running squad keeps its protocol until you switch it explicitly.

The first window that applies the skill becomes the coordinator: it finds every Codex, Claude or Cursor window of the project and introduces itself to each one. An existing coordinator in the same registry that answers a ping keeps the role; a pending or expired ping never transfers leadership or resources. The full rule is in the skill; census limits and joining in detail are in startup and presentation.

Then create one durable registry, outside temporary folders:

export SQUADRA_ROOT="$HOME/.local/state/squadra/my-project"
squadra init --name "My project" --project /path/to/project
squadra agent --id coord --identity window-01 \
  --role coordinator --client codex --repo /path/to/project
squadra agent --id builder --identity window-02 \
  --role builder --client claude --repo /path/to/builder-checkout
squadra agent --id reader --identity window-03 \
  --role reviewer --client codex --repo /path/to/reader-checkout
squadra status
squadra dash --open

The coordinator gives independent work to every available window at once (Codex, Claude, interactive Cursor), and no window waits idle while some exists: one builder per tree, reads on frozen copies, and a release's final read by a Claude reader and a Codex reader at the same time. The coordinator reads its registry mail at every step, because a window may get work directly from the owner and report it only there.

Every update to the owner shows the table from squadra board: In progress, To do and Done, columns Window | Work | State | Time (approx.), «Done X of Y» at the end, then «Tu adesso: …» (what you do now). Times are measured; estimates are marked as estimates; no made-up percentages.

Read before you cite; record a decision before a pinned test changes; parallel lanes own their files; state the cost and a cap before spending; the owner chooses the review mode; every close says how the next task can go faster; and a release leaves on time: a cut-off two hours after its scope is fixed, final reads scoped to the integration when every lane was already read, the parallel runner as release proof, and a stalled read moved to a free reader; a fix round fixes only the problem, read only by whoever raised it. Every rule in full: the skill.

You talk to the agents in plain words; they run the commands. Copy a prompt into the window it is meant for and replace the paths and names. Every prompt works in Codex, Claude and interactive Cursor windows that have the squadra skill installed.

Start a squad (the first window becomes the coordinator)

Use the squadra skill for this project. Shared registry: ~/.local/state/squadra/atlas.
Read the project mandate first. Find the other Codex, Claude and Cursor windows working on it,
introduce yourself to each one and wait for their confirmations.
Then write a plain-words brief of the project and show me the progress table.

Join an existing squad

Use the squadra skill. Shared registry: ~/.local/state/squadra/atlas.
Register this window, introduce yourself to the coordinator and wait for a role.
Do not take any task or resource until your assignment is confirmed.

Assign work (coordinator)

Create a task "Key rotation service" for the builder window, with the checkout at
/path/to/builder-checkout and the reviewer window as independent reader.
The proof is the whole test suite. Write a brief that says why the task exists,
for whom, and when it is finished. Then hand it over and wait for the builder's ACK.

Where are we?

Show me the progress table from the registry: in progress, to do and done, with who is doing what.
Tell me in one sentence what is blocked and whether anything needs my decision.

Confirm your assignment, then build it in your own checkout.
When the change is ready, freeze it, run the agreed proof on the exact files and deliver it
to the reviewer. Record one output with the result and the next step, then stop.

Confirm the review handoff you received, then read the frozen candidate on a private copy.
Run your own probes, write the report first, and record your verdict with the requirements
it covers. Only grave findings block; list the rest as follow-ups with an owner.

Check that the proof and the review concern the same candidate, then close task T1.
Take a checkpoint and show me the progress table. Do not publish anything.

Open the squadra dashboard for this registry in my browser.

Record my decision in the registry, linked to task T1, as typed here:
"Keep the old keys readable for a month." Then tell the builder.

Pause the squad: stop only the processes you own, save the registry and the code, and prove
the save with a real restore check. I will tell you when to resume.

Resume the squad: re-read the mandate and the registry, reconcile sources and resources,
record the resume and tell me the next step.

Your context is getting full. Save a checkpoint and a complete handover with task, identity,
branch, open findings and the exact next step, so a fresh session can continue.

Show me the plugin page for "memo" in the dashboard: what it is, its settings and its drafts.

I selected drafts and pressed "Send for review" in the dashboard. Read the plugin's AGENTS.md
and run only its consumer for the pending request, within your existing permissions.
Then tell me the outcome.

Before closing T1, answer the "worth remembering" question. Write da-ricordare.json with one
sentence per decision, constraint or trap, each with its evidence and how sure you are,
and no secrets, personal data or private paths. Attach it to your closing output.

We just closed T4. Look at where its time went in the dashboard and tell me, in one line,
how the next task can go faster. Then apply it when you assign the next one.

Work in parallel: give every free window an independent task now, each with its own tree
and its own files, and merge the lanes yourself when they deliver.

Show me the progress table with the time column: the board's measured times, plus your
estimate of what remains for each task, marked as an estimate.

Before you report a number, an id or a path, read it from a command's output, not from memory.

If a test pins something I asked to change, record my decision first, then change the test
and the code together.

Before any paid call (models, voice, images), tell me the expected cost and a cap, and stop at the cap.

For this release use one final review only: merge the lanes as they deliver, then a Claude
reader and a Codex reader read everything together.

Open Reads in the dashboard to see recorded plan and code verdicts, in total and by task, and changed versions submitted after a request for changes, each linked to its report and task story. These are counts of reads and later versions, not of prevented defects or successful fixes; repeated reads stay separate records, and closed and replaced tasks stay included.

Readers can add bounded observations with review --findings-file; see the details.

New to Squadra? Try these twelve steps once, end to end, on a test project. A window is one working session: a Codex, Claude or Cursor agent, or a person. Every window uses the same registry.

1. Install and set export SQUADRA_ROOT=... in every window.
2. Create the registry and register each window with init and agent.
3. Find the windows and introduce yourself: census lists them without writing; send and transport deliver the introduction; each window answers with ack.
4. Say what the project is in plain words with brief --project.
5. Assign and explain the first task with task and brief --task.
6. The builder confirms and starts: ack, then start.
7. The builder proves and delivers: prove runs the agreed check on the exact files; deliver hands them over.
8. Someone else reads: a reader who did not write the work records a verdict with review.
9. The coordinator closes: check, then close.
10. Check who still answers: ping --all; ping --sweep puts an unanswered window in stand-by, which stops nothing it runs.
11. Open the dashboard with dash --open; «How to read this page» explains every term.
12. Record what the owner says with decision, --owner-words, --channel and --task.

Each step in more detail: startup and presentation.

squadra census --project /path/to/project
squadra send --actor coord --to builder --id HELLO-builder --body-file /evidence/introduction.md
squadra transport --actor coord --message HELLO-builder --via manual
squadra ack --actor builder --message HELLO-builder
squadra brief --actor coord --project --file /evidence/project.md
squadra task --actor coord --id T1 --owner builder --reviewer reader \
  --title "Key rotation" --repo /path/to/builder-checkout \
  --scope-file /evidence/scope.md --proof-file /evidence/argv.json
squadra brief --actor coord --task T1 --file /evidence/t1.md
squadra ack --actor builder --message assign-T1
squadra start --actor builder --task T1
squadra prove --actor builder --task T1 -- python3 -B -m unittest discover -s tests -v
squadra deliver --actor builder --task T1
squadra ack --actor reader --message "review-ID-RETURNED-BY-DELIVER"
squadra review --actor reader --task T1 --verdict accepted --report /evidence/code-read.md
squadra check --actor coord --task T1
squadra close --actor coord --task T1
squadra ping --actor coord --all
squadra ack --actor builder --message "PING-ID-RETURNED-BY-PING"
squadra ping --actor coord --sweep
squadra decision --actor coord --reason "Owner instruction" --task T1 \
  --owner-words "Keep the old keys readable for a month" --channel typed-here
squadra dash --open

The Summary on a synthetic Atlas registry (Italian, dark theme). Recorded texts such as briefs, the owner's words and messages stay as written, here in Italian. The examples contain no customer data and do not measure model quality.

squadra dash --open opens on the Summary: one sentence and four tiles say where the work stands, Needs you appears only when something waits for the owner, and one card per task shows its steps, who builds and who reads, and the next step. Each card opens the task's story in time order.

Charts, sortable tables, a «Read» dialog for long texts, sounds and notices when a step closes, IT / EN and light / dark: every part of the page, view by view, with every screenshot in both languages.

Views: Summary, Windows, Tasks, Mail, Communications, Decisions, Runs, Outputs, Timeline and History; what each one shows is in the page guide.

Communications shows who talks to whom, in plain sentences. Sent is not read: only a recorded confirmation proves reading.

Refresh and safety. The page refreshes every two seconds, pauses while the tab is hidden, and refreshes immediately when you return. It offers text search and opens registered artifacts in a dialog. It is read-only except declared settings and selections of installed plugins; registry actions use the CLI. It listens on 127.0.0.1, checks Host and token, checks Origin for settings and selection writes, and loads no remote scripts or CDN. --port picks a port (by default a free one); Ctrl-C closes the dashboard server, not the agents; a disconnected page keeps its last view with a warning.

A plugin brings another tool's data into the dashboard: a folder $HOME/.squadra/plugins/<name>/ with a plugin.json manifest, where a separate program, the plugin's producer, writes data panels. The Plugins menu group lists every installed manifest, or says «No plugins installed» and explains where plugins go; select one to see its data for the open registry.

Plugin folders must belong to you and must not be writable by group or others; the Store creates private ones.

Build your own. The contract is open: anyone in the community can publish a squadra plugin, free or paid. A plugin is data plus a separate program. The dashboard and CLI never run plugin code; agents run it only as its AGENTS.md says, under the file's trust conditions and the user's existing permissions. Start from the plugin contract.

Step by step: the plugin authoring guide builds a working plugin, tests it with the dashboard and explains how to publish it, free or paid.

Settings, results for each service, selecting drafts and the Store's update rules: the plugin page in detail.

Who runs the request? An installed plugin may ship $HOME/.squadra/plugins/<name>/AGENTS.md with instructions for agents. The coordinator window reads it at start and resume and runs only the commands it specifies, within existing permissions: the producer after a close, the consumer when the dashboard shows a pending request, then reports the outcome. This requires a regular file owned by the user, not group- or other-writable and not a symlink. Without a valid file, the request stays pending and the coordinator says so; you have no command to run. The dashboard never reads, writes or runs this file. This file never widens permissions and never authorizes installation, push, publication or decisions reserved for the user; for anything beyond running that plugin’s producer or consumer, stop and report.

Exact schemas, sizes, limits and refusal codes: plugin contract, about metadata, homepage and icon.

Open Plugins → Store to see the running release's catalogue, its install commands and local installation status. It refreshes only when opened or when you choose Refresh catalogue; there is no install button. Homepage links open on a click in a new tab. Ask the coordinator to run the displayed command, which targets this installation of Squadra.

squadra plugin list shows the release's catalogue and squadra plugin install <name> copies a bundled plugin; nothing is downloaded or run. With a /plugin installation, ask the coordinator to run them through python3 <release root>/scripts/squadra.py.

Submit plugins by PR or the maintainer's contact email for analysis; MCP plugins come first. Inclusion and its review date refer only to the accepted version. This is a release-local catalogue, not a remote marketplace or automatic execution service.

The memoranda Store plugin collects declared lessons and proposes them to memoranda.dev; it never approves them. Installation is free; the connected service starts with a free trial, then is paid.

Try browser checks: the optional Playwright MCP plugin prepares checks for a task, saves your selection and lets an authorized agent use its connected browser tools and report the outcome. Installing the data plugin does not install or activate MCP.

Bring app errors in (preview): the optional Sentry plugin brings sanitised summaries of errors from your authorised Sentry connection into Squadra, so you can select issues for analysis and follow their tasks. FREE · Sponsored by memoranda: development funded by memoranda, free for all users. Tested with a synthetic connection only; a live Sentry connection is not yet verified.

Publish your own plugin: follow the authoring and distribution guide for a working example, tests, permissions and version compatibility. These data plugins are separate from installing Squadra itself with /plugin; publishing a package does not automatically list, install or approve it.

The selected box is an owner instruction relayed by the coordinator: who, when, the exact words, the channel and the recorded links.

Briefs are short plain-text descriptions written by the coordinator, read before any identifier.

squadra brief --actor coord --project --file /evidence/project.md
squadra brief --actor coord --task T1 --file /evidence/t1.md

# Atlas
Atlas keeps customers' access keys in order. This phase puts the key service in production.

## Steps
- [x] Key service plan
- [ ] Key service in production

## Glossary
- JEV: job engine verification

Recorded links.

squadra decision --actor coord --id D-SCOPE --task T1 \
  --follows ask:Q1 --follows decision:D-EARLIER \
  --owner-words "Keep the old keys readable for a month" --channel relayed \
  --reason "Owner instruction relayed by the coordinator"

Each box in the graph is a recorded fact; solid lines are recorded links, dashed lines only mean «later, in the same task». The rules for briefs, decision links, replacing a task and reading the graph are in the details.

Choose the path. The builder proposes a path, the non-author reader confirms or disagrees, and the coordinator settles it with a recorded reason, answering the five questions of the IT/EN triage page. No regex, path pattern or score chooses the path.

• Fix now with proof: reversible, Q1 no and Q3 yes; a brief non-author check before closure.
• One code read: an ordinary bounded choice, with scope, bound proof and an independent review.
• Full path: Q1 yes or unknown, Q2 unresolved, material silent harm under Q5, or an existing mandate: an accepted plan before construction, then proof, a non-author read and the required checks.

The rules of the read: only a grave finding blocks; the rest is fixed now with a non-author check or recorded as a follow-up with an owner and a trigger. Never hand commands to the owner. All the rules: details.

Contract, proof, review and close. Keep evidence outside the delivered checkout: scope.md (behaviour, owned paths, dependencies, resources, checks, release boundaries), argv.json as an exact argument list, not a shell string (["python3", "-B", "-m", "unittest", "discover", "-s", "tests", "-v"]), and an optional requirements.json ([{"id": "R1", "text": "Values add up correctly"}]).

squadra task --actor coord --id T1 --owner builder --reviewer reader \
  --title "Verify the total function" --repo /path/to/builder-checkout \
  --scope-file /evidence/scope.md --proof-file /evidence/argv.json \
  --requirements-file /evidence/requirements.json
squadra ack --actor builder --message assign-T1
# Full path: a plan read by a non-author before construction.
squadra plan --actor coord --task T1 --file /evidence/plan.md
squadra review --actor reader --task T1 --stage plan \
  --verdict accepted --report /evidence/plan-read.md
squadra start --actor builder --task T1
# Implement the change, then freeze the source.
squadra prove --actor builder --task T1 --covers R1 --covers R2 \
  --timeout 120 -- python3 -B -m unittest discover -s tests -v
squadra deliver --actor builder --task T1
squadra inbox --agent reader
# Use the exact message ID from deliver; read the frozen candidate and write the report first.
squadra ack --actor reader --message "review-ID-RETURNED-BY-DELIVER"
squadra review --actor reader --task T1 --covers R1 --covers R2 \
  --verdict accepted --report /evidence/code-read.md
squadra check --actor coord --task T1
squadra close --actor coord --task T1

Options, budgets and what prove, deliver, review and check record: details.

Completion does not grant publication authority. The complete protocol is in work, proof and review.

squadra send --actor coord --to builder --id M1 \
  --task T1 --body-file /evidence/message.md
squadra inbox --agent builder
squadra ack --actor builder --message M1
squadra output --actor coord --task T1 --file /evidence/update.md \
  --next "Independent read of the frozen candidate" --artifact /evidence/result.json

Save one substantive output per completed step; its declared next step is not evidence that anything happened. Replies, expected recipients and transports: details.

At close, record what is worth remembering (a decision and who took it, a constraint, a trap already paid for) in da-ricordare.json, attached to the closing output, each with its evidence and how sure you are. Never put secrets, personal data or private paths in it: registered artifacts are immutable, so an accidental secret cannot be removed. If a memory service is in use, declare at close and do not propose the same item through another channel; nothing is proposed or approved by itself. See the schema and examples.

ask records a question before it is shown, with at least two options of distinct id, label and say (the sentence to say); buys, costs and example are optional.

[
  {"id": "A", "label": "Keep this scope", "say": "Continue with the reviewed scope"},
  {"id": "B", "label": "Plan first", "say": "Plan the optional integration first"}
]

squadra ask --actor coord --id Q1 --task T1 --waiting builder \
  --question "Which scope should we build?" \
  --options-file /evidence/choices.json --recommended A
# Only after the actual owner's answer:
squadra decision --actor coord --reason "Owner chose scope A" \
  --answers Q1 --choice A --channel typed-here \
  --owner-words "Continue with the reviewed scope"

Relayed words, withdrawals and what never counts as a decision: details.

Waits are computed when a view is read; defaults in seconds: ACK 900, delivered 3600, reviewed 1800, heartbeat 1800, alive 300. A warning never retries, reassigns or releases anything. Reserve gates, ports and databases before use. Stand-by stops nothing: it does not cancel processes, release resources, transfer roles or reassign work.

Thresholds, presence calls and why every window should run the same version: details.

Agents checkpoint without waiting for you to ask. This is the skill's required agent workflow, not a background service or an invisible token meter.

squadra checkpoint --to /durable/checkpoint-001
squadra save --actor coord --to /durable/recovery-001
squadra restore-check --from /durable/recovery-001 --to /durable/restore-test-001
squadra pause --actor coord --reason "Owner requested stop"
squadra doctor
squadra resume --actor coord --reason "Owner explicitly resumed"

checkpoint copies only the registry; save, coordinator only, adds every registered Git repository and its unfinished work; restore-check proves a package by actually restoring it into a new folder. When context fills up, the agent saves a handover before continuing. Details.

Limits of recovery: the secret filters are partial, not a full scan of history and artifacts; a copy on the same disk does not survive a disk failure; --declared-offsite is a declaration, not verified remote storage. The complete contract is in recovery and context handover.

run starts a new non-interactive Codex or Claude turn and never attaches to an open window; exit 0 alone is not a valid result. Cursor is refused: Squadra does not launch cursor-agent. See the summary and runtime contracts before invoking runners automatically.

For a task declared with task --defect-fix, closure requires proof that the regression fails without the change: the same test bytes fail by assertion on the registered base and pass on the exact candidate. A coordinator may declare an exception with a reason; the independent reader checks it, and it never appears as a passed challenge. See the complete example and limits.

squadra selftest --output /durable/selftest-001

selftest tests the toolkit with no model calls, not your product or a model; the offline comparison uses fake clients and never claims a winner. See the summary and challenge and benchmark contracts.

Always write through the CLI, never into the generated files; doctor checks the chain and the artifacts. Integrity is not proof that claims are true, nor cryptographic authentication of identities. More.

The coordinator may declare task --route light for a bounded, reversible change: at most 80 added plus deleted lines in four files (policy light-v1 / P2), counted from the original clean Git base. Scripts, plugin bundles, instruction files and normative contracts stay protected, and a security impact or a required whole gate still takes the full route. The light route skips the plan read and uses the agreed targeted proof; a non-author read, the bindings and the budgets remain. Only the coordinator can promote a task to the full route, and promotion never resets a budget. See the light route and the details.

Every command, grouped by purpose: 48 subcommands, plus --version. Use squadra <command> --help for the flags; registry commands accept --root or SQUADRA_ROOT. «Coordinator only» marks what only the coordinator can record: task, route, supersede, brief, close, ask, decision, settings, pause, resume, save, standby, ping --sweep, and the receipt that restore-check writes into the live registry. Without installing, the same commands run as python3 -B scripts/squadra.py <command>.

What Squadra cannot do.

• Trusted windows only: Squadra coordinates trusted local windows.
• Not guaranteed: that a window wakes up, a view of every token window, control of unregistered clients, or authenticated identities against an attacker who shares your account.
• Judgment stays yours: native bindings do not replace judgment about assertions, correctness or the authority to publish.
• Not a backup: local recovery is not an offsite copy.
• Not acceptance: synthetic checks are not acceptance for production or for model quality.
• No dashboard button publishes anything or runs commands.

Skill · Setup · Work/proof/review · Native runners · Recovery/context handover · Challenges/benchmark · Plugins · Plugin authoring

The detailed protocol references are in English. This README and the Italian edition describe the same functions and the same boundaries.

Squadra is free and open source, and it grows with the people who use it, extend it and talk about it.

memoranda supports the development of Squadra. memoranda is shared memory for your AI agents, with sources, approvals and a record of every decision.

Everyone who builds a plugin, reports a problem, improves the docs or helps someone get started is part of Squadra. Code contributors appear on GitHub's contributors page; each plugin's publisher is named on its Store card, next to its version and licence.

Organisations that would like to support Squadra can say so in an issue. There is no sponsorship programme yet, so the form is agreed together.

Squadra is a community project: it gets better with every plugin, report and shared idea.

• Build a plugin and offer it to others. The plugin authoring guide builds a working plugin step by step and tests it with the dashboard; section 9 explains how to propose it for the Store.
• Report a problem or suggest an idea in the issues.
• Improve the code or the docs with a pull request. Every proposal is read before anything is merged.
• Help Squadra spread. Star the repository, share it with your team and tell others how your squad works: a prompt or a short write-up helps someone start.
• Use it and tell us how it goes. What works, what gets in the way, what you would add: real use is what shapes the next releases.

Developed by Stefano D'Agostino · GitHub