foldrun 2.2.0 → 2.3.0

package/docs/runs.md

@@ -17,6 +17,7 @@ Each run holds its steps in group order. A step carries:
 | `data` | the parsed value, for a step with `output: json` |
 | `events` | tool calls, script runs with their timing, verify verdicts, refusals. A tool call is a pair of events, the call and its completion; the completion carries `ms` and, from 18 Oct 2026, `bytes` — the result's length in characters, which every later turn sends again |
 | `turns`, `systemPromptChars`, `stopReason` | model turns, summed across attempts; the system prompt's length in characters (it rides on every turn); why the last turn ended. With the events' `bytes`, these say where a step's input tokens went. From 18 Oct 2026 |
+| `promptLayers` | the system prompt's layers, stable ones first: `name` (`persona`, `agents.md`, `skills`, `knowledge`, `rules`, … then `memory`, `state`, `clock`), `chars`, `hash` (12 hex characters of its SHA-256) and `stable: false` on the ones that change between runs. Two steps of one agent compared layer by layer say why the [prompt cache](budgets-and-billing#prompt-caching) missed; the run page and `foldrun report` do the comparison. From 20 Oct 2026 |
 | `costUsd`, `tokens`, `computeSecs`, `startupSecs` | what it cost and how long the sandbox lived — **summed across its attempts**. `tokens` is `{ input, output, cacheRead, cacheWrite }`: `input` is all input, and `cacheRead` and `cacheWrite` the part of it the [prompt cache](budgets-and-billing#prompt-caching) served and stored. Steps recorded before 18 Oct 2026 have only `input` and `output` |
 | `startup` | where the step's first seconds went: when each start-up phase ended, in seconds since the step started — `services` (the account's search/browser pods up), `room` (room on the cluster to start — see [Budgets and billing](budgets-and-billing)), `applied` (sandbox created), `ready`, `files` (workspace copied in), `go` (step released), `shim`, `system` (system packages restored), `driver`, `imports`, `tools` (runtime and tools built) and `model` (the model's first text or tool call). Only the phases the step went through; `null` for a step that ran in-process, absent before 17 Oct 2026. The last attempt's |
 | `image` | which runner image the step's sandbox ran (isolated runs on a cluster): `variant` `full` or `slim`, `why`, and `pod: true` when a browsing step ran slim and browsed through the account's browser pod ([slim steps and a lost pod](tools#slim-steps-and-a-lost-pod)) |
@@ -72,10 +73,194 @@ step that drove a browser shows it live, then plays its recordings — see
 
 The account's home opens on **mission control**: what is **running now**
 (each run's step and agent, and anything running over an hour flagged), what
-**needs attention** (the newest failed, BAD or BLOCKED run of each flow in
-the last day with why, and anything waiting for an approval), and every
-desk's **last 24 runs** as a strip of cells beside its success rate, runs
-today and a week's spend. Every row and every cell opens its run.
+**needs attention** (every open [issue](#issues), anything waiting for an
+approval or an answer, and anything stuck), and every
+desk's **last 24 runs** as a strip of cells beside how many of them
+completed and what went wrong (`20/22 · 2 failed`), runs today and the
+credits charged this week. Every row and every cell opens its run.
+
+Money on the overviews — Home, the desks list, a workspace's flows and
+agents, Observe, the runs list and a run's own page — is **credits charged**:
+the ledger's line for the run, one credit to a cent. A run the ledger has not
+settled yet shows its list price, marked estimated (`~` in the runs list,
+"est. charge" on its page). The provider's token cost is not the bill; it is
+on a run's page under the figure, and in Usage.
+
+Every page counts runs the same way. **Completed** is a run that ran to the
+end without failing, whatever it found; the rate is completed out of
+completed plus failed, and a run a person stopped is left out. What the
+completed runs found is counted beside it: **blocked** (BLOCKED), **problem
+found** (BAD), and **nothing to do** (QUIET).
+
+## What a run records
+
+Every step keeps, beside its events:
+
+- **each model call**: when it came back, how long until its response
+  began arriving (from the request going out), the model, why it
+  stopped (`tool_use`, `end_turn`, `max_tokens` …), its tokens with how many
+  the cache served, and how many tools it called. A step's **model calls** row
+  on the run page lists them; `foldrun report <run-id> --calls` prints them.
+- **each tool call's input and output** — what the agent gave the tool and
+  what came back. Open **input / output** on a tool line in the trace, or
+  `foldrun report <run-id> call <call-id>`. Each part is kept up to 65,536
+  characters (the length of the whole is shown when it was cut), and a step
+  keeps at most about 4 million characters in all — past that its calls keep
+  only their names, sizes and times, and the trace says so. Secrets are
+  masked before anything is written, then the text is cut: the step's own
+  secrets by value (`[redacted:NAME]`) — a file secret such as a key by its
+  content, line by line — then anything shaped like a key, and any private
+  key block. The input is what the agent asked for; a [hook](hooks) that
+  rewrote it before it ran is in the trace beside it. The content is kept
+  beside the run, not in it, counts toward the workspace's storage, and goes
+  when the run is deleted or ages out.
+
+And the run itself says **which files it ran** — the workspace's latest
+revision when a worker first picked it up ("ran on abc1234"; a deploy's is
+its commit) — and **how long it queued** before that. A step that runs after
+an approval, or after a deploy mid-run, may run newer files than that.
+
+A workspace that should keep no content writes `capture: metadata` in its
+`AGENTS.md` (or the account's): model calls, tool names, sizes and timings
+are still recorded, inputs and outputs are not.
+
+## The trace tree
+
+A run's page opens with its **trace**: the run as one tree, each step, each
+model call it made, and each tool call under the model call that asked for
+it, every line with a bar on the run's own clock. A model call shows its
+model, tokens (and how many the cache served) and why it stopped; a tool call
+shows how long it took and, where it was recorded, its **input / output**.
+Errors are lines of their own. The tree opens on the first thing that went
+wrong — a failed tool call before the step's error line, before the failed
+step — and highlights it; **expand all** shows every call.
+
+`foldrun report <run-id> --tree` prints the same tree in the terminal, with
+`← what went wrong` on that line, and `GET /api/workspaces/<ws>/runs/<id>/trace`
+answers it as JSON. Runs from before 19 Oct 2026 have no model calls on
+record; their tool calls sit under the step.
+
+### Sending the trace to your own tracing
+
+The same tree can go to the OpenTelemetry collector you already run —
+Grafana Tempo, Honeycomb, Datadog, Jaeger, Langfuse, anything that takes
+OTLP — so agent runs sit beside the services they act on:
+
+```yaml
+telemetry:
+  otlp: https://otel.example.com/v1/traces   # the collector's OTLP/HTTP traces URL
+  headers:
+    authorization: ${OTEL_TOKEN}             # a vault secret, by name
+```
+
+In the account's `AGENTS.md` (Settings → API → *Send runs to your
+tracing*, or `foldrun account telemetry set <url> --header
+authorization='${OTEL_TOKEN}'`), or a workspace's, which replaces the
+account's whole. Every run that finishes is sent as one trace: a span for
+the run, each step (with `foldrun.agent` and `foldrun.owner`), each model
+call (`gen_ai.request.model`, token counts, finish reason) and each tool call
+(`gen_ai.tool.name`), failures as error spans. Resource attributes name the
+account, workspace, flow and run. Ids come from the run's, so a run sent
+twice is one trace. Test runs are not sent.
+
+*Send a test trace* (`foldrun account telemetry test`) sends one made-up run
+and says what the collector answered. A header whose secret is not in the
+vault stops the send and says which; a token written into the file is
+refused by `foldrun check` and the deploy. The collector is reached like a
+`notify:` webhook — never a private address — and a slow or failing one
+never holds a run up: a failed send is logged on the platform, not retried.
+
+## Searching runs
+
+The runs pages search by what happened inside a run, not only its status:
+**tool** (a step called a tool whose name contains it — `web`, `crm`), **a
+tool errored**, **agent**, **model** (contains — `haiku`), **≥ tokens** (input
+read by all its steps, `50k`) and **≥ secs**. A search can be kept as a named
+**view** (save view), yours on every browser; the views sit beside the search.
+`foldrun runs --tool web --tool-error`, `--agent`, `--model`, `--min-tokens`,
+`--min-secs` and `--view <name>` do the same (`foldrun runs views` lists
+yours), and `GET …/runs` takes `tool`, `tool_error`, `agent`, `model`,
+`min_tokens`, `min_secs`. Tools and models are searchable on runs from
+19 Oct 2026; tokens and time on every run.
+
+## Insights
+
+The account's **Observe** page opens with **Insights**: the problems that keep
+costing without failing anything, found in the last week of runs with nothing
+to set up. Each says what it is, why it happens, what to do, about how many
+credits it cost, and links the runs it was seen in:
+
+- **mostly uncached** — an agent sends a big prompt the model's cache rarely
+  serves, step after step (something near its start changes every call);
+- **a big tool result sent again** — a tool hands back more than 20,000
+  characters and every later model call in the step pays for it again;
+- **a retry loop** — a tool errors three or more times in one step and the
+  agent keeps trying;
+- **near its timeout** — steps that use 80% or more of their `timeout:`.
+
+`foldrun insights` prints them; `GET /api/insights` answers them.
+
+## Compare with the last good run
+
+On a finished run, **compare with the last good run** lays it beside the
+newest earlier run of the same flow that finished well (or, failing that, the
+run it re-ran). It says whether the two ran the same files and which files
+changed between them, then, step by step, what differs: status, a new error,
+the instruction, the model, tool calls and tool errors, how long it took, the
+tokens it read, the model calls it made, and the first line it said. Steps that
+did not change are left out. `foldrun report <run-id> --compare [<other-run>]`
+prints the same, and `GET …/runs/<id>/compare?with=` answers it.
+
+## Issues
+
+What went wrong is an **issue**, and it stays open until a person resolves
+it. One issue is the same thing going wrong again:
+
+- one desk's flow **failing** at the same agent;
+- one desk's flow ending **BLOCKED**, or finding a problem (**BAD**);
+- one desk's scheduled flow **not starting** when it was due (see below);
+- one **platform** cause across every desk it hit — sandboxes that cannot
+  start, a model sign-in refused, the usage cap, the provider overloaded, a lost
+  worker — with what
+  to fix, none of it in the desks.
+
+Each issue says when it was first and last seen, how many times, which runs,
+the newest reason and what to do. A later good run does not close it: the
+issue says "fine since …" and waits for someone to resolve it, so a failure
+at 3am is still there at 9 whatever ran in between. **Acknowledge** says you
+have seen it (it stays open), **Snooze** hides it for a while (it comes back
+on its own), **Resolve** closes it, **Reopen** undoes that. Each act is kept
+in the issue's history with who did it. The same thing going wrong after a
+resolve opens the issue again, counting from there.
+
+An issue that was resolved and happens again is marked **regressed**, with
+the revision its new run ran ("regressed since abc1234"). Besides **Snooze
+1d**, **Ignore next 5** hides it until it happens five more times — for a
+known flake (`snooze` with `times` on the API, `--times` in the CLI).
+
+**Doctor** on an issue opens the [run doctor](assistant#the-run-doctor) on
+its newest run, in the workspace that run is in, wherever the card is shown
+(Home, a workspace's home, the Issues page): the assistant says why and
+proposes the fix as files to save. Nothing changes until you save it; then
+resolve the issue, or rerun and let it show "fine since". A missed schedule
+has no run, so it has no Doctor. From a terminal: `foldrun issues doctor <id>`.
+
+A **missed schedule** is an issue too: a scheduled fire in the last week that
+started no run — none began from two minutes before it to thirty after, and
+none of that flow was already going. It says when it was due ("due Mon 09:00
+(Australia/Sydney), no run started") and opens the flow. Fires from before
+the flow file last changed are not counted.
+
+A flow can choose to have its issues close themselves: `issues: auto-close`
+in its frontmatter, and a run of it that goes fine resolves its open
+failures, BLOCKED and BAD (marked "auto"); one going wrong after that opens a
+new episode. Unset (`stay-open`) a person resolves them. Platform causes and
+missed schedules never close on their own.
+
+The **Issues** page lists them (Open, Snoozed, Resolved, All; a workspace's
+own from its home), Home lists the open ones under Needs attention, and
+`foldrun issues` and `GET /api/issues` are the same list. A platform issue
+belongs to the account: closing it needs access to every workspace.
 
 Each agent also has an **Activity** page: every step it has ever run, across
 flows and direct runs, with that step's own headline. It is where "how has
@@ -156,6 +341,13 @@ tests, so "what does a test run refuse" is a file and not a search.
 **Stop** ends the run and destroys its sandbox, not just the record. A
 stopped run is recorded as stopped; it never quietly completes.
 
+**Re-run with an edit.** On a finished run, a step's **edit & re-run** opens
+its instruction: change it and re-run from that step, with the earlier steps
+carried as context. The new instruction is for that one run — the flow file is
+not changed — so you can try a fix on the real input before writing it in.
+The new run says where it came from (`rerunOf`). From the terminal:
+`foldrun rerun <run-id> --from <n> --instruction "…"`.
+
 **Stop and re-run in bulk.** `POST /api/workspaces/<ws>/runs/bulk` applies
 one of those two actions to every run a small filter names — statuses, a
 flow, a time window, or an explicit list of ids. It is the tool for the

package/docs/security.md

@@ -24,8 +24,9 @@ in, and — for an agent whose [network](network) is `open` — the public
 internet and its own account's search and browser pods; nothing else. An
 agent that is `trusted` or `none` (the default for one that does not read
 the web) reaches the internet only through the egress proxy, which holds
-its list of sites per connection; on an install that enforces it
-(`FOLDRUN_NETWORK_ENFORCE=1`) its pod has no other route, and no way to the
+its list of sites per connection; where it is enforced
+(`network_enforce: true` in the account's or workspace's `AGENTS.md`, or
+`FOLDRUN_NETWORK_ENFORCE=1` on the install) its pod has no other route, and no way to the
 account's browser or search pods. The policy denies every private range (RFC1918) and the
 cloud metadata endpoint — the address that, on a cloud host, hands out the
 machine's own credentials. It cannot reach the platform's API, its

package/docs/tools.md

@@ -99,7 +99,7 @@ runtime:
 | `args` | each argument and what it means — this is what the model reads |
 | `timeout` | seconds; without one the program runs until it finishes |
 | `interpreter` | what runs the file — `python3`, `bash`, `node` — when the extension does not say, or says wrong. `python3` (or `python`) means the tool's own environment when it has a `runtime:`, not the image's bare python |
-| `secrets` | the vault names the program reads, `[RESEND_API_KEY, EMAIL_FROM]` — granting the tool grants them, so the agent does not list them again; or `proxied` when the program sends through the egress proxy itself (reads `FOLDRUN_EGRESS`, sends `${NAME}`); the default, `materialised`, puts the real values in its environment |
+| `secrets` | the vault names the program reads, `[RESEND_API_KEY, EMAIL_FROM]` — granting the tool grants them, so the agent does not list them again; or `proxied` when the program sends through the egress proxy itself (reads `FOLDRUN_EGRESS`, sends `${NAME}`); the default, `materialised`, puts the real values in its environment. The names the step's own model call uses (`ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_BASE_URL`, `ANTHROPIC_CUSTOM_HEADERS`, the `ANTHROPIC_*_MODEL` tiers, `CLAUDE_CODE_OAUTH_TOKEN`, `FOLDRUN_MODEL_KEY`) never replace the model's own settings, and `foldrun check` warns: script and API tools and `verify:` get the declared value under that name, but the agent's own shell sees the model's — give it another name (`MY_ANTHROPIC_KEY`), or run the model on it with `provider:` |
 | `outward` | `true` when the program makes something happen outside — sends, posts, orders. On a [test run](runs#test-runs) a step granting it is handed no real secret at all, whatever their names |
 | `test_mode` | `allow` for a reader that happens to use a send-capable secret (a Business Profile reader on the same token the poster uses): on a test run the step still gets the real values. An `outward` tool in the same step wins. Parsed as `testMode` |
 | `runtime` | interpreters and packages, merged into the step's environment |
@@ -1763,6 +1763,7 @@ limits:
   web: 150            # every web action together
   crm: 20             # a tool by the name it is granted as
   calls: 300          # every tool call in the step, any tool
+  repeat: 5           # the same call — one tool, the same input — at most 5 times
 ```
 
 | key | counts |
@@ -1775,6 +1776,7 @@ limits:
 | `read` · `write` · `code` | Read/Glob/Grep · Write/Edit · Bash. An exact SDK name (`Bash`) works too |
 | `search` · `history` · `desks` · `ask` | the platform's own groups; a consulted colleague by its name |
 | `calls` | everything — including a delegation to a sub-agent |
+| `repeat` | one identical call: the same tool with the same input (key order aside). A model asking the same thing again and again is stuck, and each repeat is spend; past the cap it is told so — *this exact call 5 of 5 times in this step — repeating it will not change the answer* — and can try something else. A different input is a different call |
 
 Values are whole numbers, 1 or more; to withhold a tool, leave it out of
 `tools:`. How the count works:

package/docs/workspaces.md

@@ -144,6 +144,7 @@ The frontmatter is the workspace's defaults:
 ```yaml
 ---
 timezone: Australia/Sydney
+owner: ops@example.com         # who answers for every agent and flow here that names no owner of its own
 budget: 60                     # a cap in USD for this workspace — per month; or 60/day, 60/week; unset is no limit
 notify:
   email: ops@example.com
@@ -154,6 +155,23 @@ provider:                      # see Providers
 ---
 ```
 
+`owner:` names the person accountable for the workspace's agents and flows.
+Each agent and flow may name its own; one that does not takes the
+workspace's, and a workspace that does not takes the account's.
+
+`telemetry:` sends each finished run to an OpenTelemetry collector as one
+trace; a workspace's block replaces the account's whole. See
+[Runs](runs#sending-the-trace-to-your-own-tracing).
+
+`network_enforce: true` refuses a site off a step's [`network:`](network)
+list instead of only naming it in the trace. The account's `true` holds for
+every workspace; a workspace can add it for itself but not drop the
+account's. See [Network](network#report-only-then-refuse).
+
+`capture:` says what runs record of each tool call: `full` (the default —
+its input and output, secrets masked) or `metadata` (its name, size and time
+only). See [Runs](runs#what-a-run-records).
+
 There is an `AGENTS.md` one level up too — the account's — and the two
 compose in a way worth learning once:
 
@@ -188,6 +206,30 @@ The value is an IANA name (`Australia/Sydney`) or a plain fixed offset —
 deploy both refuse anything else; a bad value that reaches a run falls through
 to the next level with one line in the trace rather than failing the step.
 
+## Pausing runs — the kill switch
+
+When something is going wrong — an agent posting what it should not, a
+loop spending money — pause the workspace, or the whole account, from its
+Settings → Pause, `foldrun workspace pause` / `foldrun account pause`, or
+the API (`POST /api/workspaces/<ws>/pause`, `POST /api/account/pause`).
+
+While paused, nothing new starts: a schedule's fire, a webhook delivery, a
+chained flow, a person's Run and a rerun are all refused, and the
+workspace's Triggers page logs each refused fire as *paused by a
+person*. A refused fire is not run later. A run that was queued before
+the pause and has not begun waits until the resume. Add `--stop` (or tick
+*Also stop the runs going now*) to stop the runs already going — and the
+queued and parked ones — as well; without it, a run already under way
+finishes.
+
+The account's pause holds every workspace, and only the account's resume
+lifts it; a workspace paused on its own stays paused when the account
+resumes. Who paused and why is on the page, on every dashboard page while
+the account is paused, and in the audit log (`workspace.paused`,
+`account.resumed`, …). A scheduled fire inside a pause is not reported as a
+missed schedule. The pause is the platform's record, not a file, so a
+deploy never lifts it.
+
 ## The account library
 
 `<account>/library/` holds tools, skills, knowledge and memory shared by every

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foldrun",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Agents are just folders. Write them, check them, run them — on your machine.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -11,7 +11,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@foldrun/core": "^2.3.0"
+    "@foldrun/core": "^2.5.0"
   },
   "files": [
     "bin",
@@ -21,7 +21,7 @@
   ],
   "scripts": {
     "e2e": "FOLDRUN_E2E=1 FOLDRUN_DATA=$(mktemp -d /tmp/foldrun-e2e-XXXXXX) node --test --test-timeout=300000 tests/e2e.test.ts",
-    "test": "FOLDRUN_DATA=$(mktemp -d /tmp/foldrun-test-XXXXXX) node --test tests/cli-account.test.ts tests/model-credential.test.ts tests/cli-approvals.test.ts tests/cli-stop.test.ts tests/cli-account-settings.test.ts tests/cli-schedule.test.ts tests/cli-billing.test.ts tests/cli-storage.test.ts tests/cli-scaffold.test.ts tests/cli-secrets.test.ts tests/cli-site-login.test.ts tests/cli-check-library.test.ts tests/cli-check-timezone.test.ts tests/cli-check-frontmatter.test.ts tests/cli-agent-import.test.ts tests/cli-check-subagents.test.ts tests/cli-connect.test.ts tests/cli-accounts.test.ts tests/cli-remote.test.ts tests/cli-stream.test.ts tests/cli-doctor.test.ts tests/cli-tool-test.test.ts tests/cli-agent-run.test.ts tests/cli-check-remote.test.ts tests/cli-shares.test.ts tests/cli-triggers.test.ts tests/cli-providers.test.ts tests/cli-rerun-put.test.ts tests/cli-guide.test.ts tests/cli-runtimes.test.ts tests/cli-deploy-safety.test.ts tests/cli-operator.test.ts tests/cli-flow-patterns.test.ts tests/cli-flow-rm-step.test.ts tests/cli-flow-dup-step.test.ts tests/cli-flow-write-stale.test.ts tests/cli-agent-link-stale.test.ts tests/cli-parity.test.ts tests/cli-invoke-inputs.test.ts tests/cli-audit-keys.test.ts tests/cli-version.test.ts tests/cli-check-web-warnings.test.ts tests/cli-report-image.test.ts tests/cli-report-cache.test.ts tests/cli-check-workspace-paths.test.ts tests/cli-parity-dashboard.test.ts tests/cli-api-standards.test.ts tests/cli-backups-onboarding.test.ts tests/cli-check-limits.test.ts tests/cli-gallery.test.ts tests/cli-status-platform.test.ts tests/cli-webhooks-notifications.test.ts tests/cli-flags.test.ts tests/cli-api-coverage.test.ts tests/cli-hooks.test.ts tests/cli-release.test.ts tests/cli-terminal.test.ts tests/cli-network.test.ts tests/cli-assistant.test.ts tests/cli-check-scan.test.ts tests/cli-published.test.ts",
+    "test": "FOLDRUN_DATA=$(mktemp -d /tmp/foldrun-test-XXXXXX) node --test tests/cli-account.test.ts tests/model-credential.test.ts tests/cli-approvals.test.ts tests/cli-issues.test.ts tests/cli-capture.test.ts tests/cli-stop.test.ts tests/cli-account-settings.test.ts tests/cli-schedule.test.ts tests/cli-billing.test.ts tests/cli-storage.test.ts tests/cli-scaffold.test.ts tests/cli-secrets.test.ts tests/cli-site-login.test.ts tests/cli-check-library.test.ts tests/cli-check-timezone.test.ts tests/cli-check-frontmatter.test.ts tests/cli-agent-import.test.ts tests/cli-check-subagents.test.ts tests/cli-connect.test.ts tests/cli-accounts.test.ts tests/cli-remote.test.ts tests/cli-stream.test.ts tests/cli-doctor.test.ts tests/cli-tool-test.test.ts tests/cli-agent-run.test.ts tests/cli-check-remote.test.ts tests/cli-shares.test.ts tests/cli-triggers.test.ts tests/cli-providers.test.ts tests/cli-rerun-put.test.ts tests/cli-guide.test.ts tests/cli-runtimes.test.ts tests/cli-deploy-safety.test.ts tests/cli-operator.test.ts tests/cli-flow-patterns.test.ts tests/cli-flow-rm-step.test.ts tests/cli-flow-dup-step.test.ts tests/cli-flow-write-stale.test.ts tests/cli-agent-link-stale.test.ts tests/cli-parity.test.ts tests/cli-invoke-inputs.test.ts tests/cli-audit-keys.test.ts tests/cli-version.test.ts tests/cli-check-web-warnings.test.ts tests/cli-report-image.test.ts tests/cli-report-cache.test.ts tests/cli-check-workspace-paths.test.ts tests/cli-parity-dashboard.test.ts tests/cli-api-standards.test.ts tests/cli-backups-onboarding.test.ts tests/cli-check-limits.test.ts tests/cli-gallery.test.ts tests/cli-status-platform.test.ts tests/cli-webhooks-notifications.test.ts tests/cli-flags.test.ts tests/cli-api-coverage.test.ts tests/cli-hooks.test.ts tests/cli-release.test.ts tests/cli-terminal.test.ts tests/cli-network.test.ts tests/cli-assistant.test.ts tests/cli-check-scan.test.ts tests/cli-published.test.ts",
     "release": "node scripts/release.mjs",
     "typecheck": "tsc -p tsconfig.json",
     "docs:sync": "node scripts/sync-docs.mjs",