bareloop 0.40.0 → 0.42.0

package/CHANGELOG.md

@@ -5,6 +5,101 @@ All notable changes to bareloop are documented here. Format:
 [SemVer](https://semver.org/spec/v2.0.0.html). Pre-1.0: **minor** = a ladder rung or
 feature lands, **patch** = docs, fixes, scaffolding.
 
+## [0.42.0] - 2026-10-14
+
+### Added
+
+- **Rubric jobs on local files, no judge yet (Part 1a).** A Rubric job whose first Input is the full path of a text file (`label: /abs/file`) no longer stops at "not a code project". `proveRubricInputs` (`src/source.js`) freezes each file into the hidden-git tree and records `inputs: [{ label, rel, sha256 }]` in `source.json`; a web address, search line, relative path, symlink, env file, over-5-MiB or non-UTF-8 file is refused at $0 in plain words ("line N: web inputs (URLs, search) arrive in a later build. Nothing spent."). There is no scout and no confirm turn: the worker's goal is written by code from the numbered job lines (`src/rubricstep.js`).
+- **One output per job line.** The worker writes `output/steps/<n>.json` (`{ text, cites: { <label>: [{ claim, quote }] } }`); `output/steps/` is delivered with the output.
+- **New close kind `rubric-step`** (text genre only, `closeDecl.lang: "text"`; a code job never sees it): one stage per job line, graded by bareguard's rubric primitive rebuilt every run from the input shas the source door recorded. Checks: the step file exists and is a JSON object (`happened`), `text` present, `cited` per input the step cites, and `maxWords` / `minWords` / `maxLines` / `sections` / `sectionWords` on `text`. A missing or cut-off file is red; a changed input, an unreadable record or a rubric that cannot be built is an instrument stop (97).
+- **Every part of a job line is sorted at drafting** (countable, judged, guard, none). A judged part ("this rule needs the judge, which arrives in the next build. Nothing spent."), an unsortable part, a guard with no web input, contradicting limits (both parts and numbers named), a stage on the wrong line and a quote from an unknown input are plain-words reds; the drafting and signing stops print them whole.
+- Signing such a job makes zero judge-round records (the calibration gate runs only for a judged stage).
+- **The confirm turn is back for these jobs** (form -> confirm turn -> sign, scout still off). Its protections come from code: the text genre's guard, the write fence and one line per job line saying its step file must exist, be complete JSON and carry text; the model is told what a check can be here and shown the same list as already covered.
+- **A red count for the fix-loop governor.** A red `rubric-step` stage reports failing claims plus failing checks, lower is better, through the same `closeGrade` path numeric stages use.
+- **The panel words a rubric-step check** as "line N — does its output pass the line's checks?" instead of the raw stage name.
+- **Worker brief:** copy every number, time and price in a claim exactly as the input writes it.
+- **The panel topbar shows the version:** `bareloop · v<version> · automate a job, verified`, read from bareloop's own package.json when the page is served (never written into the HTML).
+- **Each `~` guardrail is shown on its own marked row** under its numbered job line on the plan card and the Job tab (fwdloop's shape).
+- **A refused drafting try records why** in `draft-log.jsonl` (`try-refused`) and on the drafting step's progress line.
+- **Required facts (Part 1b): a job line that finds, lists or looks something up is checked by what the person asked for, not what the worker chose to write.** The drafter turns the line and its `~` rules into a signed list of facts (name, shape money / number / date / time / phrase / text, a rule only where asked, the input they come from); the worker's file for that line is `{ results: [{ quote, values }] }` with no free text, and bareguard's `cited` + `decides` checks every result in code: the quote is really in the frozen input, every value is really in the quote (compared by shape), every value meets its rule. The claim text is written by code; "N results" is a count code checks. (`src/facts.js`, `src/rubricstep.js`)
+- **Records. (Removed in Part 1c, below: no record cutting.)** The drafter names where a record opens and where the quoted slice ends; code splits the input and counts the records. The drafter reads the input at drafting (a big one as a said-so sample: the first 15000 characters, cut at a line end, shown on the card).
+- **Three early tests at drafting, on the real input (removed in Part 1c, below: code now only proves the words are in the source),** before a fact check can be signed (`src/factcheck.js`): every word a check depends on is really in the input; the check finds its value in each record (count shown); a rule has one value per record or an anchor; a value changed by code makes the check go red; the pass / fail split of a rule is shown. A run repeats the words / found / one-per-record tests on the source it reads and stops in plain words if it no longer fits.
+- **No silently dropped rule.** Every `~` rule must become a check (its number in a part's `rules`) or be listed under Not checked (`refused` entries may now name a `rule`); a number the AI made out of the person's words is marked "AI's proposal — check it", and an AI time limit must be a range.
+- **Prose after facts.** Every number in a text step must appear in a checked quote of an earlier fact line (bareguard `numbersInQuote`); the card says "what the text says" is not checked and is judged at Accept.
+- **Plan card and worker brief.** One code-worded row per fact (with the early-test evidence) on the confirm card and the Job tab, covered by the sign-time shown == run check; the worker's goal briefs each line by what its stage checks.
+- **A refused drafting try keeps its declaration (Part 1b live fix A3).** The refused proposal rides `author-try-failed` and the panel writes it to `draft-log.jsonl` beside `try-refused` (secrets masked, cut at 60000 characters with `declarationCut`), so a failed draft can be read and replayed at $0.
+- **One rulebook for the confirm step and the drafter (B1).** `RUBRIC_RULES` is the single text both `RUBRIC_CONFIRM_NOTE` and the drafter brief print: a limit the person wrote is a checkable rule; a number made from their words is the AI's proposal and a range; names, labels and units are the input's own words, and a code like `SFO` the person did not write is never added.
+- **The drafter is shown which fact shape takes which fields (B2).** `factShapeGuide` is read off bareguard's `rubricVocabulary` (`factShapeFields` throws at load if bareguard's wording changes) and carried in `REQUIRED_FACTS_BRIEF`, which also says one stage holds all of a job line's facts.
+- **The look, then say what can be checked (Part 1c, docs/product/ITEM33-BUILD.md; PRD item 33 RF18-RF22).** Drafting no longer grades and no longer cuts records. Before the drafter writes a check, a read-only, bounded look (`runInputLook`, `src/authorscout.js`; tools in `src/inputlook.js`) searches the person's frozen input text, reads the spots it finds, and reports per job line the facts it can check - name, shape, a label, one example value it saw - and what it could not find. Fixed grant (search and read over in-memory text, nothing to write), `LOOK_ROUNDS` 8, a reserved final round whose only tool is the strict answer form (`report_look`; never free prose with JSON inside), spend metered into the drafting book like the repo scout's. Every place, date or name in the job line is a fact too, bound to the label before it (a direction is `Leaves` / `arrives at` as a phrase fact); prose lines and their `~` limits are not looked up. The drafter is shown the verified report.
+- **Labels are picked, never typed (`src/labelscan.js`).** Code scans the source at $0 and lists, per shape (money, number, date, time, text), the words right before each value with how often they occur (`Departure time:` x43, `From` x44, `Leaves`, `arrives at` on the saved flights page; `## [` and `] -` on this changelog). The look and the drafter pick a label only from that list, by id or exact words; one scan for every page or file, no per-site table.
+- **Code proves the words are in the source (`src/factwords.js`).** Every anchor must be on the input's list for its shape, and every `until`, phrase and unit must be in the source once, compared white-space blind (Google writes U+202F before AM/PM). A word not found is a red naming the word and the input (`rubric-fact-label-off-list`, `rubric-fact-word-missing`, `rubric-fact-unread`); the look's phrase facts are proved by the same counter.
+- **Web addresses as inputs (`src/pagefetch.js`, `src/source.js`).** An Inputs line may be `label: https://...`. barebrowse (`^0.21.0`, now a production dependency) fetches it read only (`connect` with `incognito`, `blockPrivateNetwork`; `goto`, then a bounded wait for the network to go quiet so the page's own scripts finish filling the results, then an `act` snapshot); an empty, near-empty (under 200 characters), header-and-menus-only (nothing outside the banner / navigation landmarks), bot-challenged or unreachable page is a plain-words stop. Drafting fetches it once for the look; run start (`refreezeUrlInputs`, called from `run-u --spec`) fetches it again, writes that text into the prepared tree as the run's frozen input and commits it as the new seed before the worker starts, so the close checks quotes against the run's copy and the worker reads it, never the live page. A resume keeps the copy its first start froze.
+- **Ask at once about a `~` rule the look could not capture (I1).** When the look names a `~` rule whose words or meaning are not in the source, the person is asked about that rule, by line and rule, before the plan and the draft (the existing question gate: answer required, no skip, the answer becomes a `~` rule on that line; at most `MAX_QUESTIONS`). Any other drafting failure of a rubric job on files asks nothing piecemeal: the stop says to review the whole job and submit it again, with the reasons in plain words.
+
+### Fixed
+
+- **A missing earlier step file is a normal red; a rubric job's broken check no longer blames install/build/test commands (Part 1c M2).** When a fact line ties its numbers to an earlier line's answer and that line's step file is not there yet, the grade says "line N's answer is not there yet" instead of raising an instrument fault; a `broken-close` on a rubric job reads "A check of the close could not run" instead of the code-job wording about install, build and test commands.
+- **After Sign & run the Runs list is refreshed until the new run is listed (Part 1c M3).** The list re-fetched only every 10 seconds and the runner writes its row a few seconds after the click, so a signed run showed only after a page refresh; the panel now forces bounded refreshes until a run not listed at the click appears (as a resume already did).
+- **A header-only page stops before the look, and an empty input is never asked about (Part 1c L2).** A fetched page whose text outside the banner, navigation and footer landmarks is under 100 characters is refused in plain words (a 719-character fetch of a site's header and sign-in used to pass the 200-character floor); an input with no content makes the survey absent before the look and before any question, so nothing is asked and nothing is spent.
+- **A fact's words must repeat as often as results were asked for (Part 1c M1, M4).** On a line asking for N results, an anchor label (M1) or a "must say" phrase (M4) that the input holds fewer than N times sits in no single result (a sort tab, a page header), so no one-result quote can hold it. `checkFactWords` refuses it at $0 in plain words naming the words, the input, the count and N (`rubric-fact-label-rare`, `rubric-fact-phrase-rare`); count 1 or no count keeps a once-only one legal. The one rulebook (`RUBRIC_RULES`) tells the drafter. Live runs mv73swnx and mv76jhj1.
+- **Plain words for every rubric red (B3).** `rubric-step-twice` and every `rubric-*` code read as a whole sentence on the proposal door, the signing door and the stop text; `invalid-value` / `missing-field` on a rubric-step's parameters say where (stage, part, fact, field). A test reads the rubric red codes from source and fails on any unmapped one.
+- **The long-record refusal says what to do (A1; removed with record cutting in Part 1c).** `rubric-fact-record-long` names the record, its length, the end marker given (or "no end given") and an example taken from that record.
+- **An end marker the records do not hold is its own red (A2; removed with record cutting in Part 1c).** `rubric-fact-record-end` names the marker and how many records lack it; before, a partial miss fell back to the whole record and read as "too long". A marker that is the first thing after a record's start (it opens the next record too) counts as found.
+- **Drafting wording.** The drafting line says `drafting (retry N of M)` only after a try that was actually refused, and `drafting (look N of M)` after one that passed (the loop drafts again after a passed try too). A refused try's reason, and the drafting stop texts, no longer end "Nothing spent." — a drafting try always paid for its model call.
+- **The plan card showed the drafter's prose (run mv5e1ktb).** The confirm turn's bubble stayed above the code-worded card and was the one read. After drafting the earlier plan bubbles are dropped, so the card is the signed close's own sentences. "at most 1 lines" now reads "1 line" (and "1 word").
+- **The review door's held line said "rendered by the judged floor" for a rubric close where no judge ran.** Wording only: the hold is by verdict class and is unchanged.
+
+- **A check shown at the confirm turn could be dropped from the signed close without a word (run mv5bk400).** The composer put "lists 3 releases" in the close's notes and wrote no stage for it. Now `minClaims` / `maxClaims` count the claims listed under an input (the code counts, bareguard's `min`/`max` compares), parts say which confirmed checks they carry out (`covers`), the plan card after drafting is built from the signed close itself, every confirmed check no part carries out is moved to Not checked in code, and signing refuses when the checks shown differ from the checks of the close.
+- **Wrong labels on a rubric job on files:** the close carries genre `TEXT` (not `TYPES`), its records carry no `judgedCount` (no judge ran), and the progress list says "copying input files" / "reading input files" instead of "making worktree" / "reading repo".
+- **The panel could not start a rubric job with two or more local-file Inputs:** `POST /api/author/start` asked the repo proof of every card and reded line 1 ("is not a folder"). A rubric card whose first input is a local file now skips it; the session proves each line.
+
+- **The panel shows a refused Start (Part 1c item f).** The $0 refusal that `/api/author/start` returns (an Inputs line, a Destination) was drawn as a faint 11px hint under the cap fields and never scrolled into view, so it read as nothing happening; it is now red, 13px and brought into view, like the progress list's failure line. The failed-draft refusal of a pasted web address that cannot be read no longer ends in two full stops.
+- **A fact line's `~` rule is carried by its fact part, and `covers` stays on the part (Part 1c L4).** Live drafts of the flights job (panel session smv710w8c3wdh, 3 of 3 tries) were refused on form: `covers` written on every fact, and "not a red-eye" / "nonstop" sent as a judged or unsortable part beside the fact part. The one rulebook (`RUBRIC_RULES`, `REQUIRED_FACTS_BRIEF`) now says a limit the AI turns into a number goes on the time the input holds, as a `between` range marked AI's proposal, inside the fact part; a rule it cannot express goes in `refused`, never a part; and the refusals (`src/facts.js`, `src/rubricstep.js`) say where each belongs.
+- **The plan card keeps the person's words (Part 1c L3).** Code settles it before anything is validated or signed (`settlePersonsWords`, `src/rubricstep.js`): a limit made only of the person's own numbers is not marked AI's proposal; a time window the AI proposed is replaced by the one explicit positive range the person wrote or answered ("between 07:00 and 23:00"; a "not between ..." rule is never read as a range); a `~` rule that a part carries is not also listed under Not checked. The look carries a rule it can number from its own knowledge ("not a red-eye") as a fact with `forRule` marked AI's proposal instead of reporting it not found, so it is not asked; and the early question's reason is cut only at a sentence end (`wholeSentences`), never mid-sentence.
+
+### Changed
+
+- **The plan card legend and fold wording** (chat plan card and Job tab): the legend reads "Done when every › check passes" and the mandatory-guards fold is "Always checked" (was "= the approved plan" and "Always on"). Words only.
+
+- **barebrowse `^0.21.0` is a production dependency** (bare suite, Node 22). bare-agent keeps its own optional nested `barebrowse ^0.5.0`; the two do not conflict in a clean install.
+- **bareguard `^0.21.0` -> `^0.23.0`** (`cited` decides with typed values, bind-only and `text` decides, anchors match on word edges only, a `cited` claim carrying `values` with no `decides` is red).
+- **bareguard `^0.23.0` -> `^0.24.0`** (a money fact's `currency` may be one symbol or a list of 1-3 and `unit` one string or a list of 1-10, at least one; tokens with the same amount count as one price; a revoked-Proxy claim value is red `claim-value-malformed`; `rubricVocabulary` currency/unit descriptors carry `list:{max}`). bareloop still sends one `unit` or one `currency` per money fact (`src/facts.js`), so the lists are available but not yet used.
+- **`~ PASS:` / `~ FAIL:` examples are required of a rubric job only when it holds a judged part** (`jobBlockFitsCheck(lines, rubric, { judged })`, hamr's ruling P1=B). A rubric on a local file holds none in this build; a rubric on a repo still needs them.
+- **Node 22 or newer is required** (`engines.node` `>=22`, CI on Node 22). barebrowse, which the coming rubric `search` step drives, needs Node 22; Node 20 is past end-of-life.
+
+## [0.41.0] - 2026-10-12
+
+### Added
+
+- **Settings > Providers, rewritten from fwdloop's layout (P8).** One shared grid: a key row (API shape, Base URL, the "old max_tokens" tick, Tokens, `[ Test ] [ ⟳ Refresh ]`) with its model lines under it (Use tick, In / Out $/1M, tokens), a folded summary, `label : value` lines below 1280px, and the KEYS strip stacking below 900px. **Test** and **Refresh** are one free `GET <Base URL>/models` (`src/modellist.js`); `gemini-api` is now testable. `Open keys folder` stays in the KEYS strip.
+- **Model lines.** Config gains `models.<ENV>` — a list of `{ model, use, inPerM, outPerM }` — and `keys.<ENV>` becomes `{ shape, baseUrl, legacyMaxTokens }`. A price is a pair or nothing, a ticked line needs both, 0 / 0 is a chosen price. An older `keys.<ENV>.{name,priceInPerM,priceOutPerM}` still reads as one line until the row's first save.
+- **"Thinking on" tick (per job).** A tick under Model in the New job card, unticked by default, saved in the signed job as the optional `thinking` boolean (absent = off; an old spec and any unticked job keep their hash). It covers drafting and the rubric judge, never the worker. `src/thinking.js` is the one owner; bare-agent (^0.52.0) says what each model can switch and reports `thinkingStatus`, which the draft log and the drafting `thinking` row show.
+- **`--model <id>` and `--provider <KEY>`** on `run-u`, `run <bundle>` and the resume route name the Settings line a run works on (for a spec that names no model); `interview` takes `--model` and writes it into the draft.
+- `tests/no-hardcode.test.js`: a search of `src/` and `bin/` finds no provider name, model name, web address or price in code, except an allow-list with a reason per entry.
+
+### Changed
+
+- **Resume of a pre-P8 run whose signed spec names no model** opens the Resume card's Model box (it was locked, so the person could not act on `--model`). The menu offers only lines of the spec's API shape (and endpoint, when the spec names one) and shows `Tick a <shape> model in Settings > Providers.` when none match; Sign & resume stays blocked until a usable line is picked, and the pick is sent as model + provider. The spec and its hash are untouched. Changing the Model line now blocks Start/Sign until its key check returns, and a late answer for a line no longer selected is ignored (the New job card shares this path).
+- **Chat's Model menu** lists only ticked, priced lines as `<KEY> · <model>`; a card carries `provider` (the key's env name) beside `model`, and a stale pick is refused at $0 with one of three plain sentences.
+- **A job's key is its row's own variable name.** There is no built-in key name, tier table, default model, default address or per-model gating: the "old max_tokens" tick on the row decides the output-cap spelling.
+- **Existing DeepSeek rows need one tick.** An existing DeepSeek row (or any OpenAI-compatible server that wants the old `max_tokens` field) must have "old max_tokens" ticked once in Settings > Providers: the built-in per-model rule that did this is gone (no-hardcode ruling), and until the tick is set the output cap may not bind (F149).
+- The Money tab groups spend by the Providers row that served it (a run no row serves lands under its own shape and address) and carries tokens per model.
+- A fresh keys file holds two comment lines and no preset key.
+- Dependencies: `bare-agent` ^0.51.0 to ^0.52.0.
+- The exported bundle README tells the user to put their provider's API key in their keys file (the name their Settings row uses), with no vendor.
+
+### Removed
+
+- **Balance** (the Settings column, both routes and the `anthropicBalanceNote` config field).
+- Built-in tiers and keys: `*_TIER_MODELS`, `envKey`, `OPENAI_MODEL_OPTIONS`/`paramsFor`, `PRESET_KEY_NAMES`, the vendor default addresses, the `--model sonnet|haiku` aliases, the vendor map in the Money tab.
+- **`JUDGE_MODEL`** is no longer exported from the package root or `src/judged.js` (a public-API removal: pass your own model id). `resolveWorkerModel` takes `suppliedModel` instead of `defaultModel` and throws when no model is named.
+- The bench row `bareguard-types-deepseek` is renamed `bareguard-types-gateway` (spec file renamed; contents and hash untouched; the patient directory it names is now `bareloop-patients/bareguard-u-gateway`).
+
+### Breaking
+
+- **The config shape changed.** Every row that relied on a built-in default (shape, address, model, price) must have its API shape, Base URL and model lines entered or ticked ONCE in Settings. A row on a server that ignores `max_completion_tokens` (F149) needs "old max_tokens" ticked by hand, once, before a paid run: an output cap that does not bind is a money hazard.
+- **Specs signed before this release that name no `model` (or no `baseUrl`)** have nothing to run on until a line is named at run start: `--model <id>` (the hash is untouched). A signed model no ticked line carries is refused at $0.
+
 ## [0.40.0] - 2026-10-11
 
 ### Added
@@ -14,7 +109,7 @@ feature lands, **patch** = docs, fixes, scaffolding.
 - **Try-3 questions.** On the last drafting try, after two failed ones (validation red, seed-read failure or vacuous close, or an output cut-off), the drafter may ask up to 2 questions, each naming a job line. The panel asks each through the ordinary ask path (answer required, no Skip), adds the answer word for word as a `~` rule on that line, and drafts once more with no asking. Off unless the caller wires an asker (the CLI never does).
 - **Thinking switch for drafting and the judge.** `thinkingMode` ('on' | 'off', anything else throws) is asked of bare-agent; `off` is sent only for models bare-agent's `thinkingSupport` says are switchable, and nothing is sent for a not-switchable or unverified model. The draft log records `thinking` (off / on / not-switchable / unverified) and bare-agent's `thinkingApplied` verdict per call.
 - **Panel.**
-  - One shared plan renderer draws the chat bubble and the Job tab: numbered lines, rules, checks under the line they serve, with *Not checked* and *Always on* folds; an "AI's summary" row, and an "AI's open questions" row (each question its own item, then "Revise if you need to.") shown only when there are questions.
+  - One shared plan renderer draws the chat bubble and the Job tab: numbered lines, rules, checks under the line they serve, with *Not checked* and *Always checked* folds; an "AI's summary" row, and an "AI's open questions" row (each question its own item, then "Revise if you need to.") shown only when there are questions.
   - The Job tab runs The job, Inputs, Destination, Tools, Cap, Signed, with the job at full height; older jobs show an older-job note and keep their goal as line 1.
   - The job boxes grow to 8 lines then scroll, with the number gutter scrolling alongside; the left pane widens to 630px from 1200px wide.
   - The drafting list opens with a code-owned *thinking* row; if the model reports it thought anyway after `off` was sent, it reads "thinking on (the model thought anyway)".

package/README.md

@@ -18,33 +18,25 @@
 
 **"Automate this job — I don't know the best workflow."**
 
-For work that is repeated, long, and verifiable: an agent authors the workflow scaffolding
-itself, as a constrained and validated config rather than freeform code. Every run executes
-under an outer gate the agent cannot reach or argue with. And the workflow gets better across
-runs, because what actually worked is kept with receipts and carried into the next run.
+The best workflow is the shortest proven path that gets the job done, and that heals itself when a different model works a different way.
 
-Agents got good at doing the work. The open problem is knowing when the work is actually
-done. Three of the strongest results in long-running agent work landed on the same answer
-independently: the ralph loop, code machine MCP, and recursive language models all trust the
-agent to do the work and verify it with something the agent cannot reach. Trust, but verify.
+bareloop finds that path for you. Write your problem in plain language, as steps. Under each step, say what counts as success and what it must never do. The agent builds the bridge it will walk on, and the run is green only when the output passes checks the agent never touches.
 
-bareloop takes that principle and makes it the product. You describe a repeated, verifiable
-job and what *done* means for it. The agent handles the rest, under verification it never
-gets to touch.
+The harness (budget, time, what it may touch) and the judge both sit **outside** the agent loop. The agent can't judge itself. Every run is recorded, so you can audit it and replay it at $0 and see exactly what happened.
 
-## Two kinds of done
+## Two kinds of jobs
 
-Jobs differ by what decides the result is good. That difference is the product's spine, so you
-choose it when you create the job.
+**Deterministic (code)**: code decides. Tests pass, the linter is quiet, the build exits clean. If no check exists yet, say what you need and the agent builds that check first.
+> *"Fix the lint errors."* · *"Add doc comments to every function."* · *"Split this 3,000-line file without breaking a test."*
 
-**green** — a predicate decides. Tests pass, the build exits clean, the type checker is
-quiet.
-> *"Fix the failing suite."* · *"Migrate this package to strict types."*
+**Rubric (research)**: it searches, collects, compares and hands you a report where every fact is quoted from a saved copy of its source. A judge only points at the quotes, and fixed rules decide.
+> *"Find flights LAX→SFO under $400, nonstop, no red-eye."* · *"Compare these 5 laptops on price, weight and warranty."*
 
-**softgreen** — an assessment decides, against a rubric you wrote and signed. You say what
-separates a pass from a fail, and give one example of each; the judge only quotes back what it
-finds in the real work, and fixed rules — not the judge — render the verdict.
-> *"Reserve a ticket from SF to LA under $400."* · *"Improve my resume."*
+## What it won't do
+
+bareloop reads, searches and writes. It never acts on the world: no paying, booking, sending forms or posting. When a job needs a person partway through, or needs to *do* something, like book the flight bareloop found, that's **[fwdloop](https://npmjs.com/package/fwdloop)**.
+
+**Small tools, all local.** Built on the bare suite (bareagent, bareguard, litectx), always LLM-agnostic, always on your machine, with a simple panel UI.
 
 ## You have the last word