Omniscio

Nighty Tidy (an overnight audit that only touches its own work)

An overnight audit panel that tidies and checks things while you sleep, built around one hard boundary: it owns what it created and leaves the rest of your work alone. Covers that boundary, how to run one, and what it will refuse to touch.

On this page

audience: customer kind: library roadmap: cat-nighty-tidy summary: > An overnight audit panel that tidies and checks things while you sleep, built around one hard boundary: it owns what it created and leaves the rest of your work alone. Covers that boundary, how to run one, and what it will refuse to touch. title: Nighty Tidy (an overnight audit that only touches its own work) category: automation-scheduling group: scheduling related:

  • nighty-tidy-2-part-2
  • nighty-tidy-2-part-3
  • night-shift
  • audit-framework last_verified: '2026-11-05' verified_against:
  • src/main/services/nighty/nighty-tidy-2-service.ts
  • src/main/services/nighty/nighty-tidy-2-run-engine.ts
  • src/main/services/nighty/nighty-tidy-2-scheduler.ts
  • src/main/services/nighty/nighty-tidy-2-chosen-waves.ts
  • src/main/services/nighty/nighty-tidy-2-stopped-cloud-run-salvage.ts
  • src/plugins/nightytidy2/ui/screen-review.js media: [] video: tutorial-nighty-tidy index_title: > Nighty Tidy (the full-vision audit panel) index_summary: > THE Nighty Tidy going forward (the original is untouched legacy) — native React panel on desktop AND mobile with four live-updating screens: Run (read-only or read-write + auto-fix, scope picker with preset buttons + folder browser + custom instructions, push-driven progress queue) — the Run page lists what is running, scheduled and coming up once, and ONE seven-step setup (Where, Area, Audits, AI, When, Fixing, Review) builds a run now, a one-time run later or a schedule; plus a global pacing & limits editor, History (every run incl. visible pre-flight failures; soft-delete), Findings (structured findings view, status-aware empty states). OWN run history (nighty_tidy_2_runs) + automations (nighty_tidy_2_subscriptions) + a stateless nightly scheduler (every due audit per automation, one global concurrency-cap setting, startup rescue of finished-but-unrecorded runs). Reuses the SHARED audit framework; keeps installed specs CURRENT via a sha-provenance refresh that never overwrites user edits ("Edited" badge; Omniscio-specific audits badged). AI operator sessions drive it over the gated /nighty-tidy-2/* CLI API (run-now approval-gated; saves replay-idempotent). Bundled plugin nightytidy2, off by default in Marketplace → Installed, moon-icon sidebar __plugin_nightytidy2__


audience: customer kind: library roadmap: cat-nighty-tidy summary: > An overnight audit panel that tidies and checks things while you sleep, built around one hard boundary: it owns what it created and leaves the rest of your work alone. Covers that boundary, how to run one, and what it will refuse to touch. title: Nighty Tidy (an overnight audit that only touches its own work) category: automation-scheduling group: scheduling related:

  • nighty-tidy-2-part-2
  • nighty-tidy-2-part-3
  • night-shift
  • audit-framework last_verified: '2026-11-05' verified_against:
  • src/main/services/nighty/nighty-tidy-2-service.ts
  • src/main/services/nighty/nighty-tidy-2-run-engine.ts
  • src/main/services/nighty/nighty-tidy-2-scheduler.ts
  • src/main/services/nighty/nighty-tidy-2-chosen-waves.ts
  • src/main/services/nighty/nighty-tidy-2-stopped-run-salvage.ts
  • src/plugins/nightytidy2/ui/screen-review.js media: [] video: tutorial-nighty-tidy index_title: > Nighty Tidy (the full-vision audit panel) index_summary: > THE Nighty Tidy going forward (the original is untouched legacy) — native React panel on desktop AND mobile with four live-updating screens: Run (read-only or read-write + auto-fix, scope picker with preset buttons + folder browser + custom instructions, push-driven progress queue) — the Run page lists what is running, scheduled and coming up once, and ONE seven-step setup (Where, Area, Audits, AI, When, Fixing, Review) builds a run now, a one-time run later or a schedule; plus a global pacing & limits editor, History (every run incl. visible pre-flight failures; soft-delete), Findings (structured findings view, status-aware empty states). OWN run history (nighty_tidy_2_runs) + automations (nighty_tidy_2_subscriptions) + a stateless nightly scheduler (every due audit per automation, one global concurrency-cap setting, startup rescue of finished-but-unrecorded runs). Reuses the SHARED audit framework; keeps installed specs CURRENT via a sha-provenance refresh that never overwrites user edits ("Edited" badge; Omniscio-specific audits badged). AI operator sessions drive it over the gated /nighty-tidy-2/* CLI API (run-now approval-gated; saves replay-idempotent). Bundled plugin nightytidy2, on by default and not listed in Settings → Plugins (it has nothing to set there), moon-icon sidebar __plugin_nightytidy2__

Nighty Tidy (the full-vision audit panel)

What it is

Shipped label / internal id: users see this panel as Nighty Tidy — the "2" was dropped once the legacy original (nightytidy) was retired from view. Its internal id, DB tables, and IPC channels stay nightytidy2 / nighty_tidy_2_* / NIGHTY_TIDY_2_* unchanged; this page uses NT2 for that internal identity.

What it is — Nighty Tidy

Nighty Tidy (nightytidy2) IS Nighty Tidy — the retired first version (nightytidy) is gone, not merely hidden. On desktop it is a marketplace-plugin webview panel; on the phone it is a native React panel; both draw the same Run page and seven-step setup. It is the full code-maintenance audit panel, with four screens:

  • Run — the home screen. It lists Running now (every audit in flight on any repo, each with its own Stop, plus any paced Run-now batch as a Batch row with Stop), On a schedule and Coming up once — each automation one row: its name and repo, a summary (when · audits · fixing), a pill (Next: …, Not run yet, Paused, Finished, or Didn't finish for a one-time run whose moment passed without finishing) and its own on/off switch (saves at once; switching off halts what it queued — I25). New run opens the setup; clicking an automation opens the same setup on its Review step to change it; Limits opens the global ceilings editor. The last run you started from here stays below Running now once it settles, with each audit's outcome and Done: start another run.
  • The Run setup — one step-by-step setup for every kind of run (owner design, 2026-11-20), identical on desktop and phone. Every page opens with its question; a pinned bottom bar carries Back (from step 1, back to the Run page), Step N of 7, the running cost estimate ("About $X", and "a run · $Y a week" for a schedule) and Next, which stays disabled until the page is answered; Enter is Next.
    1. Where — a searchable list of your projects (name, folder, when it was last checked). Enter with one match left picks it and moves on; double-click a row to move on.
    2. Area — The whole project or A specific area; the second reveals What should the AI focus on? (added to every audit — the scope instructions, 4000-character limit). Both show the Label (60 characters) and a live preview of the real run title, built by the app's own title builder: [NT Audit] <Audit> #<N> — <label> · <date>. With no label a run uses the automation's name, then the first 40 characters of the instructions.
    3. Audits — the catalog for that project, grouped by category, each with a one-line description and its price from the cost preview; each category has a tick-all box (ticked, empty, or a dash when only some are ticked), plus Select all / Clear. A new run starts with nothing ticked. Omniscio-specific audits appear only on your Omniscio checkout; a user-edited spec is badged.
    4. AI — the app's own model picker (the one you start sessions with); Default is your app-wide default engine and model (I35). The cost estimate follows the pick.
    5. When — Right now, Once, later (Tonight / Tomorrow night / Another day, plus a time; "Tonight" means the next time the clock reads that time) or On a schedule (Every night / Weeknights / Weekends, single-day chips, a time). A sentence confirms it ("Runs weeknights at 1:30 AM."). A saved schedule the chips cannot show (a monthly or stepped cron) reads Custom schedule and is kept exactly as stored unless you pick days.
    6. Fixing — Report only (findings wait in Findings) or Fix automatically, which reveals ONE cut-off: for Right now Each audit's own level (the default — each audit fixes down to its own Auto-fix level) or Critical only / High and above / Medium and above / Everything, exactly as picked; for an automation the same four cut-offs, which each audit's own level can narrow (the step says how many, with Auto-fix levels…). Fix with keeps the audits' AI or picks a different one in the same picker. A Cloud audit only reports; its fixes start later from Findings.
    7. Review — every choice with a Change link, a Name (automations), the title preview, More settings (run location — this computer, a cloud machine behind the one-time spend consent, or another linked computer for Right now; pace, including All at once for Right now; per-night count, drip and spend cap and Stop after N runs for a schedule; Start from with 2+ audits) and Delete this automation when editing. The button reads Start now, Save automation or Save changes. Start now with Fix automatically asks once more in the bar (Enter confirms, Esc cancels), saying where fixes land. Under the hood: Right now is the same manual run as before (an immediate start per audit, or a paced batch the scheduler drips). Once, later is an ordinary automation on a one-date cron with a run limit of one, so each audit runs once and the automation reads Finished. The history purge never deletes the runs of an automation with a run limit, so it can never re-run it; a finished schedule comes back by raising Stop after N runs. A one-time run's per-night count and spend caps are off. An automation can hold any number of audits and a repo any number of automations; each runs paced by its own caps, all bounded by the global ceilings (concurrency / nightly count / nightly $ across every automation). How the nightly $ caps hold: before each start, tonight's spend PLUS the expected cost of audits still running (their usual cost, or $50 before the first priced run) is checked; at the cap nothing new starts that night, and an audit still waiting for a slot is dropped. The app-wide cap counts every automation that fired tonight (fires within 8 hours of each other), never last night's. Overshoot: a running audit is never stopped by a cap, so a night can end above it by what the audits already running go on to spend.
  • History — run rows with status, finding-count badges, and a "fixes applied" marker. Every row reads the run's true state, from ONE rule the phone queue, the phone's History and this panel's History all share: Queued, Running, Needs input (the audit parked on a question), Findings, Clean, Stopped by you (you pressed Cancel), Skipped (a duplicate run was refused), Failed (a real failure), or Unknown — a status the app does not recognise never reads as a clean pass or a failure. A stored status alone cannot tell a stop from a skip (both record skipped), so the run's own reason decides it: the cancel sentence "Cancelled by you." is what makes a row read Stopped by you, including the older rows written before this rule existed, which are read as a stop without any row being rewritten. A run that couldn't even START (recipe missing / repo gone) records a visible failed row with humanized copy — a broken automation is never silent. A Run now or scheduled audit that breaks before its audit session starts ends failed with the same owner-readable reason, never stuck at Running; once its session has started, that session's own end settles the run instead. Every update that marks a run failed carries the run's reason, so the phone's live run queue shows why without a reload. A skipped run with no recorded reason says it was skipped before it produced a report, since some skipped runs did start. A few cloud runs from the Nov 6, 2026 batch that showed failed or partial only because their upload never arrived are corrected once, from the run's own folder on its cloud machine: they show their findings, or one of two honest reasons — "The audit finished, but its findings never reached the app…" or "This run's session ran a different audit (…) instead…". A momentary database lock while a run starts is waited out instead: the audit keeps running and no failed row (or "database is locked" alert) is written for it. A run that FINISHES is recorded by its result (findings, or a clean pass) — including one that finishes and then parks in your Needs-You inbox on a trailing question; a completed audit is never mislabeled failed (and no false "scheduled audit failed" alert fires for it). A clean pass is only ever claimed when the audit's findings list was read and is empty: an audit whose session ended or was archived before it published its findings (and left no report) records failed ("stopped before it wrote its report"), and one whose report came without its findings list records failed too, with the report still there to open. An audit that published its findings to the app is finished whether or not any report file exists — and if its findings arrive after the run was already recorded "stopped before it wrote its report", the run corrects itself. Each row shows its cost. An audit that filed its OWN run shows the spend of the one session that filed it (read when History opens, never saved); if that session cannot be matched to the run for certain, the row says Cost unknown, never $0. Delete a run (per-row trash) or Clear the whole list — both soft-delete, behind a quick confirm.
  • Findings — the review deck: a repo's open findings, one card at a time, from the latest finished run of every audit at once. On the desktop a small repo picker and four tabs — To review, Fixing, Skipped, Done — sit along the top, and one Filter button opens a panel that narrows the deck four ways at once (each active filter then shows as a chip you can remove with one click): Audit, Part of the code (the folder the finding's file lives in, such as src/main or tests), Kind of change and Severity — each with the count it would leave, across every open finding, not just the ones loaded ("all security findings in src/main across every audit"). The card scrolls in its own pane, shows the whole explanation (never cut off), and the Start fixing bar stays pinned at the bottom. A repo with more findings than one page loads a page at a time — the deck asks for 200 at once and a Show more (N left) button at the end of a list brings the next, so a project with tens of thousands of findings is never cut off at a fixed ceiling. The counts on the tabs, the severity pills, the kind chips and the area picker are always the WHOLE set's, read from the backend, never just the findings loaded so far. Each card leads with its kind chips and severity, then the plain headline, what's wrong, The fix in one plain sentence, why it matters, and one line naming the audit, the part of the code and the file; More detail holds the audit's own technical fix, its technical description, the evidence, the verifier's note, the type, confidence and size of fix. Decide Fix or Skip, or press Ask AI to have one finding explained first (keys S / A / F, underlined in each button, ← / → to move, U to undo, D for more detail, 1–4 for the tabs and ? for the full shortcut list, on the desktop); a progress line ("Finding 3 of 41") shows how far through you are. Kinds of change — every open finding gets one to six labels saying what its fix would do: No visible change, Changes the screen, Changes how it works, Fixes a bug, Security or privacy, Costs money, Touches saved data, Speed and Developer-only. Omniscio writes these, and the one-sentence plain fix, in the background with the cheapest Claude model, about $0.0001 a finding and never more than $5 a day; it tags the newest audit first and works through older findings every 15 minutes. A finding not tagged yet says Not tagged yet and shows the audit's own fix labelled Technical fix; one the AI could not label after three tries says Couldn't be tagged, and the filter panel counts both. When the AI can't tell whether people would notice a change, it labels it a visible change, never No visible change. Tagging is switched off by the nightyTidyTaggerEnabled setting (on by default; an agent can flip it with PATCH /settings/nightyTidyTaggerEnabled); it also stops by itself when no Anthropic key is available. Ask AI sends just that finding — its title, what's wrong, where it is, the evidence and the fix it proposed — to a read-only explainer that answers in plain English whether the finding looks real and what fixing it would involve, and never changes anything: it cannot edit code, cannot start a fix, and never marks a finding Fix or Skip. While the answer is being written the finding stays in To review with an Asking AI badge (the phone shows it in an Asked AI tab); when it arrives the finding is back in the queue with an AI says row holding the answer. If the AI can't answer, one plain sentence says why and the finding stays exactly where it was, ready to be asked again. Desktop tabs: To review, Fixing, Skipped, Done (the phone keeps Queue, To fix, Skipped, Asked AI, Done) — a finding can go back to review from To fix or Skipped until its fix starts. Start fixing N (behind a confirm that says it spends paid AI time) fixes only the findings marked Fix that the filters show, a few files at a time, one after another; skipped and undecided findings are never touched by it. If a fix can't start right now its picks stay saved ("Waiting to start") and start once the current fix ends or the next time Omniscio starts, or you can press Start fixing again. An advisory audit's findings start here like any other when you pick them; the app's own automatic fixing never starts them by itself. An agent can ask for the same thing over the CLI (POST /nighty-tidy-2/start-fixing, which puts an approval card in your inbox), but only for findings already marked Fix: a request naming any other finding is turned away before a card appears, and an approved request that ends up starting nothing shows as failed with the reason, never as approved. To mark a large set first, one POST /nighty-tidy-2/findings/review call marks up to 2,000 findings Fix, Skip or undecided and counts as a single write against the app's 10-a-minute limit; it names any finding it could not mark, with the reason, and marks the rest. Opening a run from History still shows that run's full report (severity bar, filters, Keep / Drop, and a Fix plan card whose Review and fix button opens the deck on that audit and whose Fix waves button starts the batches you tick straight away, with no review first). The phone has the same deck, with the same kind chips, plain fix and Part of the code and Kind filters, and its pills carry the count beside each choice ("Critical 3"). Each audit + area is its own entry in the deck's audit picker ("Test Quality · Screen Recorder", "Test Quality · Full repo"), so two areas of one audit never mix, and findings the audit marked not worth doing never appear. The run's card in your inbox (see below) is a quick look at the run in the same style — titled with the audit session's own name followed by its counts ("[NT Audit] Test Quality (Screen Recorder) #3 · Nov 6, 3:09 PM — 373 findings, 3 critical") and a labelled-row table: Audit (with the automation's name when it has one), Area (the whole repo, or the part the run was limited to), one row per severity ("Critical | 3 (1%)"; a zero is dimmed, and a row opens the deck on that severity), Flagged (up to five) or Top issues (the most severe issues, each a short headline, never a file name or code), Timestamp ("3 hours ago" plus the full date and time), Model, Cost and a Session link to the audit session. Once an audit's fixes have been launched, a green status band sits at the top of the card, above the Audit row, so it is the first thing read on a phone as well, and the same band appears while you are reviewing in the deck. Review findings and Fix waves sit in the card's pinned bottom bar. Review findings opens THIS deck inside the card as one table, filtered to that run's audit + area, with Fix, Skip and Ask AI in the bottom bar (plus Start fixing once at least one finding is marked Fix), and Summary brings the card back — you never leave the inbox. The deck opens on the review page: Summary, "3 of 42 left" and a Filters button, then the finding itself — its title, what's wrong, why it matters and the fix — with its small facts (severity, confidence, size of fix, when it ran and the session) on one line underneath, and the keyboard hint below that on a computer. Filters swaps the card to the filters page (Audit, Area, Showing, Severity, the progress dots and Fix waves); Done, Esc or tapping a dot brings you back to the finding. When a severity filter is on, the Filters button names it. W opens Fix waves from either page. A top issue opens the deck on that finding. Fix waves asks you first, then fixes only the batches you tick. Keep / Drop happen in the deck, never on the card. A run that found nothing gets an All clear card in the same frame.

It has its own run history (nighty_tidy_2_runs), its own subscriptions (nighty_tidy_2_subscriptions), its own on/off switch (Marketplace → Installed → Nighty Tidy), and a moon-icon sidebar row in the sidebar's Plugins section, which is expanded by default. It ships on by default — a one-time backfill enables it, so the row is visible out of the box; you can turn the plugin off afterward. (Until 2026-09-04 the row nested under Developer Tools, which ships collapsed — that hid the row entirely and left the plugin unreachable, since its row is its only entry point. You can also reach it from Settings → Plugins → Open.) Its panel sidebar is a native column — brand → the screens as vertical nav → an Operator sessions list (see below). The original Nighty Tidy is touched zero times.

Desktop is a marketplace WEBVIEW plugin; mobile is native React. On desktop the panel renders through the generic plugin webview (src/plugins/nightytidy2/ui/) so it can update without shipping a whole app release; the webview consumes the app's injected theme tokens — surfaces, accent, semantic status colours, fonts, and the effective font size (plugin-webview-theme-contract optional-look-and-feel-tokens) — so it matches the app's look, custom themes, and text size, and draws its own nav rail (Run · Findings · History · Custom audits), which becomes a row of tabs at phone width.

On mobile the panel is native React (NightyTidy2MobilePanel) because a mobile-web surface can't host an Electron <webview>. Both talk to the SAME NIGHTY_TIDY_2_* IPC/service + live pushes (…RUN_UPDATED / …SUBSCRIPTIONS_UPDATED — forwarded to mobile web clients via INBOX_ALLOWED_CHANNELS), so runs, history, and automations stay in sync (I21). Operator sessions are a desktop feature; the mobile panel is the audit screens only.

Start Run and Cancel Run work from a paired phone. Both used to be refused with "This action is only available in the desktop app.", so the first audit of a phone batch flipped to Failed. They now go through, under a speed limit on the phone link: up to 20 audit starts at once (the Run screen's largest batch), then one every 5 seconds. If a phone batch runs into that limit, each audit waits the few seconds the app asks for and starts, rather than failing; tapping Cancel Run stops any that are still waiting. The computer has no such limit.

Launch fixes works from a paired phone too. Confirming it on a findings card used to be refused the same way, so the confirmation's button turned to "Try again" and nothing started. It now goes through, under the same kind of speed limit: three launches at once, then one every 5 seconds. One confirmation is one launch, however many batches you ticked.

On a phone, every screen's buttons stay put. Each mobile screen is a bounded column (the shared ScreenScaffold): one scrolling body with its header and its action bar pinned above and below it, so the thing you are reaching for never scrolls off. Concretely — the Run setup's Back / Next bar, the Run page's New run, History's Clear / Refresh and status chips, Findings' way back to History, and Custom Audits' New custom audit — all sit outside the scroll. The audit list itself no longer scrolls separately either: it is part of the page, so a drag moves the screen instead of being swallowed by an inner box, and each audit row is a full 44px touch target. Before this, picking audits for a new automation put Next below every audit row, under a scroller you had to reach the bottom of first (I33). (The desktop webview is at full parity with the native mobile screens: Run (the Run page and the seven-step setup, live-reload on …SUBSCRIPTIONS_UPDATED), History + the markdown Report, Findings (the review deck; a run opened from History → per-run structured detail: severity bar, severity/search/group-by filters, collapsible finding cards, and the applied-fixes card, with a markdown fallback), and Custom audits (a global list + in-panel editor that never sends a slug — the service derives the immutable one — live-reload on …CUSTOM_AUDITS_UPDATED). Editors guard unsaved changes and confirm deletes with two-tap inline confirms in place of a dialog.)

Where to find it

The Nighty Tidy panel in the app, where a run is started and its findings are read. The sessions it starts are tagged so you can tell them apart from your own.

How it behaves

The owned-vs-shared boundary

The audit-EXECUTION + apply layers are shared framework: the bundled codebase-audit recipe defers to the codebase-audit-orchestration skill, and the apply engine (spawnAndWatchApplySession + the applying-audit-findings skill) is shared. NT2 REUSES them by import — never editing an NT1 source. Provisioning keeps the installed copies in ~/.claude current via a sha-provenance refresh: missing files install, stale-but-untouched files refresh atomically when a newer bundle ships, and anything the user edited is NEVER overwritten (kept + badged "Edited" in the picker; ledger at ~/.claude/.nighty-tidy-2-provenance.json).

Split audits keep their schedules. When a broad audit is split into a focused one, the new catalog entry names its parent with splitFrom. The first time this computer's provenance ledger records the new spec, every existing automation that runs the parent gains the new audit right after it, so no schedule loses the checks that moved, and an open automation view refreshes. It happens once: an audit the user later removes from an automation stays removed. A fresh or wiped ~/.claude (an empty ledger) carries nothing, and if the update fails the ledger is not saved, so the next provisioning pass tries again. The first two splits are documentation-structure (from documentation: is the documentation organised by the repo's own rules, rather than is it true) and responsibility-boundaries (from code-elegance: does each unit do one job, at one level, on the right side of its layer). Each split spec ends its out-of-scope section with a "What is NOT this audit" list that routes findings to its neighbours.

NT2 owns NT2 reuses (shared)
Panel (native React, desktop + mobile) features/nightytidy2/ ~/.claude/audit-types/<slug>.md specs + the codebase-audit recipe + orchestration skill
IPC NIGHTY_TIDY_2_* + handlers + service nightyTidy2Service the apply engine nighty-tidy-apply-spawn.ts (applying-audit-findings skill)
nighty_tidy_2_runs + nighty_tidy_2_subscriptions + queries <repo>/audit-reports/audit-<slug>/ report layout + resolver
The stateless cadence scheduler + the structured-findings reader cron parse (getNextRun/getPreviousRun, presetToCron)
Offered-audit list resources/nighty-tidy-2/manifest.json the 24h runs-watchdog pattern
Operator session-host project __nightytidy2_agent__ (sentinel + spawnable + resolver workdir + hide + seed) the session-host shell (useProjectSessionHost + SessionHostSidebar + SessionRow)
Operator CLI control API /nighty-tidy-2/* + nighty_tidy_2.run_now approval handler + standing-context primer the run-now approval family (requireApprovalForCliNightyTidyRun, shared with NT1)

See and stop what is running

A strip at the top of every Nighty Tidy screen (desktop and phone) reads "N running · M waiting" whenever any audit is going in any repo, however it started: a hand-started run, a paced batch, or a scheduled automation. It is hidden when nothing is going. Waiting counts queued runs plus the audits a switched-on batch or automation has not started yet in its current cycle (its slugs with no fire claim for the current window, minus retired ones, capped by the automation's per-cycle count limit). An automation the scheduler will not fire again this cycle — the nightly spend or audit-count limit is reached, its own spend cap is reached, or a run-in-order ladder is holding it — counts no waiting audits, and Stop all does not turn it off. See them lists every run, grouped by repo and then by automation or batch ("Started by hand" for manual runs), with a Cloud tag on cloud runs.

  • Stop on a row stops that one audit. If it belongs to an automation or batch, the automation stays on and starts its next audit within a minute; the confirm says so.
  • Stop on a group (an automation or paced batch) turns it off, stops its running audits and drops the ones still waiting. Turn it back on from the Run page.
  • Stop all does that for everything in the list, after one confirm naming the automations it will turn off.

A stopped run reads Cancelled by you. in History and never counts toward retiring an audit for repeated failures — and neither does an audit whose session you closed yourself before it finished. A cloud audit stops the same way: ending its session stops the cloud worker.

How to use it

  1. It's on by default — Nighty Tidy ships enabled in the sidebar's Plugins section; toggle it any time in Marketplace → Installed; its card at Settings → Plugins → Nighty Tidy has an Open button that takes you straight to it.

  2. Run an audit — pick a project; choose Read-only (just the report) or Read-write + a severity (Critical / Critical+High / +Medium / All); tick audits — or use the Select all / Deselect all toggle by the Audits heading to pick (or clear) the whole list in one tap; optionally type custom instructions to scope every audit in the run, and optionally choose a non-default engine + model for the audit and a fix engine + model for its fix waves; Start Run. The cost estimate beside the button prices the run you are about to start: it averages your past runs of the same audits on that same engine and model, so a cheap model is never quoted at your expensive model's price. When that engine and model have no priced run yet, the figure is taken from runs on other engines and says so ("· other engines"), and it never counts toward the nightly cap — only a same-engine estimate does. Enter starts the run from the keyboard; while a read-write confirm is armed Enter confirms it and Escape cancels. Each audit is a regular session (source: 'nighty_tidy_2', Nighty Tidy: <Title>), visible while it works — and when it finishes the session files itself away and you get one card in your inbox with the result: "<Audit> audit found N things to fix", "<Audit> audit: all clear", or "<Audit> audit didn't finish" with the reason. Every finished run gets this card, however it finished — including one the app recovered after a crash or a restart, and one an audit started for itself. An audit whose findings list arrived incomplete shows as didn't finish, with that reason, rather than as findings. The card carries its own buttons and its own review, so you do not have to go looking for the panel: the title is the audit session's name followed by "— N findings, X critical", and a labelled-row table follows — Audit, Area (the whole repo, or the part the run was limited to), one row per severity with its count and share, Flagged (up to five) or Top issues (each a short headline led by its severity dot — never a file name, a line number or a piece of code), Timestamp, Model, Cost and a Session link. Findings the audit marked not worth doing are left out of every count. Two ordinary buttons sit in the pinned bottom bar. Review findings opens the review deck INSIDE the card as one table — filtered to that run's audit + area, with Fix, Skip and Ask AI, plus Fix waves for the run on screen, in the bottom bar — and Summary brings the card back; its keys (S Skip, A Ask AI, F Fix, the arrows, W for Fix waves, Esc) are underlined in their buttons and listed in that order below the finding, and work only while the deck or its bottom bar has focus — there they come before the app's own single-letter shortcuts. Fix waves opens the launch dialog, whether or not you reviewed anything. How many fix sessions may run at once is set by two settings: Audits fixing at once (how many audits may have fix sessions running at the same time, 1 by default) and Fix sessions per audit (2 by default). An audit that is already fixing can always keep going. Set both to No limit and every batch you tick starts at once. Fix waves never starts anything on its own click. It opens the app's Start session dialog — the same one every screen uses — with a box for your own message (it goes first in every batch's fix session) and, below it, a confirmation that says what will be fixed (how many issues, in how many batches), where it runs (on this computer, or in the cloud one batch after another), how many fix sessions that is, and that fix sessions use paid AI time. You tick which severities or single batches to fix — Critical and High are ticked to begin with — and every number follows your ticks. Every batch that has not started is offered, including ones you picked earlier that are still waiting and ones the run's own fix level would start later, so you can start any of them now. Severity groups with nothing ticked start folded behind an arrow; ticking one opens it. Below the batches, How fix sessions run — the same panel the deck's own Start fixing dialog shows — opens on what this run already has saved. It is the same picker as a new session, inline: harness, provider, model, effort and where it runs (this computer or the cloud), with every harness on offer. Where it runs locks once a batch has started — including a batch a fix session is already working on — so one audit never runs in two places. For fixes on this computer there is also an Archive each fix session when it finishes switch. With it on, a fix session whose work has landed leaves your inbox by itself within about a minute, even if its last message offers more work. A session that truly needs you (money, data, security, or a blocker only you can clear) says so and stays in your inbox until you reply. Turn the switch off to keep finished fix sessions in your inbox so you can read them; they still free their place in the queue once their work is done. With Cloud picked, the batches run one after another on the engine you pick; a cloud run you never picked an engine for shows, and uses, the cloud workers' own engine. An engine the cloud cannot run is refused before anything is queued, and a custom provider setup cannot run fixes yet, so Start waits. If the cloud workers are switched off, a warning offers Turn on cloud workers (this also starts any other work already waiting in the cloud queue) or Run on this computer, and Start stays greyed out until one of them is done. What you change is saved on the run, so batches that start later use it too, and a launch that starts nothing puts the old settings back. Start session is the only thing that launches; Cancel, Esc, plain Enter and clicking outside start nothing. Start closes the dialog at once, and the batches start behind it; the toast says how many batches are starting, counting the ones the app actually accepted rather than everything you ticked. If the run refuses the choice outright a toast says why in plain words, with Try again sending the same choice and message; if the launch is accepted and then starts nothing, a note says so in plain words naming what went wrong. A second Start while the first is still starting is refused rather than launching twice. The card then says what really happened, in that band at the top of the card: how many of the run's fix batches have started, which batches are still waiting their turn, by name, and a link to the fix progress. It says Starting… while the batches are still spinning up, and it updates itself the moment the launch settles — so a launch that started nothing shows the ordinary buttons again rather than a dead panel. When there is nothing to launch — no fix plan, or every batch already started or finished — the button is greyed out and the card says why beside it. A failed card's Open session opens the audit session that ran it. Dismiss the card and it stays dismissed. A read-write run, after a findings audit, spawns a separate fix session (applying-audit-findings) at the chosen severity; a fully-green fix run auto-lands into your main branch (a failed or dependency-touching run is held on its branch for review with an inbox alert). A failure the main branch already had does not hold a fix run back: the failing tests and the failing type errors are each checked again on the main-branch copy the fix started from, and only a failure that is not there counts against the fix. A batch the app has started three times that still has open issues reads Stuck in the fix plan, with the reason its last session wrote, and the app does not start it again by itself; start it by hand from Fix waves or close its issues. On a developer's computer (not the main one) a green fix run also publishes its own pull request to GitHub, so the fixes reach the team without a manual step. The auditFixSessionsPublishOwnPr setting controls this: unset follows the computer's role (on for a developer's computer, off on the main computer). It has no Settings row yet, and only the person can change it — ask your agent to set it for you.

    Choose Comment Debt (Documentation) when your code is full of comments that tell stories — incident write-ups, dated measurements, "we chose X because…", rules nobody enforces, ticket numbers, how-to steps — or when reports and notes sit in source folders instead of your docs. It first maps your documentation system, then lists every piece of debt in one table: where the text belongs (a postmortem, a decision record, a contract plus a test, a guide, or just git history), and the exact short line that stays in the code, or "delete". Comments that explain a real "why" at that line, public API docs, and anything a test reads are left alone. Auto-fix may act on it, and always copies the text to its new home before trimming the comment. It deliberately differs from Documentation, which checks whether comments and docs are wrong; Comment Debt moves text that is true but in the wrong place.

    Choose Abuse & Adversarial Misuse when you want Nighty Tidy to think like a malicious but legitimate user: it traces how valid features, identities, incentives, lifecycle transitions, automation, and feature combinations could create unfair value, shifted cost, harassment, manipulation, resource exhaustion, or hard-to-detect harm. It is intentionally separate from Security Sweep, which looks for technical vulnerabilities such as authentication, authorization, injection, and secret exposure. The abuse audit is always read-only and requires a reachable, evidence-backed path before reporting a finding; it does not perform live exploitation or external actions.

    Choose Efficiency when you want to find the work your software repeats that nobody needed. It prices every finding as the cost of one run × how often it runs × how many copies run at once, so it catches what a line-by-line review cannot: a cheap call made every few seconds in every open session, a new process started for every small question, polling where a signal already exists, work redone although nothing changed, capacity left idle while work queues, and waste in build pipelines and AI calls. It works on any kind of software and measures with the repository's own tools where it can. It deliberately leaves slow algorithms, how long database queries take, what a database stores and the work it does, rendering, cloud sizing, test speed, perceived speed and memory leaks to Performance, Database Waste, Cost & Resource Optimization, Test Efficiency, Perceived Performance and Memory Leak — run those alongside it for full coverage. Every Efficiency report lists all 35 optimization categories, with the audit that owns each.

    Choose Database Waste when you want to find what your databases keep, write and are made to do that nobody needs: data no code ever reads, the same facts stored twice, oversized values like whole transcripts or files kept in a column, history kept forever, deleted rows that are never purged, indexes that slow every save but serve no query, saves that change nothing, backups or copies that pile up — and the work the database burns for nothing: reads whose result no one uses, and statements that sift through hundreds of thousands of rows to hand back a handful. It measures storage and work read-only first and prices every finding in space kept, growth per day, disk reads, disk writes and CPU per day, and it only calls something unused after proving nothing reads it. Its fixes never delete data a person created — only rebuildable, duplicate, expired, diagnostic or already-deleted data; anything else comes back as a decision for you, with what keeping it costs.

    It deliberately overlaps Performance: a query can finish in twenty milliseconds and still be wasteful, so Performance judges how long queries take and Database Waste judges what they made the database do — rows examined, disk reads, CPU burned. Either may report such a statement and each names the other, so running both gives you both halves rather than a duplicate.

    Choose Git Efficiency when you want to find what makes git slow for everyone who works in the repository: git commands your code, scripts, hooks or CI run that nobody needed, one git command per item where one batched command would do, commands that walk all history or every branch when the question needs a slice, CI jobs that clone more than they use, commit shipping sized by whole files instead of a diff, and a git store slowed by too many packs, loose objects, refs or leftover worktrees, or by big files that should never have been tracked. It sizes up your repository first, prices every finding in git process starts, seconds and bytes per day, and works on any repository. It only ever reads the git store — it runs no clean-up, repack or fetch and changes no setting; store maintenance comes back as a list of recommended steps for a person to run. It runs read-only by default. How often a hook fires and the non-git work inside it stay with Efficiency, and pipeline structure with DevOps.

    Choose Systematization (Architecture) when you want to know which jobs your codebase does piecemeal in many places with no owner — switches, timers, process launches, retries, logs, registries, permission checks — and which of them should become one named system: a single entry point, a complete list, and a check that keeps new code on it. It needs three or more independent copies and evidence the scattering has already cost something before it recommends anything, and "leave it scattered" is a normal answer. It is advice only: it never changes code, and its findings are never applied automatically.

    Choose Guardrail Integrity (Architecture) when you want to know whether the rules your project relies on are really enforced. It pairs every written rule with the check meant to enforce it, and flags rules no check covers plus checks that cannot fail — a pattern that matches no files, a block that only warns or is switched off, a skip that reports as a pass. Advice only, like every audit in this group.

    Choose Parallel Change Friction (Architecture) when branches or agents working at the same time keep colliding. It reads the repository's merge history, finds the files and data shapes every change must edit — shared lists, numbering that every insert shifts, one file holding everything — and recommends the shape that would let each change merge cleanly. A repository with no parallel work gets "no parallel friction".

    Choose Unfinished Migrations (Architecture) when the code seems to do some jobs two ways because a move from an old library, API, pattern or storage format stalled. It counts each side, checks from history whether the move is still happening, and recommends finishing it, freezing it with a check, or rolling it back.

    Choose Domain Language (Architecture) when the same thing goes by different names on screen, in the docs and in the code, or one name means two things. It maps every concept to its names and recommends one name per concept plus a glossary — and it never renames stored data.

  3. Schedule it (optional) — New run → pick the project, area and audits, then on When choose Once, later (a day and a time) or On a schedule (days and a time), choose on Fixing whether it only reports or fixes automatically, give it a Name on Review, and Save automation. It appears on the Run page under On a schedule or Coming up once with its own on/off switch; click it to open the same setup on Review, change anything with Change, and Save changes. Add as many automations per repo as you like (one per feature); automations that give the same audit different instructions run it side by side, and so does one audit started on a different engine or model, or on this computer and in the cloud at once (handy for comparing two models). Two starts of the same audit with the same instructions, engine, model and place are refused as a duplicate. Leaving the model on Default runs it on your app-wide default engine and model, so it is the same choice as picking that engine and model by name. Remove one with "Delete this automation" on its Review step (click twice). Switching an automation Off (or deleting it) also stops any of its audits already running: each one is left stopped by you, shown as interrupted with a note that its automation was turned off, and nothing restarts it on its own (no app restart, crash recovery or stuck-session sweep) — restart it yourself if you want it back. The global concurrency cap and the nightly spend/count warning limits live in the "Global pacing & limits" editor (the Run page's Limits button). Everything live-reloads when ANY writer saves/deletes an automation — including an operator session over the CLI API (NIGHTY_TIDY_2_SUBSCRIPTIONS_UPDATED push). Over that CLI an operator can change just ONE field of an existing automation — e.g. move the nightly audit to 8 PM, or send it to a cloud machine with {"location":"cloud"} (null brings it back here) — with a partial PATCH /nighty-tidy-2/subscriptions/:id, no need to resend the whole config (omitted fields are kept, run history untouched, no restart).

  4. Review and launch the fixes — the Findings tab is the review deck: mark each finding Fix or Skip, then press Start fixing to fix only the ones you marked. Or, from that run's card in your inbox, press Fix waves, check what it will start and press Start N fix sessions (findings you dropped in the deck, and findings the audit marked not worth doing, are left out). The panel's Fix plan card has the same Fix waves button beside Review and fix, on the phone and the desktop. Either way: the first fix wave starts on the machine the audit ran on, and on your computer the rest start with it — as many as Fix sessions per audit allows, never two that work the same file; on a cloud machine they follow one after another. Audits fixing at once decides how many audits may be fixing at the same time; another audit's fixes wait until a place frees. Both settings (the phone's Run page Limits, or Settings → Cost Control) take any number from 1 to 60. Either limit is yours to remove: set both to No limit and nothing holds a wave back except a file another wave is already editing. The click is your approval — nothing is asked in a chat. Only the batches you picked, and the ones inside the run's own fix level, ever start: a run with no fix level (none was chosen, its automation's fix is switched off, or its audit's own auto-fix level is Off) never starts a batch on its own, even after one of its waves was started by hand, and a "launch everything" request for such a run from the CLI is refused in plain words. A fix wave you pause stays paused: nothing starts a second session for it, so resume or end it yourself. A run started with a fix level (the Auto-fix page) skips this step: the app starts its fixes on its own when the audit finishes, waiting in line for a free fix slot, and the audit's last message says the fixes are starting rather than asking you to launch them. An advisory audit (its findings are judgment calls) is never fixed automatically, but you can start its batches from any of these buttons whenever you choose; its fix session checks with the app that you really picked that batch before it starts work. An audit the app starts on your computer writes no report file and copies nothing into your project; its findings live in the app. A cloud audit still writes its report on the cloud machine so it can come home. A subsystem-map finding additionally offers "Create an automation…", which opens the Run setup PRE-FILLED with that subsystem's name, scope paths, recommended audits and cadence — that audit names one subsystem per finding and states the scope it should be run against, so the action just saves retyping it. It only opens a draft: nothing is created or enabled until you save it on Review, because a scheduled run costs money on every fire. Findings from other audit types carry no recipe and show no button.

  5. Write your own audit (optional) — on the Custom audits screen, New custom audit opens an editor: give it a name, a category, an optional one-line description, and a plain-language "what should this audit look for?". Save it and it appears in the Run setup's audit list next to the built-ins (badged Custom), running exactly like them — read-only or auto-fix, one-off or scheduled. You only describe WHAT to look for; the audit engine supplies the multi-phase sweep + the findings list, so a good custom audit can be a few sentences. A custom audit is offered for every repo by default, like the built-ins — or set Runs on to a single project and it is offered for that one only, hidden from the Run setup's audit list everywhere else (and refused if something still tries to run it elsewhere, so an automation saved before you scoped it cannot quietly fire on the wrong repo). Scoped or not, it always stays on the Custom audits screen so you can edit or delete it — including after you remove the project it was scoped to. Edit or delete your own any time (the built-ins stay read-only). The list live-reloads when any writer changes it — including an operator over the CLI (NIGHTY_TIDY_2_CUSTOM_AUDITS_UPDATED push).

  6. Send a run to a cloud machine (optional) — an audit can run on a rented cloud machine instead of your own computer. Open More settings on the setup's Review step and pick Cloud machine under Run location; leave it alone and nothing changes, because Local is the default. A cloud run goes through the same one gate every other cloud launch goes through, so the cloud kill switch, the one-time spend consent, the billing check, the clock check and the engine check all still apply — and if the cloud cannot take the run it stops with a plain reason on its row rather than quietly running here. When it finishes, its report and findings come back to the same place a local run's do, and History reads the same. If a cloud audit is cancelled (or its automation is switched off, or its session is closed) before it finishes, the app takes one look at that machine without switching it on, keeps whatever findings the audit had already found under that same run, and the run still reads stopped, never complete; a finding the audit had not yet had checked carries no verdict, and the Findings screen says so plainly — a neutral Not yet checked pill sits where the verdict pill goes, on the desktop panel and on the phone, so an unchecked finding never reads as a verified one. (Any finding with no verdict gets it, a red-team finding in a finished run included: no verdict means nobody checked it.) If the machine is already switched off, or holds nothing of that run, nothing is kept and the run is left exactly as it was, and the review deck keeps showing the audit's last completed run first. Two things worth knowing: a cloud automation skips its auto-fix step (the fix session would be a code-editing session on your own computer, which is not what "run in the cloud" should mean), and a cloud audit's session is ended once its report is home so the machine is not woken a second time to collect work that is already here. Cloud runs are offered only when cloud sessions are switched on for the install; the choice is hidden otherwise, never shown and then refused.

How a finished audit's results reach the panel

An audit files what it found; the panel reads it from there. When an audit finishes it publishes its findings over the local API, by piping them straight in from the session. That publish IS the report and the fix plan: an audit the app starts on your computer writes no file at all — no report.md, no waves.json and no findings.json — and copies nothing into the project or a backup folder; what it keeps is the findings it publishes. A cloud audit is the one exception: it runs where it cannot publish, so it writes its report on the cloud machine and the app brings it home — the findings you see still come from that report. The Findings screen is built entirely from the findings that reach the app.

What the verifier corrected is what you see. When an audit's findings are read from its verification step, each corrected field rides along with the verdict — the plain-English "what's wrong" and "what to do", the suggested change, how big the fix is, the confidence, and the original severity when the verifier re-priced it. A field the verifier did not touch keeps what the auditor found, so confirming a finding changes nothing. A saved publish that never got through can also be older than what the app already holds; once that run holds findings, the older copy is dropped rather than replayed, so a corrected row is never rewritten with pre-verification text.

The app writes the report, at three levels you can read. A run has a readable report even when the audit wrote no report file at all — which is every audit the app starts — because it is built from the findings already saved, so a run from weeks ago reads the same way. It gives you the run at three depths: a glance (a headline and one paragraph, with the four severity counts, and the three most serious issues, each with one nested plain-English sentence explaining it), a summary (each finding on one line in whole sentences, grouped by category — when a finding's plain words run past the line's length, only the sentences that fit stay, cut between words, never mid-word), and the full detail (where it is, what is wrong, the evidence, the suggested fix). Open it from a run's Report button, or from Open report on an all-clear run's card. A run that did not finish reads as what it is — still running, queued, waiting on an answer, skipped, stopped by you, or closed before it finished with the run's own recorded reason — so the report never tells you an audit found nothing when it never got the chance to look. It only reads; Keep / Skip stay in the review deck.

Each finding records which fix wave owns it. The app groups the findings into waves itself — worst severity first, then by folder, a file's findings kept together, with a hard cap on how many fix sessions one audit can need — and keeps each finding's group on its row, so a fix session can ask for its own work list by wave. It does this however the findings arrived: from the audit's own publish, or recovered later by the app after a cloud audit's report came back late or a stopped audit's findings were saved. An audit whose findings are still arriving waits for the rest before it gets its waves, and an audit you have already started fixing is never regrouped. If an audit finished with findings but no waves (an older app could leave one that way), the next time Omniscio starts it gives that audit its waves. Asking for a wave a run does not have is refused, with that run's actual wave names — an empty list is indistinguishable from "this wave has nothing to do". A finding the plan leaves out of every wave stays unassigned, which is what the report shows as unscoped.

A finished audit's fix waves are started from the panel — never by the audit itself. You press Start fixing in the review deck (only the findings you marked Fix) or Fix waves on the run's inbox card, in the card's review bar or on the panel's Fix plan card (only the batches you tick in its confirmation) — at any time, with no review needed first. A finding the audit marked not worth doing is never part of any batch's work. The first wave with work left is handed to the app's one wave road, which titles it ([NT Apply] …), builds its brief, and records the new session against that run's wave row — so the panel can show which wave is running and a second session is never started for a wave that already has one. The remaining waves start straight away, even when the run's automation does not auto-fix: your click is the intent the chain carries (from the card's Fix waves, that means exactly the batches you ticked — an unticked batch never starts, whatever the run's own fix level). On your computer a run's fixes start together — up to Fix sessions per audit (or with no limit at all, if you set one), and never two waves that share a file; a wave held back for either reason starts on its own as soon as a fix session ends or the wave sharing its files finishes. A wave counts as finished the moment its own apply state reads done — complete: it stops taking a place within a minute, even while its session stays open to hand its branch off or wait for a reply. A cloud wave on Omniscio's own code lands the way every cloud session does: when its findings are reported and its checks pass, it runs the ordinary ready command, which brings its commits home and asks for the ready tag the auto-lander lands. Its work does not come home and land on its own when the wave simply stops. Fixes sent to a cloud machine start only when you ask for them: when a cloud wave comes home the app does not start the run's next ordinary wave, so it waits as Ready until you start it — from the review deck (pick its findings and press Start fixing) or by having a session ask over the CLI. There is no one-click "start the next wave", on purpose. The one thing the app continues on its own is a wave you picked in the review deck, one at a time. Every wave fixes everything at the run's chosen level, not only findings matching the wave's own label, so a medium-level run's high wave also fixes the medium findings riding in it. A wave's brief names only the findings you kept, and a wave whose findings you all dropped is not started. Automations set to auto-fix keep starting their own waves.

Starting a fix wave is one request. Whether the app began the wave after an audit or you asked for it by hand, it goes through POST /nighty-tidy-2/runs/:runId/waves/:waveId/spawn, which asks you to approve first — it spawns a session that edits your code. Waves run on your computer by default; you can also send one to a cloud machine from the Run page's Limits (Global pacing & limits) (offered only where cloud sessions are enabled), where it becomes one job for a cloud worker that reports each finding back the same way. Two things it deliberately does not do: a run that starts its own fix has nobody to hand the job to, so that one still runs here, and the cloud worker queue has to be switched on. Ask for a cloud wave without either and it is refused in plain language, naming what to change, rather than queued against nothing.

A wave with nothing left to do is not started. A wave is refused if every finding it was given already carries an outcome, so asking for one by hand — over the CLI route, or from a stored plan whose row never recorded a session — cannot start a session with no work in it. The refusal names the wave and says why. It is deliberately narrow: a wave with even one finding still open, a wave whose findings have gone missing, and a wave whose findings all failed (a fix that did not hold is work still outstanding) all still start.

A finding recorded wrongly can be put back on the open list. Sometimes a finding is marked skipped ("already on master") or applied when its fix never actually reached master, and then its wave counts as finished. An operator session can reopen named findings with POST /nighty-tidy-2/runs/:runId/findings/reopen and a body of {"findingIds": ["F010", "F012"], "reason": "why the recorded outcome is wrong"}. The reason is required. Each reopened finding goes back to open, its old commit and skip reason are cleared, and its note keeps the reason, who reopened it, and the outcome it replaced. The answer lists what was reopened, which waves now hold that work, and what was refused (a finding that does not exist, one the audit ruled out, one dropped in review, or one already open). Then ask for that wave again with the spawn route above and it starts for the reopened work. A wave whose work was already delivered is still refused. When you ask for a wave again by name and some of its findings were recorded fixed with no commit at all, the app reopens those for you first (with that reason in their note), and any whose recorded fix never reached GitHub are put back on the wave's work list, so the new session names that work instead of starting with nothing to do.

A fix wave that runs out of checks keeps going in a new session. A wave gets three check runs for its own change. If its last one still fails on something the wave caused, it saves its work as one commit, leaves its findings open on that commit, and closes itself without asking anyone. The app then starts a fresh session for the same wave, which picks up from that saved commit with three new check runs. A wave that stops and waits (for example, it ends on a question) is nudged twice; after that the app ends it and starts the wave again the same way, unless the wave asked you for something only you can give. A fix wave also cannot mark a finding fixed unless it names the commit that fixed it.

A wave that can never start does not stop the rest of the plan. A wave the app can never start — findings all recorded, a cloud job the worker vetting will never accept, an attempt already over — is passed over and the run's next wave starts instead. That judgment is remembered for where the wave was being started, so a cloud wave the worker could never take is not held back after you switch fix waves back to your own computer. Everything else is tried again: most importantly the fix-session limit, which is a wait rather than a dead end.

A run you started by hand remembers where it was, across a restart. A run whose wave you started — from the panel or over the CLI — records that it still has waves to run, so after an app restart the app watches every wave still running and starts the rest instead of leaving the plan stranded; a wave refused because a fix limit was full waits in line and starts when its turn comes, without a restart. A freed slot goes to the run that has waited longest, not back to the run whose wave just ended, so one audit with many waves cannot keep its slot while every other audit waits. Runs on your computer are chained by the app. A run whose waves go to a cloud machine is not: nothing starts its next ordinary wave when one lands, and the app continues only the waves you picked in the review deck.

A wave that lands without reporting its findings still gets them closed. A wave can end before it reports — it crashed, was archived, or simply stopped — and if its branch then landed, its findings would sit looking unfinished even though the fixes are on master. An hourly check marks the unreported findings of a landed, no-longer-running wave applied, each with a note saying the app marked it rather than the wave. It never touches a wave whose work did not land or is still running, and never overwrites an outcome the wave reported itself — including a failed one, which is a real verdict, not a missing answer.

An applied finding also carries a short note on how the fix went. A status alone cannot say whether the fix landed cleanly or fought back, so the AI that applies a finding records a short plain-text note beside its status — "applied cleanly", or what got in the way ("applied, but the fixture needed a hand edit"). It is written for every finding the wave applies or skips, kept on the finding, and shown back next to that finding's status; a finding a cloud worker fixed takes its note from the worker's own final report. The note is stored and displayed exactly as written, never treated as formatting.

The report folder is the identity, so an audit never has to be told its run id. An audit that lost its run id, or was never handed one, publishes with the folder it wrote to; the app matches that folder to the run it belongs to and — when there is genuinely no run yet — registers one right then, so the work is never refused because the caller could not name a run. Only the first batch of a publish may create a run this way; every later batch is filed against the run it resolved.

A registration is only ever filed under a project the app still has. A run row's project is a real link to a project, so a registration that names one the app no longer has is filed under the project its report folder belongs to instead; with neither to go on, the caller gets a plain refusal naming the problem rather than a database error.

A publish that cannot identify its run is kept, not dropped. If a publish fails, the whole payload is spooled (the ten most recent) and re-tried after the next one goes through. A payload that is permanently refused — including a "not allowed" (403) answer — is stamped and skipped rather than retried forever.

A cloud audit publishes its own findings too — into its own run, and only that one, which the app checks before accepting them. If such a publish still fails, the helper says so plainly: its spool lives on that machine and disappears with it. The findings come home another way — when the run settles, the app copies the audit's report folder back and reads its findings from it.

A run an audit opened for itself is settled when its findings land. It is marked as belonging to the audit that made it, so once its findings arrive the run moves off "running" on its own, and the overnight watchdog leaves it alone rather than restarting or failing a run still being worked.

  • The original (legacy) Nighty Tidy (nightytidy) has been retired and removed. NT2 reuses the shared audit framework + apply engine it left behind; everything user-facing is forked.

Last verified 2026-11-05