@datarails-ai/dr-cli 1.6.94 → 1.6.96

package/dist/scopes-map.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "cliVersion": "1.6.94",
+  "cliVersion": "1.6.96",
   "_contract": "Resolve a command path through `aliases` (canonical prefix + alias segment -> canonical path) before any lookup. A path listed in `pendingCommands`, or whose first segment is a key of `pending`, is UNDECIDED, not unrestricted: fail closed or skip it, and never read a path's absence from `commands` as 'no requirement'. An entry carrying `denied` is UNAVAILABLE to any AGENT-SCOPED credential — one whose `scopes` claim carries at least one `resource:action` entry; a claim that is absent, empty, capability-only or wholly unparseable is UNRESTRICTED, and this mark does not apply to it — whatever else that entry says: it is not a ceiling and it is not always-available, its `denied.reason` says why and `denied.until` names the ticket that lifts it, and the absence of `requires` on it must NEVER be read as 'no requirement'. Only an entry in `commands` with an empty `requires` means always-available.",
   "commands": {
     "login": {
@@ -1795,6 +1795,26 @@
         }
       ]
     },
+    "integrations sftp create": {
+      "requires": [
+        {
+          "resource": "integrations",
+          "action": "write"
+        },
+        {
+          "resource": "fileboxes",
+          "action": "write"
+        }
+      ]
+    },
+    "integrations sftp provision": {
+      "requires": [
+        {
+          "resource": "integrations",
+          "action": "write"
+        }
+      ]
+    },
     "connectors publish": {
       "denied": {
         "reason": "The connectors control plane runs no dr-auth-sdk guard and checks no scope, so the `integrations` ceiling this command declares would be enforced by nobody. Closed to scoped credentials until that control plane adopts the SDK.",

package/dist/skills/create-connector-lib/SKILL.md

@@ -60,7 +60,9 @@ parameter fails in `connect()` before the vendor is called.
   synthetic. Per-customer values (columns, category or custom-field names) live only in thin files.
   Before committing, grep the lib diff for the customer's name, domain and org id.
 - **Reuse before adding.** Use the SDK kit first (`from dr_integrations_sdk import kit`: logger, query
-  vars, HTTP client, CSV writer, paging, auth, dates), then `_core` helpers and an existing connection
+  vars, HTTP client, CSV writer, paging, auth, dates; on kit 1.1 also `config.is_unlimited`,
+  `http.json`, `http.same_origin`, `paging.gather_or_cancel`, `runtime.Deadline` and
+  `CsvWriter(block_bytes=)`), then `_core` helpers and an existing connection
   that fits; never a second copy. Name modules after what they do, never after who uses them. Hand the
   user a list of lib improvements you noticed (duplicated helpers, code that belongs in `_core`, a
   hand-written copy of a kit helper), done in their own PR.
@@ -81,7 +83,9 @@ parameter fails in `connect()` before the vendor is called.
   the header-once, one-block-per-page writer and takes `csv.writer` dialect kwargs
   (`lineterminator="\n"`, `quoting=`), but writes each value as `csv.writer` does (`str()`, `None` as an
   empty cell), so the engine still pre-formats every cell the way the landed file shows (`true`, not
-  `True`).
+  `True`). Kit 1.1's `CsvWriter(cell=kit.csv.cell)` is a generic formatter, not a parity one: use it
+  only when its output matches the landed file byte for byte, else pass the engine's own function as
+  `cell=`.
 - **Credentials resolve at runtime from the datasource** (`get_credentials`), never from code, tests
   or logs (`tech/security.md` §4). Check a migrated credential's shape without printing it; a stored
   header value may carry its scheme (`Basic <base64>`).

package/dist/skills/datarails-connectors-onboard-connector/SKILL.md

@@ -194,22 +194,32 @@ dataquery that defines its own `_get_logger`, `_query_vars`, `_safe_snippet`, `_
 call below before it is reviewed. A template gives you the structure; the logger, config, retry, CSV
 and paging code comes from
 `from dr_integrations_sdk import kit` (import the package, not `kit.csv`/`kit.logging` by name — they
-would shadow the stdlib). `sample_http_vendor` uses it; `sample_streaming_fanout` and `lib/sample_vendor`
-still carry hand-written `_get_logger` / `_query_vars` / retry helpers, so swap those for the kit when you
-copy them. Reference: dr-connectors-runner `docs/connector-kit.md`.
+would shadow the stdlib). Every template is built on it (`sample_http_vendor`, `sample_streaming_fanout`,
+`lib/sample_vendor`), so a copy starts with no hand-written helpers. Reference: dr-connectors-runner
+`docs/connector-kit.md`.
 
 | Need | Kit |
 |---|---|
 | a logger whose lines survive the sandbox | `kit.logging.get_logger("<vendor>__<dq>")` |
 | the merged config channels, required variables | `kit.config.query_vars(req)`, `kit.config.require(vars, *names, context=)` (raises `PermanentError` naming each missing one) |
+| *(1.1)* a cap variable that may mean "no cap" | `kit.config.is_unlimited(value)`: `None`, `""`, `0` and the string `"0"` all mean unlimited |
 | vendor text in a log line or an error | `kit.redact.safe_snippet` / `log_safe` (redacts credentials); `one_line` for ids and cursors |
 | HTTP with retry and 4xx classification | `kit.http.client(...)`, an `httpx.AsyncClient` (every httpx kwarg passes through): retries 429 (honouring `Retry-After`), 500/502/503/504 and transport errors; 401/403 raise `AuthError`, any other 4xx or an unfollowed redirect `PermanentError`; a 429/5xx still failing after the last attempt raises `httpx.HTTPStatusError` (runtime retry). `raise_for_status=False` hands 4xx back to you |
+| *(1.1)* a JSON body you must not misread as an empty page | `kit.http.json(response, expect=list)`: `PermanentError` with a redacted snippet when the body is not JSON or not that type |
+| *(1.1)* a vendor next link fetched with the credential | `kit.paging.cursor_pages(page, same_origin=base_url)` refuses a link to another scheme, host or port before fetching it; `kit.http.same_origin(url, base)` / `require_same_origin` for links you follow yourself; *(1.2)* `kit.http.client(base_url=..., same_origin_only=True)` refuses every request off that origin, redirect hops included |
 | the CSV header once, one block per page | `kit.csv.CsvWriter(fields).blocks(req, pages)`; `.rows` counts rows written |
+| *(1.1)* many small pages | `CsvWriter(fields, block_bytes=kit.csv.BLOCK_BYTES)` coalesces them into ~4 MB blocks, far under Azure's 50,000-block limit |
+| *(1.1)* typed values as CSV cells | `CsvWriter(fields, cell=kit.csv.cell)`: bool `true`/`false`, `Decimal` without exponent, tz-aware datetime as naive UTC, bytes hex, dict/list compact JSON. Not on a Workato migration: there the cell shape comes from the landed file (see *create-connector-lib*) |
 | paging that fails loudly | `kit.paging.cursor_pages` / `offset_pages`; `kit.paging.waves(items, worker, concurrency=)` |
+| *(1.1)* a handful of concurrent vendor calls | `kit.paging.gather_or_cancel(awaitables)`: cancels the siblings on the first failure and re-raises it unwrapped. Never `asyncio.TaskGroup`: its `ExceptionGroup` turns a `PermanentError` into 5 retries |
+| *(1.1)* the hook's time budget | `deadline = kit.runtime.Deadline("<vendor> <dq>")` in `fetch`: *(1.2)* it counts from the runner's own start of the hook and stops 60 s short of the timeout the runner kills at, watching CPU time too. `deadline.check(progress)` per page, `await deadline.sleep(s, progress)` for poll waits, and `kit.http.client(deadline=deadline)` for retry waits. Each raises `PermanentError` naming the progress |
 | credentials and tokens | `kit.auth.credential(creds, *keys, vendor=)`, `client_credentials` / `password_grant` → `Token.header()`, `basic_header`, `bearer_header` |
 | a date window | `kit.dates.date_window(vars, start_keys=, end_keys=, required=)`, `DateWindow.chunks(days)`, `parse_date` |
 
-**The kit is live in every production ring**, so it is never a reason to fall back to copied helpers.
+**Kit 1.2 is live in every production ring** (runner image `connectors-runner-base` v1.35.0, since
+2026-10-02), so every row above is usable there and the kit is never a reason to fall back to copied
+helpers. The *(1.1)* / *(1.2)* marks say which kit version a row needs, for an environment whose runner
+image is older.
 At runtime the kit comes from the **runner image**, not from `.sdk-ref` (that pins only what CI tests
 against). An image with the kit prints
 `INFO:dr.sdk: hook=… correlation_id=… kit=<version>` as each hook's first log line. On a dev or test
@@ -309,9 +319,10 @@ Two more sandbox ceilings worth knowing, both undocumented elsewhere:
   ThreadPoolExecutor **never reaps its threads** — so an unbounded pool can claim ~256 MB of the
   512 MB and never give it back. That is why a brief concurrency spike used to poison every *later*
   phase of a run with `RuntimeError: can't start new thread` and SSL allocation failures long after
-  the spike finished. Cap it once at the top of the fetch:
-  `asyncio.get_running_loop().set_default_executor(ThreadPoolExecutor(max_workers=4))`.
-- **`RLIMIT_CPU = 60s`** sits right next to the memory limit in `sandbox_entry.py`. Exceeding it
+  the spike finished. **The runner now caps it at 8 threads** before every hook
+  (`sandbox_entry.py` `SANDBOX_EXECUTOR_THREADS`, DR-53651), so a connector no longer installs its own
+  `set_default_executor(...)`; remove one when you touch the file.
+- **`RLIMIT_CPU = 2700s`** sits right next to the memory limit in `sandbox_entry.py`. Exceeding it
   SIGKILLs the hook (runner reports `sandbox exited -24`) with no `MemoryError` to explain it. Async
   I/O waiting is free, but TLS handshakes, gzip and JSON parsing are not — log
   `time.process_time()` alongside wall clock so you can see how close you are.
@@ -871,8 +882,8 @@ unmerged connector has no version to ingest, bind, or run.
 | Confused about publish vs ingest | CI publishes to JFrog on merge (cuts the git tag `vN`); the CLI ingests a published version into a DC | `dr connectors publish <path/to/dataqueries/<dq>.py> --server DEV --account <customer-user-email> --json` reads the newest git tag (`git fetch --tags` + max `vN`, or `--tag vN`) — **no local compose** — then the control-plane **pulls that tag from JFrog** (no upload) and registers it (needs `NODE_EXTRA_CA_CERTS`); returns `{name, version: "vN", digest}`. |
 | Run `Failed`, `connect` completion `verdict: ok` but `fetch` completion `verdict: retry`, error `'async for' requires an object with __aiter__ method, got function` | Passed the async-generator **function** to `write_output` — `write_output(req, gen)` instead of **calling** it `write_output(req, gen())`. `write_output` does `async for chunk in <arg>`, which needs an async **iterator**, not a function. (The connect gate passing but fetch dying instantly is the tell.) | Call the generator: `write_output(req, gen())`. The golden template already shows `write_output(req, rows())` / `write_output(req, blocks())` — match it exactly; the missing `()` is easy to drop. |
 | Vendor **4xx** (e.g. `402 Payment Required`, `401`, `403`, bad-symbol `404`) makes the `fetch` completion `verdict: retry` and the run **retries forever**; the HTTP status shows ONLY in the completion store, never in the Inngest run `output` (which is `null`). | A bare `r.raise_for_status()` raises `httpx.HTTPStatusError` for **every** status ≥ 400, and the runtime classifies that as **transient → retry**. But a plan/auth/bad-request 4xx will never succeed on retry. | Use `kit.http.client` (skill §1): 401/403 raise `AuthError` and any other 4xx `PermanentError`, each naming the status and a redacted body; 429 and 5xx are retried, then left to the runtime's retry (genuinely transient). Concrete case: FMP's free tier answers **402** when `limit` exceeds its historical allowance (dev key caps statements at the last **5** annual records) — a small `limit` or a paid key fixes that one; the PermanentError stops the infinite loop for the general case. The golden `sample_http_vendor` template is built on this client. |
-| Connector works perfectly in local/dev testing, then in production `fetch` dies with `MemoryError`, `MemoryError: Unable to allocate output buffer`, an SSL/crypto allocation failure, or `RuntimeError: can't start new thread` — often within a second of "fetch start", and deterministically on every one of the 5 attempts | The sandbox caps **virtual address space at `RLIMIT_AS` = 512 MB** (`dr-connectors-runner/src/runner/sandbox_entry.py`), and the runner pod's limit is also 512Mi. The guard is `if sys.platform != "win32"`, so **the ceiling does not exist on a Windows dev box** — a buffering connector cannot fail locally. Two causes, usually together: (a) the fetch accumulates the result set (a `rows` list, `asyncio.gather` over every parent, a full CSV string + its `.encode()` copy) — journal_lines measured **378 MB live to emit 67 MB**, 243 MB of it row dicts at 846 B/row; (b) asyncio's **default** DNS ThreadPoolExecutor grew to `min(32, node_cores + 4)` threads × 8 MB stack ≈ **256 MB of address space that is never reclaimed**, which is why a brief concurrency spike poisons every later phase of the run. | Stream: do the fetching **inside** the generator passed to `write_output`, replace gather-over-everything with a bounded worker pool feeding a bounded `asyncio.Queue`, format rows to CSV bytes immediately (never hold dicts), and re-batch to ~4 MB blocks. Cap the executor once: `asyncio.get_running_loop().set_default_executor(ThreadPoolExecutor(max_workers=4))`. Full rules in §1 *Memory*; working template `samples/sample_streaming_fanout/`. Reproduce locally in `python:3.12-slim` under the same rlimits — never trust a Windows run for this. |
-| Hook dies with no traceback and no `MemoryError`; runner reports `sandbox exited -24` | **`RLIMIT_CPU = 60s`** (`sandbox_entry.py`, right beside the memory limit) — 60 seconds of **CPU** time, then SIGXCPU/SIGKILL. Async I/O waiting is free, but TLS handshakes, gzip and JSON parsing across thousands of requests are not. | Cut CPU per row (fewer/larger vendor pages, `onlyData` where the vendor supports it, no per-row dict churn) and log `time.process_time()` next to wall clock so proximity to the cap is visible before it kills a run. |
+| Connector works perfectly in local/dev testing, then in production `fetch` dies with `MemoryError`, `MemoryError: Unable to allocate output buffer`, an SSL/crypto allocation failure, or `RuntimeError: can't start new thread` — often within a second of "fetch start", and deterministically on every one of the 5 attempts | The sandbox caps **virtual address space at `RLIMIT_AS` = 512 MB** (`dr-connectors-runner/src/runner/sandbox_entry.py`), and the runner pod's limit is also 512Mi. The guard is `if sys.platform != "win32"`, so **the ceiling does not exist on a Windows dev box** — a buffering connector cannot fail locally. Two causes, usually together: (a) the fetch accumulates the result set (a `rows` list, `asyncio.gather` over every parent, a full CSV string + its `.encode()` copy) — journal_lines measured **378 MB live to emit 67 MB**, 243 MB of it row dicts at 846 B/row; (b) asyncio's **default** DNS ThreadPoolExecutor grew to `min(32, node_cores + 4)` threads × 8 MB stack ≈ **256 MB of address space that is never reclaimed**, which is why a brief concurrency spike poisons every later phase of the run. | Stream: do the fetching **inside** the generator passed to `write_output`, replace gather-over-everything with a bounded worker pool feeding a bounded `asyncio.Queue`, format rows to CSV bytes immediately (never hold dicts), and re-batch to ~4 MB blocks (`kit.csv.CsvWriter(..., block_bytes=kit.csv.BLOCK_BYTES)` on kit 1.1). The executor cap (b) is now set by the runner (8 threads); a connector installs none. Full rules in §1 *Memory*; working template `samples/sample_streaming_fanout/`. Reproduce locally in `python:3.12-slim` under the same rlimits — never trust a Windows run for this. |
+| Hook dies with no traceback and no `MemoryError`; runner reports `sandbox exited -24` | **`RLIMIT_CPU = 2700s`** (`sandbox_entry.py`, right beside the memory limit) — 2700 seconds of **CPU** time, summed over all threads, then SIGXCPU/SIGKILL. Async I/O waiting is free, but TLS handshakes, gzip and JSON parsing across thousands of requests are not. | Cut CPU per row (fewer/larger vendor pages, `onlyData` where the vendor supports it, no per-row dict churn) and log `time.process_time()` next to wall clock so proximity to the cap is visible before it kills a run. |
 | A sync `Completed` and the file **looks** complete, but the customer's totals are short | A page-limit "safety cap" (`_LINE_PAGE_LIMIT`, `_HEADER_PAGE_LIMIT`, …) tripped and the code **logged a warning and returned what it had**, so a partial result landed as if whole. Same failure class as a missing offset follow-up: journal_lines silently dropped **113,171 rows** of one customer's month this way. | Caps must `raise PermanentError`, never warn-and-return — a failed sync is recoverable, a silently partial landing gets reconciled against and believed. Audit every `log.warning` that is followed by `return`. |
 
 ## Env quick reference (dev germany)

package/dist/skills/dr-cli/SKILL.md

@@ -299,6 +299,7 @@ area's gotchas.
     reconnect before the next sync._
 - `integrations share users|groups`
 - `integrations it list|get|add|update|delete|resync` (IT-admin file-sync; redacts secrets by default)
+- `integrations sftp create|provision` — self-serve SFTP fileboxes: `create --name <n>` makes a filebox and its SFTP folder `/<name>_<id>` in one step; `provision <filebox_id>` does it for an existing filebox
 - `entities list|qbd-availability|netsuite-connections|rename|rename-group|delete|mark-completed` (alias `companies`)
 - `entities create qbo|xero|qbd|netsuite` (connected accounting systems)
 - `error-enrichments list|stats|get|create|update|delete|test-regex|export|import` — the
@@ -611,7 +612,10 @@ network traffic or hand-edits JSON. Full recipes in the relevant reference file.
   date to whatever granularity the filebox's own DATE tag actually uses —
   no need to know if it's yearly/quarterly/monthly/daily/weekly. `--tag` is
   an unvalidated escape hatch that forwards straight to the server; a
-  malformed value 500s with no error body. See reference/filebox-documents.md.
+  malformed value 500s with no error body. To know when it finished, add
+  `--wait` — never poll `status` or the version count: an unchanged result
+  writes no new version and still reads `SYNCED`. See
+  reference/filebox-documents.md.
 - **"User has no table permissions" is almost always a misread.** To see which
   tables a user can access, use `dr users permissions get <id>` — never the raw
   `GET /api/it/users/<id>` object's `permissions` field. That field is Django

package/dist/skills/dr-cli/reference/filebox-documents.md

@@ -169,8 +169,12 @@ set-version-include` (below).
   only allow-listed keys are accepted (currently `is_bank_integration`); unknown
   keys are rejected client-side (the server silently accepts dead keys).
 - `filebox data-query get|set|clear|sync <fb_id>` — read/write/delete/poke the
-  Workato data-query. `get` shows `sync_interval` (cron) + `last_sync`; `set
-  --payload-file` PUTs a create/update body; `clear` is two-step.
+  Workato data-query. `get` shows `sync_interval` (cron), `last_sync` and
+  `Last start` (when the latest sync started); `set --payload-file` PUTs a
+  create/update body; `clear` is two-step. `last_sync` doubles as the
+  auto-sync debounce, so it can read minutes in the future. Older servers do
+  not return either timestamp: `last_sync` then reads `never` and `Last start`
+  is omitted.
 - `filebox data-query sync <fb_id> [--date YYYY-MM-DD]` — trigger an async
   sync, optionally scoped to specific period(s). `--date` is repeatable and
   takes one plain calendar date — the CLI reads the filebox's own DATE
@@ -195,6 +199,32 @@ set-version-include` (below).
   constant — varies per tenant) and the epoch just needs to fall within the
   target period (the server normalizes it). Prefer `--date`; reach for raw
   `--tag` only when it doesn't cover your case.
+- **Waiting for a sync: `filebox data-query sync <fb_id> --date … --wait`.**
+  Never poll `status` or the version count yourself — both lie:
+  - With `sync_only_changes` (the default), a sync whose output is identical
+    to the stored latest version for that period writes **no new version**.
+    `status` still goes to `SYNCED`, and the version count never moves. This
+    is not an error.
+  - Right after a sync is queued, `status` can still show the previous run's
+    value (or `-`) until the sync starts. A loop that waits for "not
+    SYNCING" exits at once.
+  - A multi-period sync flips `status` to `SYNCED` after each period, so
+    "status is SYNCED" can mean one period of several.
+  - A premature exit followed by `filebox download` silently returns the
+    **previous** version.
+
+  `--wait` snapshots each `--date` period's versions before triggering, then
+  polls until every period either gained a new version (**new version**) or
+  had its latest version re-confirmed — the server bumps that version's
+  `last_sync` instead of writing one (**unchanged**). It exits non-zero when
+  the data-query goes to `ERROR` (with the server's `last_sync_error`) or on
+  `--timeout <seconds>` (default 1800). `--json` prints one object:
+  `{outcome, periods: [{period, result: new_version|no_change|pending,
+  version_id, version}], unmatched_new_versions, error, waited_seconds}`.
+  Without `--date`, it waits for the first period to finish. It cannot be
+  combined with `--tag`. One blind spot: a sync that returns **no rows**
+  writes no version and re-confirms none, so it ends in a timeout whose
+  message says so — check `dr filebox data-query get <fb_id>`.
 - `filebox data-query set-sync-interval <fb_id> --cron "<expr>"` — change how
   often the data-query polls (Workato-backed **and** connector-platform /
   `DatarailsConnector` fileboxes both use this cron). **Use this for sync

package/dist/skills/dr-cli/reference/integrations.md

@@ -34,6 +34,40 @@ secrets by default.
   `--set-config KEY=VAL`), `integrations it delete` (two-step confirm),
   `integrations it resync`.
 
+## Self-serve SFTP (`integrations sftp`)
+
+The embedded SFTP integration: each filebox gets its own folder in the org's SFTP
+container, and files dropped there land in the filebox.
+
+- `integrations sftp create --name <n> [flags]` creates an SFTP filebox in one step
+  (`--scenario`, `--date-sub-type`, `--parent`, `--no-date` as on `filebox create`).
+  `integrations sftp provision <filebox_id> [flags]` sets up SFTP on a filebox that
+  already exists. Both make the UI wizard's call,
+  `POST /api/v3/data_integrations/fileboxes/<id>/sftp/provision`, which creates the
+  folder `/<filebox name>_<filebox id>` (with a `.keep` file) and, for the org's
+  first SFTP filebox, the org's SFTP user and password.
+- The org is the logged-in account's org (`--server`, `--account`; `dr login-as` to
+  act as a customer). There is no org flag.
+- Give the client the printed **Folder** unchanged. An SFTP login opens inside the
+  org's container, so the container name is never part of the path. **Host** is the
+  bare hostname.
+- `--date-method filename|upload_date`. A date-tagged filebox defaults to
+  `upload_date`. `filename` also needs `--date-format` (one of the 10 formats the UI
+  offers) and `--date-position beginning|end`. `--backfill <n>` adds subfolders
+  `<folder>/-1` … `<folder>/-N` (`upload_date` only). A `--no-date` filebox takes none
+  of these flags.
+- Safe to re-run: no folder is duplicated, and flags left out keep their stored values.
+- The password is redacted unless `--show-secrets`, in `--json` output too. It is the
+  org's password: one SFTP user serves every SFTP filebox in the org, so revealing it
+  gives access to all of their folders.
+- Errors: 404 "not enabled" means the org's `integrations__sftp` flag is off. 403
+  means the account does not own the filebox, or is a viewer. 400 "already connected" means the
+  filebox is linked to another data source. 502 means the gateway is unavailable;
+  re-run. When `integrations sftp create` fails at the SFTP step, the filebox
+  already exists, so finish with `integrations sftp provision <id>`.
+- Do not copy SFTP settings from another filebox with `filebox data-query set`. That
+  links the filebox but creates no folder, so the client has nowhere to drop files.
+
 ## Entities — company data sources (`entities`, alias `companies`)
 
 The connected accounting systems (QuickBooks Online/Desktop, Xero, NetSuite) —

package/dist/skills/dr-cli/reference/reconciliation-mec.md

@@ -22,7 +22,14 @@ Account assignment / sign-off (all take the bank-account UUID via
 
 - `reconciliation accounts update-settings --file <p>` — admin-only PATCH.
   Two-step confirm; the token binds to a hash of the file's rows, so editing
-  the file between plan and confirm invalidates it.
+  the file between plan and confirm invalidates it. Rows are matched to the
+  tenant by `(entity, account_group, name)`; only rows that differ are sent,
+  in PATCHes of at most 256 KB (one whole-tenant PATCH near 1 MB returns
+  HTTP 500). The plan reports rows to change, rows skipped as already
+  matching, and the changes by target frequency (`Exclude` is how an account
+  is excluded from reconciliation). If a PATCH fails, the error says how many
+  rows landed; re-run the same file without a token and the new plan covers
+  only the rest.
 - `reconciliation accounts set-assignee <account_uuid> --date <YYYY-MM-DD>
   --type Preparer|Reviewer --user-id <n> [--user-name <s> --user-email <s>]` —
   resets any prior sign-off; name/email are auto-fetched if not supplied.
@@ -38,7 +45,12 @@ Account assignment / sign-off (all take the bank-account UUID via
   resets. Every account is checked before anything is written, and the
   write goes out in PATCHes of 100 accounts. If one fails, the error says
   how many accounts landed; re-run the same file without a token and the
-  new plan covers only the rest. Do not script a loop of single
+  new plan covers only the rest. Before each PATCH after the first, the
+  accounts are re-read; if any account in the next chunk is gone (a
+  trial-balance rebuild re-mints account ids) or its member slots changed
+  since the plan, the run halts, says how many accounts landed, and names
+  the drifted accounts. Gone accounts mean the file must be rebuilt from
+  `accounts list` once the rebuild settles. Do not script a loop of single
   `set-assignee` calls for this.
 - `reconciliation accounts clear-assignee <account_uuid> --date <YYYY-MM-DD>
   --type Preparer|Reviewer` — unassigns (preserves due_date, resets sign-off).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datarails-ai/dr-cli",
-  "version": "1.6.94",
+  "version": "1.6.96",
   "description": "Datarails CLI",
   "type": "module",
   "engines": {
@@ -17,7 +17,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@datarails-ai/dr-appspace-cli": "0.10.19",
+    "@datarails-ai/dr-appspace-cli": "0.10.20",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@napi-rs/keyring": "^1.3.0",
     "commander": "^12.1.0",