Add engraphis connect --token so a purchased client can actually connect

[Coding-Dev-Tools]

The problem

engraphis/cloud_session.py::save_bootstrap() is the only function that writes
~/.engraphis/cloud_session.json, and it had zero production callers — only tests
reached it. Meanwhile docs/AGENT_CONNECT.md and .env.example told customers to prefer
that file. Nothing created it, so a paying customer had no supported way to connect a
client and every paid feature was undeliverable.

The server half already exists (engraphis-cloud #25: POST /v1/devices/connect). This is
the client half.

CLI surface

engraphis connect --token engr_ct_...

Option	Effect
--token TOKEN	Required. - reads one line from stdin, keeping the token out of shell history.
--control-url URL	Control plane (default: shipped manifest, or ENGRAPHIS_CLOUD_CONTROL_URL).
--compute-url URL	Managed compute endpoint (default: ENGRAPHIS_CLOUD_COMPUTE_URL, or the shipped endpoint).
--workspace WORKSPACE_ID	Bind the device to one workspace.
--label TEXT	installation_label shown in the account portal.
--device-name TEXT	device_name (default: hostname).
--timeout SECONDS	Network timeout (default 15).
--json	Redacted machine-readable summary.

Exit 0 on success, 1 on a handled failure, 2 on argparse misuse.

New entry points in [project.scripts]:

• engraphis = "scripts.entry:main" — the front door, so the string the account portal
  displays is runnable as shown. It is a dispatcher, not a second CLI: it rewrites sys.argv
  and calls the same main() each existing engraphis-<verb> script calls, lazily, so
  engraphis connect never imports the memory/embedding stack.
• engraphis-connect = "scripts.connect:main" — matches the existing engraphis-* naming.

Implementation

• engraphis/device_connect.py — token validation, client identity, the POST,
  status-keyed error copy, and the call into save_bootstrap. The 200 body is fed to
  save_bootstrap verbatim.
• scripts/connect.py — argparse CLI following scripts/init.py conventions
  (main(argv=None) -> int, non-interactive, no prompts). No new CLI framework.
• scripts/entry.py — the verb dispatcher.
• engraphis/cloud_session.py — preflight_save() so storage faults are found before
  the token is spent, plus the IncompleteRead fix in _post_refresh described below.

Credential handling

The connect token travels in the request body and nowhere else — never printed, never
logged, never persisted, and never quoted back in an error message (a rejected token is
still a secret). Malformed, truncated, or wrong-prefix tokens are rejected before any
network call, so a bad paste costs no rate budget and consumes no token.

Transport

build_pinned_https_opener with a redirect-blocking handler and an explicit timeout,
exactly as cloud_session.py and update_check.py do — no bare build_opener, no
requests. HTTPError bodies are drained and closed inside the handler (a sibling
except would not cover a raise from the handler itself). Provider bodies are untrusted
and never reflected into messages.

--timeout is bounded, not merely checked for finiteness. socket.settimeout() converts
its argument into an absolute deadline, so a large but finite value raises OverflowError
from inside urllib — verified on Windows, where 1e9 already fails with "timeout doesn't
fit into C timeval" and 1e10 with "timestamp out of range for platform time_t". A
math.isfinite() check alone therefore still let --timeout 10000000000 print a traceback.
The ceiling is 3600s: far more than one interactive POST can need, far below the first
value any supported platform rejects.

Error mapping

Status	Message
401	"expired, was already used, or is not valid — generate a new one in your account portal". The service makes all three indistinguishable on purpose, and the fix is identical, so the copy names all three rather than guessing.
402	"subscription is not active … update billing at <upgrade_url>" — kept distinct from 401, because a lapsed subscription reported as a bad token sends the customer to the wrong page forever.
403 / 404 / 422 / 429 / 503	Each gets its own actionable line.
network / timeout	"temporarily unreachable", with the underlying detail (which may quote an internal proxy) suppressed.

Nothing is written unless the exchange succeeded.

Failures after the control plane has answered are copy-critical, because a 2xx consumes
the single-use token as it is written. urllib raises HTTPError for every status ≥ 400 and
_NoRedirect turns a 3xx into one, so any fault past opener.open() follows a success
status. Every such path therefore says the token is gone and sends the customer to the portal
rather than advising a retry that would deterministically 401 — sharing one
_SPENT_TOKEN_SUFFIX so the copy cannot drift apart:

• a reply truncated mid-body;
• an oversized, unparseable, or non-object 2xx body;
• a parsed 2xx carrying no refresh_credential;
• an endpoint that stops resolving before the write;
• a state directory that changes under the exchange;
• a refresh lock that vanishes or turns unsafe between the pre-flight and save_bootstrap
  (wrapped in CloudSessionError, so it never reached the OSError clause that carried the
  warning).

The CLI verifies cloud_session.configured() before emitting any success output. That
call reads the session back and can raise, so while it ran last a complete --json success
object reached stdout and the command then exited 1 — a consumer parsing stdout accepted a
failed connect. On failure stdout is now empty and only stderr carries the message.

http.client.IncompleteRead is not an OSError

Worth stating explicitly, because two comments in this PR previously asserted the opposite
and one guard was written on that false premise:

http.client.IncompleteRead.__mro__
  == (IncompleteRead, HTTPException, Exception, BaseException, object)

It is only an HTTPException. Two consequences, both now fixed and both regression-tested:

• The HTTPError error-body drain was guarded with except (OSError, ValueError), which
  could never catch it. Because the drain runs inside an except block, the sibling
  except http.client.HTTPException clause of the same try was unreachable for it too, so
  a truncated chunked error body replaced the status copy with a raw traceback.
• engraphis/cloud_session.py::_post_refresh carried the same guard and had no
  HTTPException clause at all — it did not import http.client. That is the token-refresh
  path every paid feature runs through, so a truncated refresh reply crashed far from its
  cause. Fixed here since this PR already modifies that file.

A test now pins the real MRO so the false claim cannot come back.

OSError means opposite things either side of opener.open()

IncompleteRead was the symptom; this was the cause. Both call sites opened the connection
and read the body inside one try, so a TimeoutError or ConnectionResetError raised
mid-body — after urllib had already parsed a success status line — was reported with the
connection-phase copy. Both now split the two phases:

• post_connect: a body-read failure means the token is spent, so it reports that
  instead of "try again". A reset before any reply still gets the retry copy, since
  RemoteDisconnected genuinely means nothing was consumed — pinned by its own test so the
  split cannot over-correct.
• _post_refresh: sharper consequences. The rotated credential reaches disk only after
  the body parses, so a post-response failure leaves the spent credential stored.
  _public_session_error maps 503 to transient=True, CloudFeatureClient.run_job acts on
  that by resubmitting, and this module already documents that the control plane answers a
  replayed credential by revoking the whole credential family. Every post-response branch
  (truncated, oversized, unparseable, non-object, incomplete credentials) now returns 409,
  the existing non-transient "connect this installation again" bucket, and a test asserts the
  status still maps to transient is False — that mapping, not the number, is what prevents
  the retry. This deliberately prefers a false "reconnect" over a replay: the opposite
  mistake revokes the whole family and forces the same reconnect from a worse state.

A coercion is not a validation

str(response.get(key) or "").strip() reads like it normalises a field, but JSON arrays and
objects arrive as Python list/dict and str() renders their repr:

str(["tok_abc"] or "").strip()   # -> "['tok_abc']"  — truthy, non-empty

So {"refresh_credential": ["tok_abc"]} passed the missing-credential check, was persisted
as the literal text ['tok_abc'], read back by configured() as a usable session, and
reported as a successful connection — while the next refresh submitted the junk, after the
single-use token was already spent. cloud_session.text_field() now requires a genuine
string at every untrusted-provider boundary (save_bootstrap, the rotation handling in
access_for_workspace, and connect's pre-save check, which uses the writer's own helper so
the two cannot disagree). Identity fields are dropped rather than stored as a repr, since the
dashboard renders them verbatim.

preflight_save also stopped swallowing a failed os.unlink of its probe. Creating a file
and removing one are separate rights, and atomic_private_text finishes with os.replace,
which needs the delete right that would have failed — so on an add-file-but-no-delete ACL the
preflight passed on a directory the real save could not use, redeeming the token before
failing. That is the exact drift the preflight exists to prevent.

Client identity

installation_client_id / device_client_id are minted once and persisted at
~/.engraphis/client_identity.json (owner-only, honours ENGRAPHIS_STATE_DIR), using the
package's own ULID minter — inst_01K… / dev_01K….

They are random rather than a hardware fingerprint on purpose: a MAC- or hostname-derived
id is a stable cross-account identifier the customer never agreed to ship, and it changes
under exactly the conditions (a new NIC, a rename) where stability was the point. Minted
once in the state directory gives the server what it needs — stable per installation — and
a second state directory is correctly a second installation.

Compute URL

DeviceRegistrationResponse carries no compute endpoint, but cloud_session.configured()
requires one, so connect would otherwise leave a customer "connected" but not configured.
Resolution is --compute-url → ENGRAPHIS_CLOUD_COMPUTE_URL → the shipped compute
endpoint only when the control plane is also the shipped one. A custom or self-hosted
control URL gets no guess; the command then says exactly that instead of half-reporting
success. configured() is checked after the write either way.

Docs

docs/AGENT_CONNECT.md and .env.example no longer point at a file nothing creates —
both now document engraphis connect --token as the real path, with the option table,
the single-use/short-lived token semantics, and the 401 vs 402 distinction.

Verification

Offline gate on Windows, junit XML parsed from outside the repo. Both rows measured in this
environment, rebased onto the same origin/main (73aa244):

	collected	passed	failures	errors	skipped
origin/main	1411	1397	0	0	14
this branch	1513	1499	0	0	14

+102 tests, all passing, zero regressions. python -m ruff check . → all checks passed.
eval.harness on sample.jsonl and codemem.jsonl → recall@5 / hit@5 / answer-token-recall
all 1.000; eval.ablation unchanged (vector 0.6667, 1-hop 0.0, PPR 1.0). The absolute
collected count differs from CI's Linux number, so the delta is the meaningful figure.

New tests cover: happy path writes a session where cloud_session.configured() is true and
every field lands correctly; the exact documented request shape (no organization_id, no
extra fields, optional fields omitted rather than sent empty); stable ids across reconnects;
401 printing actionable copy and writing nothing; 402 staying distinguishable; per-status
copy for 403/422/429/503/500; error bodies never reflected; HTTPError drained and closed;
the token absent from stdout, stderr, and every written file while present in the request
body; secrets absent from both the report and the --json summary; and eight malformed-token
shapes rejected before the network via a poison opener that fails the test if dialled.

Post-review additions, each written as a failing test before the corresponding fix:
IncompleteRead's real MRO; a truncated error body still producing the status copy (on both
read and close, for IncompleteRead / LineTooLong / ConnectionResetError); the same
for _post_refresh; oversized timeouts refused before the network by a poison opener, with
the ceiling asserted against a real socket.settimeout() so it cannot drift into the
overflowing range; a credential-less 200 across all three shapes (key absent, empty,
whitespace); and two CLI tests asserting exit 1 with no Traceback in stderr. Second round:
every unusable-2xx shape (unparseable / JSON string / JSON array / oversized) carrying the
spent-token copy; a refresh-lock race keeping both its cause and that copy; and an unusable
session producing empty stdout in both --json and report mode, which rules out a partial
success object as well as a complete one. Third round: body-read failures after success
headers (TimeoutError / ConnectionResetError / OSError) reporting the spent-token copy
while a pre-reply reset keeps the retry copy; post-response refresh failures returning 409
and mapping to transient is False; and a preflight probe that cannot be deleted failing
before the token reaches the wire (opener.calls == []).

Additionally smoke-tested end to end outside pytest, twice:

• The real CLI against a real loopback HTTP server through the real urllib path —
  POST /v1/devices/connect, UA: Engraphis/1.0.1 device-connect, token present in the body
  and in no file or stream, and cloud_session.configured() → True.
• The IncompleteRead path against a real socket rather than a mock: a loopback server
  sending Transfer-Encoding: chunked, a chunk header promising 32 bytes, 17 bytes of body,
  then a clean FIN. Real HTTPResponse.read() raises a real IncompleteRead
  (isinstance OSError: False, isinstance ValueError: False), and connect() returns
  DeviceConnectError(status=401) with the portal copy and no traceback.

🤖 Generated with Claude Code

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 78027222d2

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Greptile Summary

This PR delivers the missing client half of the device-connect flow: engraphis connect --token engr_ct_… exchanges a one-time portal token for the session file that ~/.engraphis/cloud_session.json docs and .env.example have always pointed at but nothing ever created. It also adds an engraphis front-door dispatcher so the portal's copy-paste command is actually runnable.

• engraphis/device_connect.py — token validation (local, before any network call), stable ULID-based client identity, a redirect-blocking pinned HTTPS opener, per-status actionable error copy, and a pre-flight storage check that preserves the single-use token when the state directory is broken.
• engraphis/cloud_session.py — adds preflight_save() (tempfile probe + private_file_stat checks) and extracts _refresh_lock_path() so the lock path is now computed consistently.
• scripts/connect.py / scripts/entry.py — CLI surface following existing scripts/init.py conventions; entry.py rewrites sys.argv and delegates to each verb's existing main(), keeping the memory/embedding stack un-imported for engraphis connect.

Confidence Score: 4/5

Safe to merge with one open write-path exception that can surface a raw traceback after the single-use token is spent.

The previously-flagged CloudUrlUnresolved (ValueError subclass) escape from save_bootstrap remains open: a transient DNS failure after the token is spent surfaces as a raw traceback, leaving the customer with a consumed token and no actionable message. Everything else is carefully engineered with strong test coverage.

Files Needing Attention: engraphis/device_connect.py — the connect() function's exception handling around the save_bootstrap call.

Important Files Changed

Filename	Overview
engraphis/device_connect.py	Core connect logic: token validation, identity management, HTTP transport, and session bootstrap — well-structured with careful credential hygiene; one uncaught ValueError path from save_bootstrap (previously flagged) is the only meaningful gap.
scripts/connect.py	CLI entry point following the existing init.py conventions: argparse, main(argv=None)->int, no prompts, correct --token - stdin handling, and separate JSON/human output paths.
scripts/entry.py	Verb dispatcher: rewrites sys.argv then calls each command's main(); correctly restored in finally. The _USAGE string claims 'Every command is also installed as engraphis-' — true only if those entries already exist in pyproject.toml from earlier PRs.
engraphis/cloud_session.py	Added preflight_save() and _refresh_lock_path() refactor: logic is sound, preflight probe uses tempfile+unlink so no session is partially created, and the lock path is now computed consistently.
tests/test_device_connect.py	Comprehensive test suite: 43 new tests covering happy path, per-status error copy, token hygiene (no leakage to stdout/stderr/disk), pre-flight blocking, stable identity, and the dispatcher — well-isolated with an autouse fixture.
pyproject.toml	Adds engraphis and engraphis-connect script entry points; minimal and correct change.

Sequence Diagram

sequenceDiagram
    participant U as User
    participant CLI as scripts/connect.py
    participant DC as device_connect.connect()
    participant CS as cloud_session
    participant CP as Control Plane

    U->>CLI: engraphis connect --token engr_ct_...
    CLI->>DC: connect(token, control_url, compute_url, ...)
    DC->>DC: _validated_timeout()
    DC->>DC: normalize_connect_token()
    DC->>DC: _validated_control_url()
    DC->>DC: validate_cloud_base_url(compute_url)
    DC->>DC: client_identity() - write client_identity.json
    DC->>CS: preflight_save() - mkstemp probe
    CS-->>DC: session_path (write confirmed)
    DC->>CP: POST /v1/devices/connect
    CP-->>DC: 200 DeviceRegistrationResponse
    DC->>DC: check refresh_credential present
    DC->>CS: save_bootstrap(response, control_url, compute_url)
    CS-->>DC: cloud_session.json written 0600
    DC->>DC: summarize(response) - secrets excluded
    DC-->>CLI: summary dict
    CLI->>CS: configured() - verify session usable
    CLI-->>U: Connected. Next steps: engraphis-dashboard

Loading

_{Reviews (3): Last reviewed commit: "Address connect review: manifest compute..." | Re-trigger Greptile}

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: aae7d939b6

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9d77f4f728

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 6084dfd0b9

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[Coding-Dev-Tools]

Review — Add engraphis connect --token so a purchased client can actually connect

✅ LGTM — closes a critical gap: save_bootstrap() had zero production callers, making every paid feature undeliverable.

Credential handling is correct: token in request body only, never printed/logged/persisted/quoted in errors. Malformed tokens rejected before any network call. The pinned HTTPS opener with redirect blocking and explicit timeout matches the existing pattern.

Pre-flight storage check (commit aae7d93) is a strong addition — spending the single-use token and then failing the write would strand the customer. The UnsafeStateFile translation into DeviceConnectError with the path to fix is actionable. The six tests asserting opener.calls == [] prove the POST is never issued on pre-flight failure.

Client identity as random ULIDs in the owner-only state directory is the right call over hardware fingerprints — avoids cross-account tracking and handles NIC changes correctly.

Compute URL resolution (manifest key → env → shipped default only when control is shipped) avoids silently half-connecting customers on custom deployments.

The follow-up commits addressing review findings (manifest compute endpoint, nan/inf timeout validation, OSError translation from save_bootstrap, IncompleteRead and CloudUrlUnresolved handling) are each correct and well-scoped.

CI: 1452 passed, 0 failed (+43 new tests). ruff clean.

One note: the test_create_fails_loudly_when_force_graph_is_unavailable flake mentioned in PR #74 is unrelated but worth tracking in CI — if it starts failing on this branch too, it is a subprocess timing issue on Windows, not a regression here.

[Coding-Dev-Tools]

🔍 Pre-PR Code Review — ✅ LGTM (approve blocked: own PR)

Reviewer: Pre-PR Code Analyzer (automated)
Scope: +2023/-5 across 9 files, 4 commits

Security

Exceptional. Token never appears in logs/stdout/stderr/files. Redirects blocked. HTTPS pinned. Provider bodies never reflected. Preflight before token spend. Session file 0600. Client identity is random ULID.

Logic

No bugs found. Timeout validation rejects nan/inf/≤0. Post-redemption failures properly mapped. Compute URL resolution correctly scoped.

Tests

43 new tests (958 lines) for ~902 lines of production code. Covers happy path, HTTP error mapping, token leak prevention, malformed tokens, preflight storage, post-redemption failures, transport, response validation, and CLI dispatch.

Verdict: LGTM — ready to merge

Security-first design, thorough test coverage, all CI green (11 checks). Minor non-blocking: shell-history token exposure (documented trade-off with --token -), redirect-handler could use an explicit 3xx test.

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 19e89e963e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[Coding-Dev-Tools]

Review round addressed in 19e89e9 and 86b77e8, rebased onto current origin/main (73aa244).

All three threads were correct and are fixed; each was reproduced as a failing test before the change rather than fixed on inspection:

1. IncompleteRead escaping the error-body drain. Verified the premise first — http.client.IncompleteRead.__mro__ is (IncompleteRead, HTTPException, Exception, BaseException, object), so except (OSError, ValueError) could never catch it, and the drain runs inside an except block so the sibling HTTPException clause was unreachable for it. Also verified against a real socket, not a mock: a loopback server sending a chunk header promising 32 bytes, 17 bytes of body, then a clean FIN.
2. Timeout overflow. The bound was needed at a lower value than reported — 1e9 already raises OverflowError from socket.settimeout, on Windows as well as Linux. Ceiling is now 3600s, asserted against a real socket so it cannot drift upward.
3. Credential-less 200. Copy now says the token has been used and a new one is required, matching the truncated-reply path.

One extra bug found while fixing (1), fixed here. The comment on the connect drain cited cloud_session._post_refresh as "the same shape" — which turned out to be true of the bug. _post_refresh had the identical (OSError, ValueError) drain guard and no http.client.HTTPException clause at all (it did not import http.client), so a refresh reply truncated mid-body escaped as a raw traceback. That is the token-refresh path every paid feature runs through, so the crash surfaced far from its cause. In scope because this PR already modifies that file; four new tests, all failing before the fix.

Two review comments had asserted the false premise that IncompleteRead "subclasses HTTPException/ValueError" — presumably how the wrong guard was written in the first place. Both are corrected and a test now pins the real MRO.

Offline gate, both rows measured locally on the same base: origin/main 1411 collected / 1397 passed, this branch 1490 collected / 1476 passed — +79 tests, 0 failures, 0 errors, 14 skipped either side. ruff check . clean; eval harness and ablation unchanged.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 86b77e8779

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9974ae2329

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: dd8258bd48

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 43655a789b

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d4a113af4e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 04f8b6534a

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d9c2f68002

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[greptile-apps]

Coding-Dev-Tools has reached the 50-credit limit for trial accounts. To continue receiving code reviews, upgrade your plan.

[Coding-Dev-Tools]

Superseded by #80, which consolidated this change with the complete audited 1.1.0 client release and is now merged into main.