Scopehaven is a local assessment workbench. These controls reduce specific risks; passing tests does not prove zero vulnerabilities, ASVS compliance, production readiness or certification. Current code and reproducible observations are the authority.
Report security problems in ScopeHaven itself privately, never in a public issue:
- Preferred: GitHub private vulnerability reporting on this repository.
- Or email hello@scopehaven.dev with "security" in the subject.
Say what you found, how to reproduce it and what it lets an attacker do. You should hear back within 7 days. A confirmed report gets a fix or a documented limit, a security advisory with credit to you if you want it, and a note in CHANGELOG.md. Supported: the latest release on main; older tags get fixes only when the problem is severe and the fix is small.
A finding in an application you tested with ScopeHaven is yours to report to that application's maintainers, not to this project; ScopeHaven output is evidence from your own copy, never a disclosure.
Protect the local access capability, dedicated test-account credentials, application responses, saved evidence, notes and the integrity of conclusions. Treat target responses, imported JSON and human notes as untrusted data. A tool-reported verdict or reassuring application reply is not independent backend truth.
The local operator and operating-system account are trusted. This design does not resist same-account malware, a compromised browser/extension or an administrator rewriting code and evidence. It is not a shared hosted service. Exposing its listener through a tunnel does not provide hosted authentication or tenant isolation.
| Boundary | Control | Evidence |
|---|---|---|
| API access | Bind 127.0.0.1; exact numeric Host; Origin/Fetch Metadata checks; expiring bearer; reject duplicate Host/Authorization; POST marker | Local-access and independent security tests |
| Capability | Random 32-byte key, 8-hour expiry, timing-safe comparison; private 0600 launch file in 0700 directory; fragment removed on entry; memory-only browser key; reload locks view | local-access.mjs and browser receipt |
| Browser content | Same-origin assets and restrictive CSP; text rendering and escaped HTML reports; separate intro document with connect-src none; no token forwarding | Server/report and release integration tests |
| Authorization | A configured target runs only under an authorization record (scopehaven-authorization/1) that names it, every endpoint the run contacts, every credentialed test account and a window containing now; assess, the gate, the Action (in its prepare step, before its wait), the dashboard's run path, sequences and conversations check it before any connection and refuse with its code. Once the window ends, no further request is sent and no further observer call starts (one already running, or a stop, can still read until it returns), and a run whose window ends before it is saved is refused, with nothing saved or stamped. The record is read from a regular file (no symlink or FIFO, at most 256 KiB); its checksum is unkeyed, not a signature |
test/authorization.test.mjs, roe tests |
| Connector | Literal 127.0.0.1 HTTP origin from local configuration, or an operator-remote https origin under an authorization record naming it (DNS pinned for the run, non-public addresses refused unless named, certificate verified, no redirect followed); bounded paths; no DNS name except the remote origin's own host, and no redirect, proxy, automatic retry or arbitrary browser URL | Contract and connector tests |
| Credentials | Dedicated SCOPEHAVEN_TARGET_ references, sent as a bearer token, a named cookie or a named header (credentialHeader; Host, Cookie, Authorization, Content-*, framing, forwarding, proxy, trace-context and override names refused; the run keeps a digest per actor, never the value) to the target's origin only; missing credentials abort before requests (a declared webhook signing secret that is missing only leaves its signature headers unverified); explicit anonymous identities; raw response bodies and credentials omitted from retained evidence |
Connector and security tests |
| Files | Owner-private real directories; bounded no-follow reads; 0600 publication; append-only run core and separate notes; quotas and pagination | Storage boundary tests |
| Import | Auth before parsing; 2 MiB request, 1 MiB source, bounded depth/nodes/rows; duplicate/prototype keys rejected; minimized labels and attributed verdicts; no path/URL fetch or persistence | Import tests |
| Meaning | Synthetic observations, response contracts and external claims remain distinct; missing evidence stays inconclusive; required permitted-use controls gate repair claims | Runner, gate and import tests |
| Resource use | Bounded bodies/headers/responses, timeouts, 32 connections, one active assessment and no automatic target retry | HTTP and connector tests |
| Supply chain | Project-local Node 24.22.2 with runtime guard; the guard admits only the 22 and 24 LTS lines from 22.16.0 and 24.0.0, where node:sqlite needs no flag and honours its open timeout, and the launcher warns below their October 2026 security releases (22.23.4 and 24.22.1); official archive SHA256 verified; CI and the GitHub Action pin the same exact 24.22.2; no third-party runtime packages |
Runtime test and dependency guide |
The POST marker is a cross-site request safeguard, not authentication. Clearing the browser view is not global key revocation; restarting rotates the capability. Static assets and intro contain no capability. Dedicated test credentials remain separate from workbench access.
SHA256 detects changes against the saved checksum; it is not a signature and cannot resist a same-account actor replacing both. Notes never change verdicts. Saved runs are not signed. ./scopehaven export signs each export by default (below), and ./scopehaven attest signs exported files on request. Both use an operator-held Ed25519 key (a DSSE envelope carrying an in-toto Statement v1), and a Node verifier or an independent Python standard-library verifier checks them. A valid signature shows only that the key holder produced those exact files and run identities. It does not show that the checks or results are correct, it cannot resist anyone holding the key, and key custody, rotation and revocation are the operator's (integrations/attest/README.md). Unsafe existing permissions or symlink leaves are rejected rather than silently changed. Defaults are 1,000 runs, 64 MiB retained evidence and 2 MiB per file. Quota coordination is process-local: independent writers can race it, and a bounded temporary publication needs scratch space.
Browser exports use authenticated requests and generated blobs, and are not signed. The supported ./scopehaven export fallback saves an existing verified run to a fresh explicit file in an owned nonsymlink 0700 directory, and signs it into a fresh NAME.dsse.json envelope beside it unless --unsigned. Publication is exclusive, 0600, and never overwrites. The signing key lives in ~/.config/scopehaven/signing (or --signing-key-dir), a 0700 directory made on first use, with the private key 0600, never printed, logged or placed in an export, and the public key 0644. A key or directory with a wrong mode or owner, or a symlink, is refused (signing-key-unsafe), never repaired, and a failed sign removes the export it would have covered. No browser endpoint accepts a filesystem output path. Notes may contain operator-supplied private text; review them before sharing.
External source exists temporarily in caller/server memory. Omitting it from results is minimization, not secure erasure. Import performs no provider execution, does not authenticate vendor identity/version, and cannot create native runs or verified repairs. Its digest identifies bytes, not their truth.
App action logs (appLogs) are read from a local file the application writes, with bounded no-follow reads and nothing else: no request, no port, no credential. What they say is the application's own account, labelled app-reported: it is never custody evidence, never enters a custody verdict, and an application that writes a false log defeats it. With "use": "admission" it can only be used against the application: a clause fails when the log records a forbidden committed action of the check's own actor in the check's own window (app-log-unobserved-admission); it never makes, extends or rescues a pass, and a baseline fail resting only on it never credits a repair. Only the mapped fields of each line (the rule's action, name and resource, the actor as a declared principal or an unlisted digest, the outcome, the time) and a digest of the line are kept; the raw line is not.
Regression cases preserve initial findings involving action-ID reuse with altered arguments, missing local authentication/storage protections, malformed UTF-8 accepted as replacement text, and duplicate header ambiguity. Profile reads now also use bounded no-follow handles and fatal UTF-8. The independent repository review was an automated code review, not a professional external penetration test. One storage test is skipped where creating a different-UID file would require privilege escalation; that condition must not be called tested.
The independent review records are not in the open edition; the retests are in test/security-review.test.mjs.
A credentialed actor counts as logged in only from positive identity evidence: a required GET control whose response names the actor's declared identity value, checked at a probe point before the first and after each of that actor's other checks, and not satisfied without the credential, with a random credential of the same format or with another actor's credential. Under actor-identity/5 identity is bound per check: a probe point that did not pass withholds the checks it covers (ranked across both of a check's points), except that a required control is withheld only for a login-level reason (an identity probe that did not pass or did not finish at a point covering it, or a probe refused at any point), never because a surface probe failed for another reason; the identity route's own failure, or a probe refused with the actor's own credential at any point, withholds every check of the actor, required and identity controls included (a refused identity probe, answering 401, 403, the declared sign-in redirect or a complete 2xx that names another principal or none, reads bracket-not-passed; a refused surface probe, answering 401, 403 or the declared redirect, reads surface-refused; and bracket-not-passed when both were refused); and otherwise a check whose own two points passed keeps its status when a later point fails. Rows whose identity is not proven for them are inconclusive, never passing, in the run, the release gate, compare, SARIF and the HTML report; a boundary row whose refusal was observed while its identity or allowed use was not established is the distinct state prohibition-observed-identity-unproven (its decision), reported as such by the gate and never credited as a repair. A baseline row whose identity was not proven for it cannot produce a restored row. The gate stays per actor (identity-not-established); compare is per row. The gate, compare and the contract view share one evidence validator, and the suite export binds actor, credential mode, identity controls, refusal statuses, the identity rule set, a digest of the declared principals and evidence origin; run comparison refuses a pair whose identity rule sets differ.
Under the identity rules actor-identity/4, the brackets also re-send each surface control: a required GET allowed-use control of the actor on a protected route that is not an identity control. When the protected routes refuse there a credential the identity route still accepts (for example a whoami that decodes a token without checking expiry or revocation), the login is not proven (surface-refused) and the actor's rows are inconclusive. A surface probe must pass in full, as an identity probe must: one that fails for another reason (a 500, a 404, a failing or inconclusive 200) leaves the actor not established (surface-not-passed). A credentialed 401 on a boundary check is an authentication failure, not a refusal (unauthenticated-401), unless the actor declares refusesWith401 and a surface control brackets its checks. A 403 or any other answer outside 2xx counts as a refusal only after the same actor's earlier complete 2xx on a protected route (a surface control in its passed brackets); an actor without one has its login proven only on the identity route, so those rows read inconclusive (surface-unproven). A lifecycle post-change check is the declared exception: it expects the refusal, and it counts only when the change was sent by a credentialed actor with an identity control whose login was proven for the change check (changer-login-unproven otherwise). Three limits remain. An outage strictly between the two probe points that cover a check is not detected. Evidence of credential loss on an actor's own main rows, rather than at a probe point, stays row-level: a credentialed 401 on a boundary check (unauthenticated-401), a redirect to the declared sign-in, or a required control answering a refusal status withholds or fails that row, and the gate fails in each case, but compare may still credit other rows of that actor, and a change or a captured value that actor made still counts as attributed. A surface control is re-sent with the credential but never without it, so a required GET control on a public route satisfies the surface rule without showing that the credential was accepted anywhere protected; choose a surface route that needs the login. Runs saved as actor-identity/3 or /4 keep the earlier rules. Typed captures keep a captured value out of their own records (a per-run keyed digest only), but not out of observer evidence: an observer records the resource identifiers the application reports, such as an audit log's request path or a snapshot's row key, which can be the captured value, so saved runs need the same care as the profile. An absence clause whose selector pins an actor, a resource or a trace id needs an allowed-use twin that was sent and matched (selector-unpaired, selector-not-shown-to-match), so a selector that names a wrong actor or resource cannot pass by selecting nothing; a resource pin needs no twin only when every deciding observer declares that resource for the selector's exact name and every committed effect of that name (and the selector's source and operation, when it gives them) in the window carries a declared resource. Pairing shows non-vacuity, not relatedness: an absence clause about an effect its own request could never cause still passes once its selector is shown to select something. Saved evidence uses keyless checksums, so a same-account actor who edits and consistently reseals a run is not detected: that includes its probe point outcomes, its lifecycle entries (which decide which rows are post-change refusals) and the change attribution recomputed from them. The exported suite binds declarations, not outcomes: the lifecycle declarations, the declared principals (by digest), each actor's identity controls, identity predicate and refusal statuses, and which probe points exist (through its check list); probe outcomes, and what is recomputed from them, stay under this limit. Signed evidence is future work.
An egress recorder keeps every outbound request body as a salted digest. Capture of body content is off by default and opt-in per destination: a destination's capture.pointers names up to 16 JSON pointers to scalar fields of its JSON request bodies (64 per recorder), and only those values are stored on the send events, in the run record and every export, with the declaration on the run (observers[].capture). The whole body is never captured, CONNECT tunnels and the witness request are never captured, and at most the declared maxBytes (1024 to 65536) of a body is buffered to parse it. Capture applies only on the destination's declared paths (a destination that declares capture must declare paths); a send on any other path of the host records path-undeclared and no values. A pointer whose keys name a secret-like field (password, passcode, pw, pwd or pswd, token, secret, authorization or auth, cookie, session or sid, CSRF, JWT, HMAC or signature, key or signing key, private key, credential, card, cc or ccn, CVV or CVC, security code or answer, IBAN, bank account, account or routing number, sort code, OTP, MFA, 2FA, TOTP or recovery code, passport, SSN, social security or insurance number, national or tax id, TIN, date of birth or DOB, driver's license, or a key word that is, starts with or ends with PAN, PIN, SSN, SIN, CVV, CVC, OTP, auth or acct, as in customer_ssn, ssnLast4, pinCode or user_pin) is refused when the profile loads, even as an interior key. Keys are folded with NFKC first (fullwidth letters become ASCII), and a key that still holds a character outside printable ASCII (a Cyrillic or Greek lookalike) is refused; a short list of ordinary words (single, since, span, ping and a few others) is excepted, and refusing too much is accepted. A string over 200 characters, or a value shaped like a secret or a personal identifier (a JWT, a provider key, an AWS access key id, a bearer, basic or token authorization value, a PEM block, a long hex or base64 run, a Luhn-valid 13 to 19 digit run or integer that may be a card number, with any one separator character between digit groups, or a nine-digit NNN-NN-NNNN identifier with any one separator or none; strings are checked after NFKC folding, and one holding a decimal digit outside 0-9 is redacted), is not stored. A nine-digit JSON number is not redacted (amounts in cents reach nine digits): name identifier fields so the deny-list refuses them. Captured values stay with the evidence until the evidence directory is deleted (the store has no delete or expiry), so keep such runs as private as the profile and its test data. A provider feed that declares a template vocabulary stores, per send, only the operator label of a declared template id the provider's signed entry names exactly (or that it named none, or an undeclared one). The profile's provider template ids are never stored as such in a run, an export or a digest of their own; a label appears there, and it equals an id only when the operator chose it so. Rules: src/body-fields.mjs; generated summary: docs/DATA-HANDLING.md.
A body that cannot be read (not JSON in UTF-8, compressed, over the cap, invalid, nested too deep, a repeated key) leaves its declared fields unknown, and a clause over an unknown field reads missing: never pass and never absent. A destination may also opt in to reading the same fields from form-encoded bodies (capture.encodings), with the same deny-list (also applied to the flattened form key), the same redaction and the same caps; a form send that is not a POST, or that has a URL query, a fragment or a Cookie header, is never read. A destination that declares an idempotency header has that header's value stored only as salted digests (the key, its case-folded form and the request head), never in clear. The validator binds each sealed window's published capture to the declaration and each captured record to its declared pointers.
A destination may opt in to forwarding (forward, src/effect-outcome.mjs, integrations/observers/egress-forward.mjs): each recorded send is then forwarded to a declared upstream that must be the literal http://127.0.0.1:<port> (a host name, another address, https, a path, the recorder's own port, another declared observer's port or the target origin's port is refused at validation), with no redirects followed and the reply bounded in time and size. The upstream's reply goes back to the application, and the send event records only the upstream's status, whether its proof verified and the outcome, never the reply body. An outcome is decided only with a valid proof: an HMAC, under a proofEnv secret of at least 32 characters from the dedicated SCOPEHAVEN_TARGET_ namespace that the application is never given (a proofEnv that is also an actor's or observer's credential is refused), over a fresh per-request nonce, the method, path and query, body digest and content type the upstream received, and its status. Then it is applied only for a listed 200, 201, 203, 204 or 205 to a method other than GET, HEAD, OPTIONS or TRACE, and rejected only for a listed 4xx; anything else is unknown, and an unknown outcome never passes a clause that requires upstream: "applied". The proof shows who answered, not that the answer is true: an upstream that answers a listed 2xx without applying the request reads applied. A destination that declares proof version 2 has the proof cover the reply body too, and one that also declares ids keeps the declared string ids of each proven reply (minted ids, minus any value the request itself carried, and references) only as digests salted per recorder, never the ids or the reply body.
A destination that declares keyed retries may also declare verified signature headers (idempotency.signing, src/idempotency.mjs): a scheme from a fixed menu (stripe, standard-webhooks, slack-v0) and 1 to 4 SCOPEHAVEN_TARGET_ variables holding the webhook signing secrets the destination verifies with. Unlike an actor credential (sent to the application) or a forward proofEnv (which the application must never hold), a signing secret is the application's own, so a verified signature shows only which declared secret signed a send, never who signed it. The egress recorder reads those variables once, when it is built, and keeps the derived key bytes only in its own closure; the connector reads them once more at run start only to refuse a signing secret that equals a proof secret (as a string, as key bytes or as the same HMAC key) and keeps nothing. They are never sent anywhere and nothing derived from them (no digest, fingerprint or MAC) is written to records, the run, reports, exports, errors or logs: a send records only { scheme, verified, t, at }, and the run records only whether each declared secret was usable. A variable that is also an actor's or observer's credential or a proofEnv is refused at load, and two secrets of one destination that are the same HMAC key are refused when the recorder is built. Verification compares every secret and signature entry in constant time with no early exit, runs one HMAC per declared secret whether or not it is usable, and never changes the reply; how long a send takes still depends on whether its own signature headers parse. Stopping a recorder zeroes the key bytes and closes verification for good; the strings themselves stay in the process environment, and memory is not securely erased.
A provider feed that declares outcomes (integrations/observers/provider-feed.mjs) reads the provider's signed later word on each message it accepted (succeeded, deferred, failed, reversed, contested, complained). It binds each word to a send only by the provider's own message id and the recipient's canonical address, never by a value the application writes, and the run stores only the observer's own event number and the word per send, with a flag saying whether every outcome up to a signed head read when the later wait ends was read (no refused entry, gap or fault); no provider message id, address or provider event type is stored. A forged outcome fails the feed's signature check like any entry. Under provider-feed/6 the records only lower a positive pass; they never make, extend or rescue one, and a forbidden send that bounced still fails. A saved run's records are bound to its sealed sends, words and order but not re-verified against the provider's signatures (raw bodies are not kept): someone who edits a saved run can drop a failure or mark the horizon clear and re-derive every verdict consistently, the same stored-evidence boundary as the events themselves.
A provider feed's custody rests on who holds the key that signs its entries, which nothing in a run can show: an application can serve a feed of its own and sign it with its own key. A feed therefore declares where its public key came from (keySource: provider for the provider's own export, adapter with adapterReads provider-api or application-store for an operator-run adapter, or stub for a test stub; collector provider-feed/7, src/custody.mjs feedKeyCustody), and its run record and every sealed window carry the declaration (undeclared when the profile names none). An undeclared source, or an adapter that reads the application's own store, is a key the application could hold: that feed's record counts as subject-writable, so it never supports a pass, while a send it shows still fails. A feed sees only its own provider's sends, so no other observer covers its route: a prohibition or count that would pass reads inconclusive when such a feed sees what it selects, whether the feed decided it or is presence-only (an export file, or an endpoint without a witness), however independent the others are (an honest feed for another vendor, or an SMTP sink, that recorded nothing). An effect.only pass that judges such a feed reads inconclusive the same way. So an undeclared presence-only feed beside another observer of the same domain leaves that absence inconclusive until it declares its key source. ScopeHaven cannot check the declaration itself: a feed declared provider or stub whose key the application in fact holds is counted as independent, so the declaration is the operator's statement and is cited as one. A run recorded before provider-feed/7 carries no key source and keeps the custody it was judged with; it never compares with a later one.
The egress recorder, the SMTP sink and the payments double hold their port on both loopback addresses, 127.0.0.1 and [::1], each bound exclusively (collectors egress-recorder/10 and smtp-sink/2). A route the application writes with a name such as localhost may resolve to ::1 first, and a process that held [::1] at the sink's port would take that route's traffic while relaying only the witness to 127.0.0.1. If either bind fails the sink does not start and its windows fail, and a listener that comes later cannot bind either address. No other address is bound; a host without IPv6 loopback cannot start these sinks.
An egress recorder that declares a request feed (requestFeed, src/request-feed-rules.mjs, integrations/observers/request-feed.mjs) makes one more network call site: its reader sends GET requests to the declared feed endpoint on the literal 127.0.0.1 and port only (the port may not be the target origin's, an observer's, a forward upstream's or a provider feed's), each bounded in time and size, at the recorder's start and once at run end within a 6 s cap; no redirect is followed and no credential is sent. It holds only the feed's Ed25519 public key, so no secret is read, and verifies every entry and every signed head (with a fresh nonce) before it reads one; an unsigned or wrongly signed entry, a malformed one, a gap or a rewrite leaves every request-feed resolution failed. Provider keys, object ids and tenants from the feed, and the send's tenant header, are compared only as digests salted per recorder, held in memory and never written; the run keeps per in-doubt send only the counts, flags and times the request feed derives its result from (and the send's own salted key digest, which its sealed key record already carries), never a key, object id, tenant, entry body or address. A saved run's reads are bound to its sealed sends and re-derived by the validator, but not re-verified against the provider's signatures (raw entries are not kept): someone who edits a saved run can rewrite a read and re-derive every verdict consistently, the same stored-evidence boundary as the events themselves.
A forwarded destination that declares read-back (readBack, src/read-back-rules.mjs, integrations/observers/read-back.mjs) has its recorder make GET requests of its own: of each route's declared control object when the recorder starts (without waiting for it), before the first write of a group is forwarded (bounded by min(1000 ms, timeoutMs), and the write goes on past it), twice after the route's declared settlement bound, and once at run end within the run-end cap, each bounded in time and size. They go through the same forwarder as the destination's writes (integrations/observers/egress-forward.mjs): to the literal 127.0.0.1 on the declared upstream port only, never through the application or the recorder's listener, with no redirect followed, to a path filled only from the write's own forwarded path segments (letters, digits, ., _, ~ and -, raw and decoded agreeing) and with no query string; a reply counts only when it carries the destination's forward proof /2, which covers the reply body. Each read carries the destination's read credential, read once from its SCOPEHAVEN_TARGET_ variable and held in the recorder's closure; a read credential that is also an actor's, an observer's, an identity's, a forward proof's or a signing secret's variable is refused at load, and one whose value is any of those values is refused at run start. The identities' variables hold credentials the application itself sends: the recorder reads each once and keeps only a digest salted per recorder, to compare with the salted digest of each send's declared credential header, and never writes either. Item ids, authors, bound paths, matched field values, scope header values and the write credential are compared only as those salted digests, held in memory and never written; the run keeps per in-doubt send only the counts, flags and times read-back derives its result from (and per send the salted digests of its group, object, touches and credential, which never leave the run's own salt). A saved run's reads are bound to its sealed sends and re-derived by the validator, but not re-verified against the backend (raw replies are not kept): someone who edits a saved run can rewrite a read and re-derive every verdict consistently, the same stored-evidence boundary as the events themselves.
Claim rules (src/http-claims.mjs) read a response once and keep only the reading and the index of the declared phrase or value that matched, never the reply text. The reading only selects which records requirement applies (a success claim needs the effect in the observers' records, a refusal claim needs its absence); the observers decide the verdict, and a reply that is not exactly one declared sentence (optionally followed by one declared courtesy sentence), unreadable or silent is inconclusive. Free text is not parsed: the normalised reply is compared with the declared sentences for equality, never compiled into a regular expression, and replies over 8000 characters, before or after NFKC normalisation, read unreadable. The declared claim rules themselves, phrases and values included, are profile content: they are stored in each check's sealed trace and exported with it, so do not put secrets in declared sentences or courtesy templates.
json.noForeignValues (src/tenant-values.mjs) reads only the values a profile declares in tenantValues; it is not a general leak detector, and a value the profile did not declare, a paraphrase or a value spelled out is not seen. It fails only on another tenant's identifier written literally (its exact declared characters, spaces at its ends trimmed) as a whole token, in an occurrence that no value of another set of owner tenants overlaps, that the check's own request does not carry. It passes only when every leaf is in the plain form, the response body repeats no member name, and no other tenant's value occurs in any reading, except that under "attributesAlone": "ignore" an attribute seen as a whole token does not prevent a pass. Everything else reads inconclusive, never pass. A response body with a repeated member name in any object reads inconclusive, never pass, because JSON parsing keeps only the last of the repeated values (the connector counts repeats on the raw body); another tenant's identifier written literally in the parsed value still fails. Text in another letter case, with other spacing, encoded, marked up, in look-alike letters of another script, with a number written differently or split across leaves only withholds the pass; it is never reported as a leak. The full rule, its accepted recall loss and what it does not see are stated word for word in docs/KNOWN-LIMITS.md and in the limitation every run that declares tenant values carries. Saved runs and the exported suite keep counts and 1-based positions (tenant n, identifier m), never a declared value or the response text; the declared values are profile content, so keep the profile as private as its test data.
ScopeHaven won't run a configured target without a matching authorization record (docs/RULES-OF-ENGAGEMENT.md, src/authorization.mjs). Each entry point that sends requests to a target the operator configured (assess, the regression gate and the GitHub Action, the dashboard's run path, the sequence and conversation commands) checks the record against the validated profile the run uses before any connection: the target's id and applicationId, every endpoint the run contacts (the origin, each observer's endpoint, an egress recorder's forwarding upstreams and request feed, a sequence's hold-gate upstream and the owned model tap's upstream), every actor with a credential, and the window. Built-in fixture targets need none. The run, its HTML report, SARIF, comparison export and gate summary carry only the record's id and checksum. The checksum is unkeyed: it shows an edit made without recomputing it, and anyone who can edit the record can recompute it, so the record is the operator's statement, not a signature. Keep it where the application under test cannot write it. A record that repeats a field name is refused, so the file cannot show one value while the check enforces another. The window is checked when a run starts, again before every request it sends and when each call it makes to a declared observer starts (and before each readiness probe of the Action's wait, whose URL must be one of the record's origins), and once more immediately before the run is saved or stamped: if it has ended, no further request is sent, no further observer call starts and the run is refused (authorization-window-ended), with nothing saved or stamped. The check is made when each observer call starts. A call already running when the window ends (a provider feed's run-end drain or later-outcome wait, a request feed's run-end read) finishes its reads, up to its own cap, and stopping a provider feed lets its queued read finish. The final check then refuses the run. An observer's own activity between its start and stop (a provider feed's poll timer, a recorder or hold gate relaying the application's calls) is not checked request by request; it stops with the run, and the final check refuses a run that ended at or after validUntil. Library callers that run a profile directly are not checked.
A remote target ("targetContext": "operator-remote", src/remote-target.mjs) is reached directly over HTTPS only when the record names its exact origin. Its host is resolved once before the first request and every request connects to that address (the TLS name stays the host, so the certificate is checked for it, against the system store and NODE_EXTRA_CA_CERTS); before each request the host is resolved again, and a different answer stops the run with no run saved. The record's window applies as to a loopback target: it is checked before the host is first resolved, before every request's DNS check and again after it, immediately before that request's connection, again when that connection's TLS handshake is done, immediately before the request is written, when each observer call starts, and once more before the run is saved or stamped. A connection started before the window ended can still finish its TLS handshake after it (handshake bytes only, within that check's request timeout: 3 s by default, up to 120 s for a check that declares timeoutMs), but its request is not written: the socket is closed with nothing sent on it, the credential included. The connector refuses a remote target, from any caller, without the grant a record naming its origin makes and the record's window check (authorization-missing). Every address of the answer must be public, or listed in the record's addresses; loopback, private, shared, link-local, cloud metadata, multicast, documentation and reserved addresses are refused otherwise. Redirects are never followed, credentials go only to the pinned origin, and observers stay on loopback.
An operator-forwarded target (a loopback forwarder in front of the operator's staging) runs only under a record whose forwarded.destination names where the forwarder sends traffic. ScopeHaven still connects only to the loopback forwarder and cannot check where it goes; the destination is the operator's statement, bound by the record's checksum, and never copied into the run. Because a forwarder can answer a route itself, a boundary pass in a forwarded run counts toward a clean gate or a clean assess exit only when a required control with the same method on the same route passed in the same run (src/forwarded-pairing.mjs).
Identify the exact owned environment, synthetic accounts, permitted operations, request/spend limits, observable effects and reset procedure. Agree what each pass proves. Response text cannot establish the absence of a database read, tool call or external side effect. Missing trustworthy observation remains inconclusive.
Outstanding requirements include user identity and revocation, organization authorization and tenant isolation, remote connector TLS/egress/SSRF design for a hosted service (the local operator-remote mode pins one authorized origin per run; a shared service would need it per tenant and request), scoped credential lifecycle, transactional storage/migrations, encryption/key management, retention/deletion, tested backup recovery, audit events, rate limits, incident response, operational monitoring, deployment controls and independent review. Scheduling and configured alert delivery are also unbuilt. These are future gates, not implemented features.
An assessment detects covered failures. Enforcement requires controls at action boundaries. Monitoring requires an operating scheduler and verified delivery. A one-shot release gate provides neither continuous monitoring nor automatic repair.
- OWASP ASVS 5.0: verification framework; no conformance claim.
- NIST SSDF 1.1: secure development and vulnerability response.
- OWASP SSRF and authorization: destination and operation boundaries.
- OWASP secrets and logging: minimize secret exposure.
- OWASP multitenancy: future hosted requirements.
- OWASP XSS and CSRF: browser boundaries.
- Node July 2026 advisory and Node 24.21.0 release: runtime patch review. Not every advisory affects this application's reachable features.
- Node October 2026 advisory, Node 24.22.1 release and Node 24.22.2 release: the minimum moved to 24.22.1 and the pin to 24.22.2. The one advisory reachable here (HTTP Agent keep-alive reuse) also had
integrations/init/probe.mjsmoved toagent: falsewithConnection: close.