AgentFlight

Features

What it does well.

See it in action

A closer look.

agentflight · finish

agentflight · status

agentflight · replay

New in 0.16.0

agentflight guard, the live trust monitor.

AgentFlight Guard watches local trust while coding agents work; the Review Passport proves the final result. ProjScan finds the risk, AgentLoopKit controls the work, AgentFlight proves the result. 0.16.0 leads with `agentflight guard`: run it beside your agent and it refreshes the local trust state, readiness, proof gaps, scope drift, Baseframe gates, and one next action, without running hidden commands or sending source anywhere. When the work is ready, `agentflight finish` writes the Review Passport.

Guard, the live monitor

`agentflight guard` watches the trust state as the agent works: readiness, changed files, verification counts, proof gaps, scope drift, Baseframe gates, the trust signals worth acting on, and the one next action. It reads the same local evidence as `status` and runs no hidden commands.

Watch, one-shot, or JSON

`agentflight guard` refreshes on an interval, `guard --once` prints one summary and exits, and `guard --format json --once` emits a structured summary. One-shot exits 0 only when readiness is ready for review or a clean worktree, so it fits a loop or a pre-finish gate.

Guard reflects proof, verify captures it

Guard never creates proof. `agentflight verify -- <command>` records the command, timing, exit code, pass or fail, and the stdout and stderr paths, and Guard updates the moment that proof lands.

Finish writes the Review Passport

When the work is ready, `agentflight finish` writes `.agentflight/reports/<session-id>-review-passport.json` and `.md` plus the handoff, report, replay, and resume. In a Baseframe session it also writes `.baseframe/evidence/<task-id>/agentflight-result.json` for AgentLoopKit to reconcile.

Source-free, local-only

Guard and the passport store metadata only: paths, commands, statuses, counts, timestamps, artifact paths, and hashes. No source upload, no telemetry, no PR posting, no login, and no LLM calls.

Baseframe Suite

Baseframe Suite Integration v1.

ProjScan finds the risk, AgentLoopKit controls the work, and AgentFlight proves the result. AgentFlight now reads local ProjScan and AgentLoopKit evidence from versioned JSON under `.baseframe/`, checks the session against the expected scope and required verification, and writes a result artifact AgentLoopKit can reconcile. The link is file-based: AgentFlight stays independently usable and imports neither tool's internals.

Start from an AgentLoopKit task

`agentflight start --from-task <task.json>` opens a session from a task contract, carrying its scope, acceptance criteria, and required verification gates.

Linked ProjScan assessment resolution

When the task contract references a ProjScan assessment, AgentFlight resolves it through `sourceAssessment.path` and reads the repository assessment evidence beside it, so the session knows the risk context the task was built from.

Scope drift detection

AgentFlight compares the files the session changed against the task's allowed and excluded paths, and flags scope drift when work lands outside the agreed boundary or misses a required area.

Verification gate reconciliation

AgentFlight reconciles each required verification gate against the proof the session captured, so a gate reads satisfied, failed, or still missing rather than assumed.

Unified readiness

Repository assessment, task contract, scope adherence, and verification gates fold into one readiness call, so the suite reports a single ready, needs verification, or blocked state rather than four separate ones.

Finish and emit the result

`agentflight finish` writes `.baseframe/evidence/<task-id>/agentflight-result.json` and updates the agentflight status in `.baseframe/agent-workflow.json`, handing AgentLoopKit a versioned artifact to reconcile. Local JSON only: no cloud, no telemetry, no source upload.

Review workflow

Trust Delta, a review queue, and review receipts.

0.13.0 sharpens the review surface. AgentFlight now summarizes what changed in the trust state, orders what to inspect first, lets a handoff be accepted and later marked stale, and routes each reviewer to their own path.

Trust Delta shows what changed in the trust state

A short readout of failed proof, stale proof, missing proof, manual review, and repo-history under-proofing, read from existing local metadata. It appears in status, the handoff, the report, the replay, and resume.

A review queue orders what to do first

One ordered list of proof reruns, missing-proof commands, manual checks, repo-calibration guidance, and file inspection. It shows up in the surfaces you already read, so there is no new command and no separate dashboard.

Review receipts can be accepted, then go stale

`agentflight handoff --accept` records a local review receipt. It reads current until an unresolved verification failure or a new changed file lands after acceptance, then goes stale, so an accepted handoff cannot quietly drift.

Role-aware routing points each reviewer at their path

Status, the handoff, the report, the replay, and resume show Maintainer, Verification, Docs/DX, Security, and Release review paths, built from existing source-free Review Intelligence signals.

Review surfaces stay quiet without losing detail

Review focus and changed-file lists now cap noisy output and mark when rows are capped, with a remaining count, instead of silently omitting lower-priority files. The full detail stays in the report and replay.

Review Contract

A claim-by-claim ledger of what to trust.

AgentFlight turns a session's signals into explicit claims and points each one at the local proof behind it, so a reviewer reads what is supported, what still needs review, what should not be trusted yet, and where the proof for each claim lives.

Every claim carries a status

Each claim reads as supported, needs review, unsupported, failed, stale, not testable, or unknown. Supported means a passed verification command backs it. Stale means the proof predates a later change. The ledger is deterministic and built locally.

Every claim points at its proof

Each claim carries source-free proof references: the changed files behind it, the proof status, any proof gaps, the readiness reason, or the suggested verification command. A reviewer follows the reference to the proof instead of trusting a summary, and a compact review path orders the claims so the highest-friction ones come first.

It shows up where you already look

The same claims surface in `agentflight status`, `report`, `replay`, `resume`, and `handoff`. No new command to learn, no separate dashboard, no cloud call.

What a clean session reads like

Task: supported. Changed files: supported. Verification: supported. Proof gaps: none. Readiness: ready for review. A session with an unverified change instead reads needs review on that file and holds readiness at needs verification.

Review Intelligence

Where to review first, and what proof is missing.

After a session, AgentFlight ranks the changed files worth reviewing first, shows which verification proof exists, flags the gaps, and states whether the work is ready. Every readiness call points at the next command.

Review first

Ranked changed files, most review-sensitive first. Example: `src/auth/session.ts`, flagged as an auth-sensitive path with no matching test evidence.

Proof, and proof gaps

Captured verification commands sit next to the gaps. Example gap: `npm test` was started but no completed result was recorded.

Readiness and next action

Each session reads as ready, needs verification, or blocked. A needs-verification session names the command to run next: `agentflight verify -- npm test`. Ranking is deterministic and runs locally.

Finish

One command writes the review packet.

`agentflight finish` is the end-of-session command. It writes the Review Passport, the single artifact that tells reviewers whether the work is ready, and bundles the handoff, report, replay, and resume beside it. `agentflight handoff` stays available for a lighter packet.

Readiness, gaps, and focus

The Review Passport states whether the session is ready, needs verification, or is blocked, lists the proof gaps, ranks review focus, names reviewer routes, and shows failed verification excerpts. A reviewer opens the passport first and the report, replay, or resume only when they need detail.

Accept it, and watch it go stale

`agentflight handoff --accept` records a local review receipt for a ready handoff. The receipt reads current until an unresolved verification failure or a new changed file lands after acceptance, then goes stale across status, handoff, report, replay, resume, and history.

Reopen it later with history

`agentflight history` lists recent local sessions with proof counts and artifact paths, and `agentflight history --limit 1` reopens the latest handoff, report, replay, or resume. Read-only and local: no index, no sync, no session switching.

Proof without pretending

AgentFlight stores passed commands, failed commands, exit codes, stdout, stderr, durations, and a short failure excerpt for failed runs as local evidence. It does not claim a test passed unless the command passed.

Trust

Local files. No telemetry. No cloud upload.

AgentFlight reads git status and package metadata, runs verification commands only when you ask, and writes local artifacts under `.agentflight/`. Reports include filenames and summaries by default, not full code diffs.

Nothing leaves the machine

No cloud, no telemetry, no source upload, no LLM calls, no account, and no automatic PR comments. AgentFlight reads git status and package metadata, runs verification only when you invoke it, and writes local files under `.agentflight/`.

What AgentFlight is not

Not a coding agent, not a cloud service, not a replacement for tests, not a security scanner, not a CI platform, and not a code review replacement.

Records, never overwrites your work

AgentFlight captures context and writes its own artifacts under `.agentflight/`. It runs your verification commands only when you invoke `verify`.

Where it sits in the studio

AgentFlight is the user-facing review layer and proof trail. ProjScan is the repo intelligence engine, AgentLoopKit is the task discipline and verification workflow engine, and TokenTrace is local AI CLI usage analytics.