@ref0/cli 0.12.0 → 0.13.0

package/dist/main.mjs

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
-import { Cause, Clock, Config, ConfigProvider, Console, Context, Cron, Crypto, Data, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, Match, Option, Path, Predicate, Queue, Random, Redacted, Ref, Result, Runtime, Schedule, Schema, SchemaIssue, SchemaTransformation, Scope, Semaphore, Stdio, Stream, Struct, Terminal, Tuple } from "effect";
 import { Argument, CliOutput, Command, Flag, Prompt } from "effect/cli";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { Cause, Clock, Config, ConfigProvider, Console, Context, Cron, Crypto, Data, DateTime, Deferred, Duration, Effect, Exit, Fiber, FiberSet, FileSystem, Layer, Match, Option, Path, Predicate, Queue, Random, Redacted, Ref, Result, Runtime, Schedule, Schema, SchemaIssue, SchemaTransformation, Scope, Semaphore, Stdio, Stream, Struct, Terminal, Tuple } from "effect";
+import { FetchHttpClient, Headers, HttpClient, HttpClientRequest } from "effect/http";
 import { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity } from "effect/http-api";
+import { Base64Url } from "effect/encoding";
 import { ChildProcess, ChildProcessSpawner } from "effect/process";
 import { execFile, spawn } from "node:child_process";
 import { createServer } from "node:http";
@@ -652,6 +653,370 @@ const AgentDetached = eventKind("agent.detached", Schema.Struct({
 	why: Schema.Literals(["revoked", "attach lost"])
 }));
 //#endregion
+//#region ../contracts/src/connections.ts
+/**
+* A connection's name in its project, such as `sentry` or `deploys`: lowercase letters, digits
+* and hyphens, from a letter, as a mention names an outside service. `ref0` names ref0's own, so
+* no connection takes it. Two connections of a project are never named alike at once.
+*/
+const ConnectionName = Schema.String.check(Schema.isPattern(/^[a-z][a-z0-9-]{0,38}$/), Schema.makeFilter((name) => name !== "ref0" || "`ref0` names ref0’s own")).pipe(Schema.brand("ConnectionName"));
+/**
+* What reads a connection's deliveries: `webhook`, whose sender posts ref0's own shape, `{ kind,
+* key, title?, url? }`; or `sentry`, whose sender is Sentry, posting its issue and alert
+* webhooks, which its mapper reads. More kinds come one at a time, each with its mapper.
+*/
+const ConnectionKind = Schema.Literals(["webhook", "sentry"]);
+/** The most characters in a signal's link: a longer one is withheld. */
+const signalLinkLength = 2048;
+/**
+* An ID as a signal holds one: letters, digits and `:` `/` `.` `-` `_`, from a letter or a
+* digit, so it can't carry a space, a quote, an instruction or a command's option.
+*/
+const signalIdPattern = (length) => new RegExp(`^[A-Za-z0-9][A-Za-z0-9:/._-]{0,${length - 1}}$`);
+/** What happened, in the service's own word: `issue.created`, `deploy.finished`. */
+const SignalKind = Schema.String.check(Schema.isPattern(signalIdPattern(64))).pipe(Schema.brand("SignalKind"));
+/** What it's about, so a repeat can be recognised: an issue's ID, a release. */
+const SignalKey = Schema.String.check(Schema.isPattern(signalIdPattern(128))).pipe(Schema.brand("SignalKey"));
+/**
+* Why a signal's title or link wasn't kept: it looked like a secret; a link that isn't `https`;
+* or a link too long to keep whole.
+*/
+const SignalWithheldWhy = Schema.Literals([
+	"looks like a secret",
+	"not an https link",
+	"too long"
+]);
+/** A signal's title or link the connection gave, withheld, and why. */
+const SignalWithheld = Schema.Struct({
+	title: Schema.optionalKey(SignalWithheldWhy),
+	url: Schema.optionalKey(SignalWithheldWhy)
+});
+/**
+* A Sentry organization, by its slug as Sentry's URLs name it: lowercase letters, digits,
+* hyphens and underscores, from a letter or a digit.
+*/
+const SentryOrg = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9_-]{0,49}$/)).pipe(Schema.brand("SentryOrg"));
+/** Where a Sentry organization's data lives, and so which of Sentry's API hosts answers for it. */
+const SentryRegion = Schema.Literals(["us", "de"]);
+/** A connection added to the project, by the admin whose approval added it. */
+const ConnectionAdded = eventKind("connection.added", Schema.Struct({
+	connection: ConnectionId,
+	name: ConnectionName,
+	kind: ConnectionKind
+}));
+/** A connection's token replaced, by the admin whose approval replaced it: the old one works no more. */
+const ConnectionRotated = eventKind("connection.rotated", Schema.Struct({ connection: ConnectionId }));
+/** A connection removed, by the admin whose approval removed it: its webhook takes nothing more. */
+const ConnectionRemoved = eventKind("connection.removed", Schema.Struct({ connection: ConnectionId }));
+/**
+* A `sentry` connection's credential set, by the admin whose approval set it: the Sentry
+* organization and region it reads, and that ref0 now holds a token for them, which only ref0's
+* server reads, to call Sentry for a workflow. Never the token, nor its hash. Setting it again
+* replaces the one before.
+*/
+const ConnectionCredentialSet = eventKind("connection.credential.set", Schema.Struct({
+	connection: ConnectionId,
+	org: SentryOrg,
+	region: SentryRegion
+}));
+/**
+* A signal, received by a connection: delivered to its webhook, by `ref0:hooks`, or sent with
+* `ref0 signal send` by the person or agent whose token sent it. `at` is when ref0 received it.
+* A title or link that failed its check is withheld, and says why in `withheld`; a title too long
+* is cut, and says so in `titleCut`. `dropped` counts the deliveries the connection dropped since
+* its last signal: over a bound, or refused. A delivery's ID, if the service gave one, is in the
+* envelope's `source` only as the SHA-256 of the connection and that ID.
+*/
+const SignalReceived = eventKind("signal.received", Schema.Struct({
+	connection: ConnectionId,
+	kind: SignalKind,
+	key: SignalKey,
+	title: Schema.optionalKey(TextId),
+	url: Schema.optionalKey(TextId),
+	withheld: Schema.optionalKey(SignalWithheld),
+	titleCut: Schema.optionalKey(Schema.Literal(true)),
+	dropped: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+	at: Schema.DateTimeUtcFromMillis
+}));
+/**
+* ref0's one origin, as a client is given it: `http` or `https`, a host and maybe a port, and no
+* credentials, path, query or fragment. That pattern alone lets through a host or port no URL has,
+* such as `https://1.2.3.999`, `https://[1::2::3]` or `https://ref0.test:99999`, so the platform's own URL parser must take
+* it too. It's kept as written, case and any default port too: every path here is appended to it
+* as it is.
+*/
+const ApiOrigin = Schema.String.check(Schema.isPattern(/^https?:\/\/(?:\[[0-9A-Fa-f:.]+\]|[^\s/?#\\@:[\]]+)(?::\d+)?$/), Schema.makeFilter((origin) => URL.canParse(origin) || "a URL the platform can parse")).pipe(Schema.brand("ApiOrigin"));
+/** Where signing in's own routes live, which Better Auth serves, outside `Api`. */
+const signInBase = "/auth";
+/**
+* A route under `signInBase`, by its method: its `path` from the origin's root, as a request
+* names it, and its `pathUnderBase`, as Better Auth names its endpoints.
+*/
+const signInRoute = (method, pathUnderBase) => ({
+	method,
+	pathUnderBase,
+	path: `${signInBase}${pathUnderBase}`
+});
+/** Signing in with GitHub, from ref0's pages: starting it, GitHub's way back, and signing out. */
+const signInRoutes = {
+	gitHubSignIn: signInRoute("POST", "/sign-in/social"),
+	gitHubCallback: signInRoute("GET", "/callback/github"),
+	signOut: signInRoute("POST", "/sign-out")
+};
+/**
+* The OAuth server outside MCP clients use (layer 4, PR 11a): its metadata, authorizing, the
+* token endpoint, registering a public client and revoking a token.
+*/
+const oauthRoutes = {
+	metadata: signInRoute("GET", "/.well-known/oauth-authorization-server"),
+	authorize: signInRoute("GET", "/oauth2/authorize"),
+	token: signInRoute("POST", "/oauth2/token"),
+	register: signInRoute("POST", "/oauth2/register"),
+	revoke: signInRoute("POST", "/oauth2/revoke")
+};
+signInRoute("POST", "/oauth2/consent");
+[...Object.values(signInRoutes), ...Object.values(oauthRoutes)];
+`${oauthRoutes.metadata.pathUnderBase}`;
+/** Where an agent's session asks for an identity token. */
+const identityTokenPath = "/v1/me/identity-token";
+/** One DNS label, or one part of an IPv4 address: letters, digits and inner hyphens. */
+const label = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?";
+/** `https://`, a host name, then maybe `:` and a port with no leading zero. */
+const audiencePattern = new RegExp(`^https://(${label}(?:\\.${label})*)(?::([1-9][0-9]{0,4}))?$`);
+/**
+* Whether the platform's URL parser reads the audience as written: an `https` URL whose host is
+* the audience's own, lowercased, and whose port is its own, or none for 443. That refuses a host
+* the parser rewrites, such as `https://1.2.3` read as `1.2.0.3`, and a port past 65535.
+*/
+const parsesAsWritten = (audience) => {
+	const parts = audiencePattern.exec(audience);
+	if (parts === null || !URL.canParse(audience)) return false;
+	const url = new URL(audience);
+	const port = parts[2] ?? "";
+	return url.protocol === "https:" && url.hostname === (parts[1] ?? "").toLowerCase() && url.port === (port === "443" ? "" : port);
+};
+/**
+* Who an identity token is for: an outside service's HTTPS origin, in ASCII, at most 255 bytes,
+* with no credentials, path, query, fragment, wildcard or space. It's kept exactly as asked, its
+* case and any port too, so `https://verifier.example:443` is another audience than
+* `https://verifier.example`. ref0 never fetches or resolves it.
+*/
+const IdentityAudience = Schema.String.check(Schema.isMaxLength(255), Schema.isPattern(audiencePattern), Schema.makeFilter((audience) => parsesAsWritten(audience) || "an origin the platform reads as written")).pipe(Schema.brand("IdentityAudience"));
+/** `POST /v1/me/identity-token`'s body: the one audience, and nothing else. */
+const IdentityTokenRequest = Schema.Struct({ audience: IdentityAudience });
+/** A compact JWT: its header, payload and signature, each in base64url, at most 4 KiB. */
+const IdentityToken = Schema.String.check(Schema.isMaxLength(4096), Schema.isPattern(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)).pipe(Schema.brand("IdentityToken"));
+/** What asking for an identity token answers: the token, and when it expires, its `exp`. */
+const IssuedIdentityToken = Schema.Struct({
+	token: IdentityToken,
+	expiresAt: Schema.DateTimeUtcFromMillis
+});
+/**
+* An identity token's `jti`: a fresh UUIDv4 from the platform's cryptographic source for each
+* token, naming its issuance in ref0's log without naming any row or secret.
+*/
+const IdentityTokenId = Schema.String.check(Schema.isPattern(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)).pipe(Schema.brand("IdentityTokenId"));
+/**
+* A person, as one audience knows them: `pperson_`, then the first 128 bits of an HMAC of the
+* person's ref0 ID for the token's issuer and audience, as a TypeID suffix. Stable at one
+* audience, different at every other, and carrying no time.
+*/
+const PairwisePersonId = TypeId("pperson").pipe(Schema.brand("PairwisePersonId"));
+/** A session, as one audience knows it, made as a person's is. */
+const PairwiseSessionId = TypeId("psession").pipe(Schema.brand("PairwiseSessionId"));
+/** The accountable person, last in a token's chain: only their pairwise ID. */
+const PersonActor = Schema.Struct({ sub: PairwisePersonId });
+/** A session in a token's chain, then whoever it acts for: its parent session, or the person. */
+const sessionActing = (act) => Schema.Struct({
+	sub: PairwiseSessionId,
+	act
+});
+const oneSession = sessionActing(PersonActor);
+const twoSessions = sessionActing(oneSession);
+const threeSessions = sessionActing(twoSessions);
+/**
+* A token's `act`, as RFC 8693 nests it: the current session, then up to three parent sessions,
+* then the accountable person, each by its pairwise ID. It's history, not authority: a verifier
+* allows the agent in `sub`, never an actor.
+*/
+const IdentityActor = Schema.Union([
+	oneSession,
+	twoSessions,
+	threeSessions,
+	sessionActing(threeSessions)
+]);
+/** A time in a token, in whole UTC epoch seconds. */
+const EpochSeconds = Schema.Int.check(Schema.isGreaterThan(0));
+Schema.Struct({
+	iss: ApiOrigin,
+	sub: AgentId,
+	aud: IdentityAudience,
+	iat: EpochSeconds,
+	exp: EpochSeconds,
+	jti: IdentityTokenId,
+	act: IdentityActor
+}).check(Schema.makeFilter(({ iat, exp }) => exp > iat && exp - iat <= 600 || `an expiry after its issue, at most 600 seconds later`));
+/**
+* A signing key's ID, its `kid`: the key's RFC 7638 thumbprint, SHA-256 in base64url, so one ID
+* never names two keys.
+*/
+const SigningKeyId = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)).pipe(Schema.brand("SigningKeyId"));
+Schema.Struct({
+	alg: Schema.Literal("ES256"),
+	kid: SigningKeyId,
+	typ: Schema.Literal("JWT")
+});
+/** A P-256 coordinate: 32 bytes in base64url, unpadded, in its one canonical spelling. */
+const Coordinate = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/));
+/** One public key in the JWKS: exactly these fields, and never a private one. */
+const PublicSigningKey = Schema.Struct({
+	kty: Schema.Literal("EC"),
+	crv: Schema.Literal("P-256"),
+	x: Coordinate,
+	y: Coordinate,
+	use: Schema.Literal("sig"),
+	alg: Schema.Literal("ES256"),
+	kid: SigningKeyId
+});
+Schema.Struct({ keys: Schema.Array(PublicSigningKey).check(Schema.isMaxLength(3)) });
+Schema.Struct({
+	issuer: ApiOrigin,
+	jwks_uri: Schema.String,
+	subject_types_supported: Schema.Tuple([Schema.Literal("public")]),
+	id_token_signing_alg_values_supported: Schema.Tuple([Schema.Literal("ES256")]),
+	claims_supported: Schema.Tuple([
+		Schema.Literal("iss"),
+		Schema.Literal("sub"),
+		Schema.Literal("aud"),
+		Schema.Literal("exp"),
+		Schema.Literal("iat"),
+		Schema.Literal("jti"),
+		Schema.Literal("act")
+	])
+});
+/**
+* The audience isn't one ref0 signs for: missing, given twice, or not an HTTPS origin as
+* `IdentityAudience` says. The refused text is never echoed.
+*/
+var IdentityAudienceRefused = class extends Schema.TaggedError()("IdentityAudienceRefused", { nextStep: Schema.String }, { httpApiStatus: 400 }) {};
+/**
+* Less than a whole second is left before the session, a parent or the credential expires, or
+* the token would expire before it's recorded: the next prompt renews or replaces the session.
+*/
+var IdentityTokenNotReady = class extends Schema.TaggedError()("IdentityTokenNotReady", { nextStep: Schema.String }, { httpApiStatus: 409 }) {};
+/**
+* ref0 signed an identity token for one of a project's sessions: in that project's log, on the
+* session's thread, with ref0's own IDs for the session, its agent and its accountable person,
+* and the token's `jti`, never the token. It proves ref0 made the token, not that any service
+* received or used it. A failed append discards the token, so every token has its event.
+*/
+const IdentityTokenIssued = eventKind("identity_token.issued", Schema.Struct({
+	session: SessionId,
+	agent: AgentRef,
+	/** The person whose attachment authorized the session's chain, last in the token's `act`. */
+	accountable: PersonId,
+	jti: IdentityTokenId,
+	audience: IdentityAudience,
+	issuer: ApiOrigin,
+	keyId: SigningKeyId,
+	issuedAt: Schema.DateTimeUtcFromMillis,
+	expiresAt: Schema.DateTimeUtcFromMillis
+}));
+//#endregion
+//#region ../contracts/src/proofs.ts
+/**
+* Proofs of possession: a credential bound to a key, and the proof that comes with each request
+* made with it, RFC 9449's DPoP. A bound credential, a host grant or a session's token, names its
+* key's thumbprint as `cnf`, which only ref0's own state says, never a caller. Each request sends
+* the token as `Authorization: DPoP <token>` and one `DPoP` header: a compact JWS, signed with
+* ES256 by that key, over the request's method and URL, when it was made, and the token's hash.
+* There's no server nonce and no replay store: a captured token and proof can be used again on
+* the same method and path while the proof's time is in the window, and a token alone can't.
+*/
+/** A P-256 key's RFC 7638 thumbprint: SHA-256 over its required members, in base64url. */
+const KeyThumbprint = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)).pipe(Schema.brand("KeyThumbprint"));
+/** The key a credential is bound to, by its thumbprint: RFC 7800's `cnf`, as `{ jkt }`. */
+const KeyBinding = Schema.Struct({ jkt: KeyThumbprint });
+/** Hosts ref0's origin may name over plain HTTP, for development on one machine. */
+const loopback = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+]);
+/**
+* ref0's origin as a proof names it: HTTPS, or plain HTTP only on loopback, for development. A
+* client sends a proof, and ref0 takes one, for no other.
+*/
+const ProofOrigin = ApiOrigin.check(Schema.makeFilter((origin) => {
+	const url = URL.parse(origin);
+	return url?.protocol === "https:" || url?.protocol === "http:" && loopback.has(url.hostname) || "HTTPS, or HTTP on loopback";
+})).pipe(Schema.brand("ProofOrigin"));
+/** The most a proof takes, as its compact JWS, before anything else reads it. */
+const dpopProofMaxBytes = 2048;
+const utf8$1 = new TextEncoder();
+const encodeJson$6 = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown));
+/**
+* An object with exactly `fields`, of at most `maxBytes` as JSON, whatever a decode's options
+* say: an exact `Struct` alone drops a member it doesn't know unless its decode is told to refuse
+* one, so the members are checked on the object as it came, before the struct reads them.
+*/
+const exactly = (fields, maxBytes) => {
+	const names = new Set(Object.keys(fields));
+	return Schema.Record(Schema.String, Schema.Unknown).check(Schema.makeFilter((members) => Object.keys(members).every((name) => names.has(name)) || `only ${[...names].join(", ")}`), Schema.makeFilter((members) => utf8$1.encode(encodeJson$6(members)).byteLength <= maxBytes || `at most ${maxBytes} bytes as JSON`)).pipe(Schema.decodeTo(Schema.Struct(fields), SchemaTransformation.passthroughSupertype()));
+};
+/**
+* A P-256 public key as a JWK: exactly `kty`, `crv`, `x` and `y`, so never a private part, a
+* key reference or another algorithm's key. Whether its point is on the curve is for Web Crypto
+* to say, when it imports it.
+*/
+const PublicJwk = exactly({
+	kty: Schema.Literal("EC"),
+	crv: Schema.Literal("P-256"),
+	x: PublicSigningKey.fields.x,
+	y: PublicSigningKey.fields.y
+}, 512);
+/** A proof's protected header: its type, ES256, and the public key that signed it. */
+const DpopProofHeader = exactly({
+	typ: Schema.Literal("dpop+jwt"),
+	alg: Schema.Literal("ES256"),
+	jwk: PublicJwk
+}, dpopProofMaxBytes);
+/** A proof's `jti`: a fresh UUIDv4 for each proof. Nothing keeps it to refuse a repeat. */
+const DpopProofId = Schema.String.check(Schema.isPattern(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)).pipe(Schema.brand("DpopProofId"));
+/**
+* A proof's claims: its ID; the request's method, and its URL with no query or fragment, as its
+* client sent it, after the URL was built; when it was made, in whole seconds; and, with a token,
+* `ath`, the SHA-256 of the whole token in base64url.
+*/
+const DpopProofClaims = exactly({
+	jti: DpopProofId,
+	htm: Schema.String.check(Schema.isPattern(/^[A-Z]{1,16}$/)),
+	htu: Schema.String.check(Schema.isMaxLength(dpopProofMaxBytes)),
+	iat: Schema.Int.check(Schema.isGreaterThan(0)),
+	ath: Schema.optionalKey(Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)))
+}, dpopProofMaxBytes);
+/**
+* A bound credential came with a proof that's missing, malformed, stale, from another key, or
+* for another request, or came as a bearer token, or a proof came with no `DPoP` credential to
+* go with it. ref0 answers it before any handler runs, so nothing was done. A machine whose clock
+* is off signs again once, by the answer's `Date`. Also what a machine answers itself when the key
+* its credential is bound to is gone, without sending anything.
+*/
+var InvalidDpopProof = class extends Schema.TaggedError()("InvalidDpopProof", {
+	error: Schema.Literal("invalid_dpop_proof"),
+	nextStep: Schema.String
+}, { httpApiStatus: 401 }) {};
+/** The one refusal of a proof, with what to do. */
+const invalidDpopProof = new InvalidDpopProof({
+	error: "invalid_dpop_proof",
+	nextStep: "If this machine’s key was lost, run ref0 connect in your own terminal, then send the next prompt."
+});
+/**
+* The key store a request's proof is signed in didn't sign it: locked, unavailable or out of
+* time. Nothing was sent. A client's own, never an answer of ref0's.
+*/
+var KeyStoreUnavailable = class extends Schema.TaggedError()("KeyStoreUnavailable", { nextStep: Schema.String }) {};
+//#endregion
 //#region ../contracts/src/credential-events.ts
 /**
 * A person's credentials, in that person's own log. Never the token: only its ID, its kind
@@ -672,7 +1037,9 @@ const TokenDelegated = eventKind("token.delegated", Schema.Struct({
 	session: Schema.optionalKey(SessionId),
 	/** The credential this one was made under, when there is one. */
 	parent: Schema.optionalKey(CredentialRef),
-	expiresAt: Schema.optionalKey(Schema.DateTimeUtcFromMillis)
+	expiresAt: Schema.optionalKey(Schema.DateTimeUtcFromMillis),
+	/** The key it's bound to, by its thumbprint, for a host grant made with one. */
+	cnf: Schema.optionalKey(KeyBinding)
 }));
 const TokenRevoked = eventKind("token.revoked", Schema.Struct({
 	credential: CredentialRef,
@@ -1009,6 +1376,11 @@ const CredentialFacts = Schema.Struct({
 		target: Schema.optionalKey(TargetGeneration)
 	}),
 	expiresAt: Schema.optionalKey(Schema.DateTimeUtcFromMillis),
+	/**
+	* The key it's bound to, for a host grant or a session's token made with one: every request
+	* with it must carry a proof that key signed. ref0's own state says it, never a caller.
+	*/
+	cnf: Schema.optionalKey(KeyBinding),
 	/** What it may do, and where. Rows a reader can't decode were left out: they grant nothing. */
 	scopes: Schema.Array(Scope$2),
 	/**
@@ -2754,92 +3126,6 @@ Schema.Struct({ intent: PublishIntentId });
 Schema.Struct({ intent: PublishIntentId });
 Schema.Union([PublishState, Schema.Struct({ none: Schema.Literal(true) })]);
 //#endregion
-//#region ../contracts/src/connections.ts
-/**
-* A connection's name in its project, such as `sentry` or `deploys`: lowercase letters, digits
-* and hyphens, from a letter, as a mention names an outside service. `ref0` names ref0's own, so
-* no connection takes it. Two connections of a project are never named alike at once.
-*/
-const ConnectionName = Schema.String.check(Schema.isPattern(/^[a-z][a-z0-9-]{0,38}$/), Schema.makeFilter((name) => name !== "ref0" || "`ref0` names ref0’s own")).pipe(Schema.brand("ConnectionName"));
-/**
-* What reads a connection's deliveries: `webhook`, whose sender posts ref0's own shape, `{ kind,
-* key, title?, url? }`; or `sentry`, whose sender is Sentry, posting its issue and alert
-* webhooks, which its mapper reads. More kinds come one at a time, each with its mapper.
-*/
-const ConnectionKind = Schema.Literals(["webhook", "sentry"]);
-/** The most characters in a signal's link: a longer one is withheld. */
-const signalLinkLength = 2048;
-/**
-* An ID as a signal holds one: letters, digits and `:` `/` `.` `-` `_`, from a letter or a
-* digit, so it can't carry a space, a quote, an instruction or a command's option.
-*/
-const signalIdPattern = (length) => new RegExp(`^[A-Za-z0-9][A-Za-z0-9:/._-]{0,${length - 1}}$`);
-/** What happened, in the service's own word: `issue.created`, `deploy.finished`. */
-const SignalKind = Schema.String.check(Schema.isPattern(signalIdPattern(64))).pipe(Schema.brand("SignalKind"));
-/** What it's about, so a repeat can be recognised: an issue's ID, a release. */
-const SignalKey = Schema.String.check(Schema.isPattern(signalIdPattern(128))).pipe(Schema.brand("SignalKey"));
-/**
-* Why a signal's title or link wasn't kept: it looked like a secret; a link that isn't `https`;
-* or a link too long to keep whole.
-*/
-const SignalWithheldWhy = Schema.Literals([
-	"looks like a secret",
-	"not an https link",
-	"too long"
-]);
-/** A signal's title or link the connection gave, withheld, and why. */
-const SignalWithheld = Schema.Struct({
-	title: Schema.optionalKey(SignalWithheldWhy),
-	url: Schema.optionalKey(SignalWithheldWhy)
-});
-/**
-* A Sentry organization, by its slug as Sentry's URLs name it: lowercase letters, digits,
-* hyphens and underscores, from a letter or a digit.
-*/
-const SentryOrg = Schema.String.check(Schema.isPattern(/^[a-z0-9][a-z0-9_-]{0,49}$/)).pipe(Schema.brand("SentryOrg"));
-/** Where a Sentry organization's data lives, and so which of Sentry's API hosts answers for it. */
-const SentryRegion = Schema.Literals(["us", "de"]);
-/** A connection added to the project, by the admin whose approval added it. */
-const ConnectionAdded = eventKind("connection.added", Schema.Struct({
-	connection: ConnectionId,
-	name: ConnectionName,
-	kind: ConnectionKind
-}));
-/** A connection's token replaced, by the admin whose approval replaced it: the old one works no more. */
-const ConnectionRotated = eventKind("connection.rotated", Schema.Struct({ connection: ConnectionId }));
-/** A connection removed, by the admin whose approval removed it: its webhook takes nothing more. */
-const ConnectionRemoved = eventKind("connection.removed", Schema.Struct({ connection: ConnectionId }));
-/**
-* A `sentry` connection's credential set, by the admin whose approval set it: the Sentry
-* organization and region it reads, and that ref0 now holds a token for them, which only ref0's
-* server reads, to call Sentry for a workflow. Never the token, nor its hash. Setting it again
-* replaces the one before.
-*/
-const ConnectionCredentialSet = eventKind("connection.credential.set", Schema.Struct({
-	connection: ConnectionId,
-	org: SentryOrg,
-	region: SentryRegion
-}));
-/**
-* A signal, received by a connection: delivered to its webhook, by `ref0:hooks`, or sent with
-* `ref0 signal send` by the person or agent whose token sent it. `at` is when ref0 received it.
-* A title or link that failed its check is withheld, and says why in `withheld`; a title too long
-* is cut, and says so in `titleCut`. `dropped` counts the deliveries the connection dropped since
-* its last signal: over a bound, or refused. A delivery's ID, if the service gave one, is in the
-* envelope's `source` only as the SHA-256 of the connection and that ID.
-*/
-const SignalReceived = eventKind("signal.received", Schema.Struct({
-	connection: ConnectionId,
-	kind: SignalKind,
-	key: SignalKey,
-	title: Schema.optionalKey(TextId),
-	url: Schema.optionalKey(TextId),
-	withheld: Schema.optionalKey(SignalWithheld),
-	titleCut: Schema.optionalKey(Schema.Literal(true)),
-	dropped: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
-	at: Schema.DateTimeUtcFromMillis
-}));
-//#endregion
 //#region ../contracts/src/date-time.ts
 /** A UTC date decoded from a string and encoded in ISO format. */
 const Timestamp = Schema.DateTimeUtcFromString;
@@ -5371,8 +5657,26 @@ Schema.Union([
 	NotPermitted,
 	DeliveryOutsideWindow
 ]);
+/**
+* Where a session is, as a fork's URL names it: its owner, project, thread and numbers. With its
+* project's visibility, which a session's routes read who sees the project by.
+*/
+const SessionPlace = Schema.Struct({
+	owner: OwnerId,
+	project: ProjectId,
+	visibility: Visibility,
+	thread: ThreadId,
+	threadNumber: ThreadNumber,
+	session: SessionId,
+	number: SessionNumber,
+	/** Whether it's still going: not ended, and its lease not run out. */
+	live: Schema.Boolean
+});
 Schema.Struct({ session: SessionId });
-Schema.Struct({ live: Schema.Boolean });
+Schema.Union([Schema.Struct({
+	live: Schema.Literal(true),
+	place: SessionPlace
+}), Schema.Struct({ live: Schema.Literal(false) })]);
 Schema.Struct({
 	...commandFields,
 	project: ProjectId,
@@ -6379,8 +6683,8 @@ var ApprovalStale = class extends Schema.TaggedError()("ApprovalStale", { nextSt
 var PreviewNotReady = class extends Schema.TaggedError()("PreviewNotReady", { nextStep: Schema.String }, { httpApiStatus: 503 }) {};
 //#endregion
 //#region ../contracts/src/passkeys.ts
-const Base64Url = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]*$/));
-Schema.Struct({ challenge: Base64Url.check(Schema.isMinLength(1)) });
+const Base64Url$1 = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]*$/));
+Schema.Struct({ challenge: Base64Url$1.check(Schema.isMinLength(1)) });
 /** How a browser reaches a passkey's authenticator, as WebAuthn names it. */
 const PasskeyTransport = Schema.Literals([
 	"ble",
@@ -6392,7 +6696,7 @@ const PasskeyTransport = Schema.Literals([
 	"usb"
 ]);
 const CredentialDescriptor = Schema.Struct({
-	id: Base64Url,
+	id: Base64Url$1,
 	type: Schema.Literal("public-key"),
 	transports: Schema.optionalKey(Schema.Array(PasskeyTransport))
 });
@@ -6403,11 +6707,11 @@ const PasskeyCreationOptions = Schema.Struct({
 		name: Schema.String
 	}),
 	user: Schema.Struct({
-		id: Base64Url,
+		id: Base64Url$1,
 		name: Schema.String,
 		displayName: Schema.String
 	}),
-	challenge: Base64Url,
+	challenge: Base64Url$1,
 	pubKeyCredParams: Schema.Array(Schema.Struct({
 		type: Schema.Literal("public-key"),
 		alg: Schema.Int
@@ -6446,23 +6750,23 @@ const PasskeyCreationOptions = Schema.Struct({
 * as its WebAuthn library leaves it.
 */
 const PasskeyCreated = Schema.Struct({
-	id: Base64Url,
-	rawId: Base64Url,
+	id: Base64Url$1,
+	rawId: Base64Url$1,
 	type: Schema.Literal("public-key"),
 	response: Schema.Struct({
-		clientDataJSON: Base64Url,
-		attestationObject: Base64Url,
-		authenticatorData: Schema.optional(Base64Url),
+		clientDataJSON: Base64Url$1,
+		attestationObject: Base64Url$1,
+		authenticatorData: Schema.optional(Base64Url$1),
 		transports: Schema.optional(Schema.Array(PasskeyTransport)),
 		publicKeyAlgorithm: Schema.optional(Schema.Int),
-		publicKey: Schema.optional(Base64Url)
+		publicKey: Schema.optional(Base64Url$1)
 	}),
 	authenticatorAttachment: Schema.optional(Schema.Literals(["platform", "cross-platform"])),
 	clientExtensionResults: Schema.Struct({ credProps: Schema.optionalKey(Schema.Struct({ rk: Schema.optionalKey(Schema.Boolean) })) })
 });
 /** What ref0 hands a browser to answer with a passkey: WebAuthn's request options, as JSON. */
 const PasskeyRequestOptions = Schema.Struct({
-	challenge: Base64Url,
+	challenge: Base64Url$1,
 	timeout: Schema.optionalKey(Schema.Int),
 	rpId: Schema.optionalKey(Schema.String),
 	allowCredentials: Schema.optionalKey(Schema.Array(CredentialDescriptor)),
@@ -6482,14 +6786,14 @@ const PasskeyRequestOptions = Schema.Struct({
 * as JSON. A field the browser doesn't have may be missing, or there as `undefined`.
 */
 const PasskeyAsserted = Schema.Struct({
-	id: Base64Url,
-	rawId: Base64Url,
+	id: Base64Url$1,
+	rawId: Base64Url$1,
 	type: Schema.Literal("public-key"),
 	response: Schema.Struct({
-		clientDataJSON: Base64Url,
-		authenticatorData: Base64Url,
-		signature: Base64Url,
-		userHandle: Schema.optional(Base64Url)
+		clientDataJSON: Base64Url$1,
+		authenticatorData: Base64Url$1,
+		signature: Base64Url$1,
+		userHandle: Schema.optional(Base64Url$1)
 	}),
 	authenticatorAttachment: Schema.optional(Schema.Literals(["platform", "cross-platform"])),
 	clientExtensionResults: Schema.Struct({})
@@ -6543,10 +6847,15 @@ const RequestFolder = Schema.Struct({
 	secretHash: SecretHash,
 	replaces: Schema.optionalKey(TokenId)
 });
-/** One to eight config folders, each with its own grant secret. */
+/**
+* One to eight config folders, each with its own grant secret, and the machine key its grants are
+* bound to: its public half, which a proof that key signed comes with. A request without one makes
+* grants bound to no key, as an older ref0 asks, until binding is required.
+*/
 const RequestAttachment = Schema.Struct({
 	machine: MachineId,
 	machineName: MachineName,
+	publicKey: Schema.optionalKey(PublicJwk),
 	folders: Schema.Array(RequestFolder).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths),
 	collectHash: SecretHash,
 	linkHash: SecretHash,
@@ -6660,12 +6969,15 @@ const RequestOrganization = Schema.Struct({
 /**
 * The result collected with the machine's two proofs: each included folder's identity and grant,
 * its agent's owner name and organizations, and excluded paths. Confirmation checks each saved
-* grant's live deadline in the Owner DO.
+* grant's live deadline in the Owner DO. Once a yes connected and the machine hasn't sent its
+* answer code, waiting says until when: `confirmBy`, when ref0 revokes each grant the machine
+* hasn't confirmed.
 */
 const RequestState = Schema.Union([
 	Schema.Struct({
 		state: Schema.Literal("waiting"),
-		expiresAt: Timestamp
+		expiresAt: Timestamp,
+		confirmBy: Schema.optionalKey(Timestamp)
 	}),
 	Schema.Struct({
 		state: Schema.Literal("connected"),
@@ -6737,6 +7049,7 @@ Schema.Struct({
 	request: ApprovalId,
 	machine: MachineId,
 	machineName: MachineName,
+	cnf: Schema.optionalKey(KeyBinding),
 	browserSession: TokenId,
 	personGeneration: Generation,
 	folders: Schema.Array(ConnectFolderCommand).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths),
@@ -10342,45 +10655,6 @@ Schema.Union([Schema.Struct({
 	found: Schema.Literal(true),
 	thread: ThreadId
 }), Schema.Struct({ found: Schema.Literal(false) })]);
-/**
-* ref0's one origin, as a client is given it: `http` or `https`, a host and maybe a port, and no
-* credentials, path, query or fragment. That pattern alone lets through a host or port no URL has,
-* such as `https://1.2.3.999`, `https://[1::2::3]` or `https://ref0.test:99999`, so the platform's own URL parser must take
-* it too. It's kept as written, case and any default port too: every path here is appended to it
-* as it is.
-*/
-const ApiOrigin = Schema.String.check(Schema.isPattern(/^https?:\/\/(?:\[[0-9A-Fa-f:.]+\]|[^\s/?#\\@:[\]]+)(?::\d+)?$/), Schema.makeFilter((origin) => URL.canParse(origin) || "a URL the platform can parse")).pipe(Schema.brand("ApiOrigin"));
-/** Where signing in's own routes live, which Better Auth serves, outside `Api`. */
-const signInBase = "/auth";
-/**
-* A route under `signInBase`, by its method: its `path` from the origin's root, as a request
-* names it, and its `pathUnderBase`, as Better Auth names its endpoints.
-*/
-const signInRoute = (method, pathUnderBase) => ({
-	method,
-	pathUnderBase,
-	path: `${signInBase}${pathUnderBase}`
-});
-/** Signing in with GitHub, from ref0's pages: starting it, GitHub's way back, and signing out. */
-const signInRoutes = {
-	gitHubSignIn: signInRoute("POST", "/sign-in/social"),
-	gitHubCallback: signInRoute("GET", "/callback/github"),
-	signOut: signInRoute("POST", "/sign-out")
-};
-/**
-* The OAuth server outside MCP clients use (layer 4, PR 11a): its metadata, authorizing, the
-* token endpoint, registering a public client and revoking a token.
-*/
-const oauthRoutes = {
-	metadata: signInRoute("GET", "/.well-known/oauth-authorization-server"),
-	authorize: signInRoute("GET", "/oauth2/authorize"),
-	token: signInRoute("POST", "/oauth2/token"),
-	register: signInRoute("POST", "/oauth2/register"),
-	revoke: signInRoute("POST", "/oauth2/revoke")
-};
-signInRoute("POST", "/oauth2/consent");
-[...Object.values(signInRoutes), ...Object.values(oauthRoutes)];
-`${oauthRoutes.metadata.pathUnderBase}`;
 //#endregion
 //#region ../contracts/src/live-calls.ts
 /**
@@ -11029,22 +11303,75 @@ const TurnTokens = Schema.Union([Schema.Struct({
 	known: Schema.Literal("read"),
 	models: Schema.Array(ModelTokens).check(Schema.isMaxLength(16), Schema.makeFilter((models) => new Set(models.map((each) => each.model)).size === models.length || "each model once"))
 }), Schema.Struct({ known: Schema.Literal("unknown") })]);
+const Name = Schema.String.check(Schema.isBetweenLength(1, 128));
+const Millis = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+/**
+* How long a turn's tool calls ran, summed, and its longest call, by tool: Claude Code's own
+* `duration_ms` for each, and, for Codex, whose hooks say none, from its `PreToolUse` to its
+* `PostToolUse` by `ref0 mcp`'s clock. Only calls that ended count: one with no end, as one a
+* `PreToolUse` answer denied or a Codex call cut short, isn't in it. `unknown`, never zero, when a
+* call that ended can't be timed, as one whose end says no time and whose start wasn't seen.
+*/
+const ToolTime = Schema.Union([Schema.Struct({
+	known: Schema.Literal("timed"),
+	totalMs: Millis,
+	/** None when the turn called no tool. */
+	longest: Schema.optionalKey(Schema.Struct({
+		tool: Name,
+		ms: Millis
+	}))
+}), Schema.Struct({ known: Schema.Literal("unknown") })]);
 /**
-* A turn's facts but its tokens, which `TurnFacts` adds for whoever sends them and `turn.ended`
-* carries only to those who may see them.
+* A compaction of the session's context during a turn: whether it was `auto` or `manual`, where
+* the harness says, as Claude Code does and Codex doesn't, and how long after ref0 started the
+* turn it happened, by the harness's own transcript, where both are known.
+*/
+const Compaction = Schema.Struct({
+	trigger: Schema.optionalKey(Schema.Literals(["auto", "manual"])),
+	afterMs: Schema.optionalKey(Millis)
+});
+/**
+* A turn's context, read from the session's own transcript as its tokens are: `peak`, the most
+* one request of the session's own sent, its cached tokens included, none for a turn with no
+* request, and each compaction. `unknown`, with neither, where the transcript wasn't read whole.
+* A subagent's context is its own, and isn't in it.
+*/
+const TurnContext = Schema.Union([Schema.Struct({
+	known: Schema.Literal("read"),
+	peak: Schema.optionalKey(TokenCount),
+	compactions: Schema.Array(Compaction).check(Schema.isMaxLength(100))
+}), Schema.Struct({ known: Schema.Literal("unknown") })]);
+/**
+* One of the harness's own subagents that a turn ran, such as Claude Code's Task agents or
+* Codex's: its type, where the harness names one, and its own tokens, which the turn's tokens
+* already include, so the turn's less its subagents' are the session's own. Its tokens, and the
+* turn's, are `unknown` when the harness kept no transcript of it. Not a child session: ref0
+* knows it only from its `SubagentStop` and its transcript.
+*/
+const TurnSubagent = Schema.Struct({
+	type: Schema.optionalKey(Name),
+	tokens: TurnTokens
+});
+/**
+* A turn's facts but its tokens and its subagents', which `TurnFacts` adds for whoever sends them
+* and `turn.ended` carries only to those who may see them.
 */
 const turnFactsFields = {
 	/** The turn's model, where the harness said it: Codex in every hook. */
-	model: Schema.optionalKey(Schema.String.check(Schema.isBetweenLength(1, 128))),
+	model: Schema.optionalKey(Name),
 	modelSource: ModelSource,
 	/** Tool calls by tool name. */
-	tools: Schema.Record(Schema.String.check(Schema.isBetweenLength(1, 128)), Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).check(Schema.makeFilter((tools) => Object.keys(tools).length <= 100 || "at most 100 tools")),
+	tools: Schema.Record(Name, Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))).check(Schema.makeFilter((tools) => Object.keys(tools).length <= 100 || "at most 100 tools")),
 	/** The files its edits touched, by repo and path, at most 50; `more` counts the rest. */
 	addresses: Schema.Array(Schema.Struct({
 		repo: RepoName,
 		path: RepoPath
 	})).check(Schema.isMaxLength(50)),
-	more: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+	more: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+	toolTime: ToolTime,
+	context: TurnContext,
+	/** How many subagents past the first 100 the turn ran. */
+	moreSubagents: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
 };
 /**
 * What `ref0 mcp` saw of a turn, sent at its `Stop`s and when the next one starts, and again as
@@ -11056,16 +11383,23 @@ const turnFactsFields = {
 const TurnFacts = Schema.Struct({
 	...turnFactsFields,
 	tokens: TurnTokens,
-	stoppedAfterMs: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)))
+	/** The turn's subagents, in the order their transcripts were first read, at most 100. */
+	subagents: Schema.Array(TurnSubagent).check(Schema.isMaxLength(100)),
+	stoppedAfterMs: Schema.optionalKey(Millis)
 });
 /**
-* A turn's facts as `turn.ended` shows them: its tokens only to an admin of the project's owner
-* and to the session's accountable person. A thread's totals still go to every reader of it, in
-* `ThreadUsage`, so on a thread with one person's sessions they are that person's usage.
+* A turn's facts as `turn.ended` shows them: its tokens and its subagents' only to an admin of
+* the project's owner and to the session's accountable person. A thread's totals still go to
+* every reader of it, in `ThreadUsage`, so on a thread with one person's sessions they are that
+* person's usage.
 */
 const EndedTurnFacts = Schema.Struct({
 	...turnFactsFields,
-	tokens: Schema.optionalKey(TurnTokens)
+	tokens: Schema.optionalKey(TurnTokens),
+	subagents: Schema.Array(Schema.Struct({
+		type: TurnSubagent.fields.type,
+		tokens: Schema.optionalKey(TurnTokens)
+	})).check(Schema.isMaxLength(100))
 });
 /**
 * `POST /v1/sessions/{session}/turns`: a new turn, for the harness's own turn ID, so a retry, or
@@ -11693,151 +12027,6 @@ Schema.Struct({
 		name: RepoName
 	}))
 });
-/** Where an agent's session asks for an identity token. */
-const identityTokenPath = "/v1/me/identity-token";
-/** One DNS label, or one part of an IPv4 address: letters, digits and inner hyphens. */
-const label = "[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?";
-/** `https://`, a host name, then maybe `:` and a port with no leading zero. */
-const audiencePattern = new RegExp(`^https://(${label}(?:\\.${label})*)(?::([1-9][0-9]{0,4}))?$`);
-/**
-* Whether the platform's URL parser reads the audience as written: an `https` URL whose host is
-* the audience's own, lowercased, and whose port is its own, or none for 443. That refuses a host
-* the parser rewrites, such as `https://1.2.3` read as `1.2.0.3`, and a port past 65535.
-*/
-const parsesAsWritten = (audience) => {
-	const parts = audiencePattern.exec(audience);
-	if (parts === null || !URL.canParse(audience)) return false;
-	const url = new URL(audience);
-	const port = parts[2] ?? "";
-	return url.protocol === "https:" && url.hostname === (parts[1] ?? "").toLowerCase() && url.port === (port === "443" ? "" : port);
-};
-/**
-* Who an identity token is for: an outside service's HTTPS origin, in ASCII, at most 255 bytes,
-* with no credentials, path, query, fragment, wildcard or space. It's kept exactly as asked, its
-* case and any port too, so `https://verifier.example:443` is another audience than
-* `https://verifier.example`. ref0 never fetches or resolves it.
-*/
-const IdentityAudience = Schema.String.check(Schema.isMaxLength(255), Schema.isPattern(audiencePattern), Schema.makeFilter((audience) => parsesAsWritten(audience) || "an origin the platform reads as written")).pipe(Schema.brand("IdentityAudience"));
-/** `POST /v1/me/identity-token`'s body: the one audience, and nothing else. */
-const IdentityTokenRequest = Schema.Struct({ audience: IdentityAudience });
-/** A compact JWT: its header, payload and signature, each in base64url, at most 4 KiB. */
-const IdentityToken = Schema.String.check(Schema.isMaxLength(4096), Schema.isPattern(/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/)).pipe(Schema.brand("IdentityToken"));
-/** What asking for an identity token answers: the token, and when it expires, its `exp`. */
-const IssuedIdentityToken = Schema.Struct({
-	token: IdentityToken,
-	expiresAt: Schema.DateTimeUtcFromMillis
-});
-/**
-* An identity token's `jti`: a fresh UUIDv4 from the platform's cryptographic source for each
-* token, naming its issuance in ref0's log without naming any row or secret.
-*/
-const IdentityTokenId = Schema.String.check(Schema.isPattern(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/)).pipe(Schema.brand("IdentityTokenId"));
-/**
-* A person, as one audience knows them: `pperson_`, then the first 128 bits of an HMAC of the
-* person's ref0 ID for the token's issuer and audience, as a TypeID suffix. Stable at one
-* audience, different at every other, and carrying no time.
-*/
-const PairwisePersonId = TypeId("pperson").pipe(Schema.brand("PairwisePersonId"));
-/** A session, as one audience knows it, made as a person's is. */
-const PairwiseSessionId = TypeId("psession").pipe(Schema.brand("PairwiseSessionId"));
-/** The accountable person, last in a token's chain: only their pairwise ID. */
-const PersonActor = Schema.Struct({ sub: PairwisePersonId });
-/** A session in a token's chain, then whoever it acts for: its parent session, or the person. */
-const sessionActing = (act) => Schema.Struct({
-	sub: PairwiseSessionId,
-	act
-});
-const oneSession = sessionActing(PersonActor);
-const twoSessions = sessionActing(oneSession);
-const threeSessions = sessionActing(twoSessions);
-/**
-* A token's `act`, as RFC 8693 nests it: the current session, then up to three parent sessions,
-* then the accountable person, each by its pairwise ID. It's history, not authority: a verifier
-* allows the agent in `sub`, never an actor.
-*/
-const IdentityActor = Schema.Union([
-	oneSession,
-	twoSessions,
-	threeSessions,
-	sessionActing(threeSessions)
-]);
-/** A time in a token, in whole UTC epoch seconds. */
-const EpochSeconds = Schema.Int.check(Schema.isGreaterThan(0));
-Schema.Struct({
-	iss: ApiOrigin,
-	sub: AgentId,
-	aud: IdentityAudience,
-	iat: EpochSeconds,
-	exp: EpochSeconds,
-	jti: IdentityTokenId,
-	act: IdentityActor
-}).check(Schema.makeFilter(({ iat, exp }) => exp > iat && exp - iat <= 600 || `an expiry after its issue, at most 600 seconds later`));
-/**
-* A signing key's ID, its `kid`: the key's RFC 7638 thumbprint, SHA-256 in base64url, so one ID
-* never names two keys.
-*/
-const SigningKeyId = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/)).pipe(Schema.brand("SigningKeyId"));
-Schema.Struct({
-	alg: Schema.Literal("ES256"),
-	kid: SigningKeyId,
-	typ: Schema.Literal("JWT")
-});
-/** A P-256 coordinate: 32 bytes in base64url, unpadded, in its one canonical spelling. */
-const Coordinate = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/));
-/** One public key in the JWKS: exactly these fields, and never a private one. */
-const PublicSigningKey = Schema.Struct({
-	kty: Schema.Literal("EC"),
-	crv: Schema.Literal("P-256"),
-	x: Coordinate,
-	y: Coordinate,
-	use: Schema.Literal("sig"),
-	alg: Schema.Literal("ES256"),
-	kid: SigningKeyId
-});
-Schema.Struct({ keys: Schema.Array(PublicSigningKey).check(Schema.isMaxLength(3)) });
-Schema.Struct({
-	issuer: ApiOrigin,
-	jwks_uri: Schema.String,
-	subject_types_supported: Schema.Tuple([Schema.Literal("public")]),
-	id_token_signing_alg_values_supported: Schema.Tuple([Schema.Literal("ES256")]),
-	claims_supported: Schema.Tuple([
-		Schema.Literal("iss"),
-		Schema.Literal("sub"),
-		Schema.Literal("aud"),
-		Schema.Literal("exp"),
-		Schema.Literal("iat"),
-		Schema.Literal("jti"),
-		Schema.Literal("act")
-	])
-});
-/**
-* The audience isn't one ref0 signs for: missing, given twice, or not an HTTPS origin as
-* `IdentityAudience` says. The refused text is never echoed.
-*/
-var IdentityAudienceRefused = class extends Schema.TaggedError()("IdentityAudienceRefused", { nextStep: Schema.String }, { httpApiStatus: 400 }) {};
-/**
-* Less than a whole second is left before the session, a parent or the credential expires, or
-* the token would expire before it's recorded: the next prompt renews or replaces the session.
-*/
-var IdentityTokenNotReady = class extends Schema.TaggedError()("IdentityTokenNotReady", { nextStep: Schema.String }, { httpApiStatus: 409 }) {};
-/**
-* ref0 signed an identity token for one of a project's sessions: in that project's log, on the
-* session's thread, with ref0's own IDs for the session, its agent and its accountable person,
-* and the token's `jti`, never the token. It proves ref0 made the token, not that any service
-* received or used it. A failed append discards the token, so every token has its event.
-*/
-const IdentityTokenIssued = eventKind("identity_token.issued", Schema.Struct({
-	session: SessionId,
-	agent: AgentRef,
-	/** The person whose attachment authorized the session's chain, last in the token's `act`. */
-	accountable: PersonId,
-	jti: IdentityTokenId,
-	audience: IdentityAudience,
-	issuer: ApiOrigin,
-	keyId: SigningKeyId,
-	issuedAt: Schema.DateTimeUtcFromMillis,
-	expiresAt: Schema.DateTimeUtcFromMillis
-}));
 Schema.Literals([
 	"info/refs",
 	"git-upload-pack",
@@ -11865,6 +12054,11 @@ Schema.Union([
 Schema.Struct({
 	reader: Reader,
 	name: RepoName,
+	/**
+	* For a fork's path, the scope it names: a project, by its ID or its name, or, with none, the
+	* owner's own scope, which holds an organization's org threads.
+	*/
+	scope: Schema.optionalKey(Schema.Struct({ project: Schema.optionalKey(ProjectRef) })),
 	push: Schema.optionalKey(Schema.Struct({
 		thread: ThreadId,
 		session: SessionId
@@ -11878,7 +12072,9 @@ const GitTarget = Schema.Struct({
 	* their sessions' forks, and the repo's `main`. Unset for one that reads the repo's project as
 	* a whole.
 	*/
-	threads: Schema.optionalKey(Schema.Array(ThreadId))
+	threads: Schema.optionalKey(Schema.Array(ThreadId)),
+	/** For a fork's path, the project its scope resolved to: a project's, or the owner's own. */
+	scope: Schema.optionalKey(ProjectId)
 });
 Schema.Union([GitTarget, RepoNotFound]);
 /** A repo whose baseline isn't readable yet: Git is told to try again in a few seconds. */
@@ -11889,28 +12085,6 @@ const CurrentBaseline = Schema.Struct({
 	name: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/))
 });
 Schema.Union([CurrentBaseline, RepoNotReady]);
-//#endregion
-//#region ../contracts/src/fork-calls.ts
-/**
-* A session's fork of a repo: its own copy, made in the background from the repo's current
-* baseline when the session first reaches the repo. Agents push only to their own session's
-* forks. A fork isn't deleted yet: when it may be, and what's saved first, waits for the user.
-*/
-/**
-* Where a session is, as a fork's URL names it: its owner, project, thread and numbers. With its
-* project's visibility, which a session's routes read who sees the project by.
-*/
-const SessionPlace = Schema.Struct({
-	owner: OwnerId,
-	project: ProjectId,
-	visibility: Visibility,
-	thread: ThreadId,
-	threadNumber: ThreadNumber,
-	session: SessionId,
-	number: SessionNumber,
-	/** Whether it's still going: not ended, and its lease not run out. */
-	live: Schema.Boolean
-});
 Schema.Struct({ session: SessionId });
 Schema.Union([SessionPlace, SessionNotFound]);
 Schema.Struct({
@@ -15211,17 +15385,21 @@ const browserSession = HttpApiSecurity.apiKey({
 	key: browserSessionCookie
 });
 /**
-* Every endpoint's credential, checked before its handler runs: a bearer token, or a browser
-* session's cookie. A request with both is refused before it gets here.
+* Every endpoint's credential, checked before its handler runs: a bearer token, a token bound to
+* a key with a proof that key signed (`Authorization: DPoP` and one `DPoP` header), or a browser
+* session's cookie. A request with a cookie and a token is refused before it gets here. A client
+* that signs proofs may fail before it sends anything, when its key store doesn't sign.
 */
 var Authorization = class extends HttpApiMiddleware.Service()("ref0/contracts/Authorization", {
 	requiredForClient: true,
 	security: {
 		bearer: HttpApiSecurity.bearer,
+		dpop: HttpApiSecurity.http({ scheme: "DPoP" }),
 		browserSession
 	},
 	error: [
 		Unauthenticated,
+		InvalidDpopProof,
 		SessionHasEnded,
 		AuthorityUnavailable
 	]
@@ -15252,6 +15430,18 @@ var ApprovalSecret = class extends HttpApiMiddleware.Service()("ref0/contracts/A
 * what to change. Any other part that fails its contract is answered with Effect's empty 400.
 */
 var MachineNameRefusal = class extends HttpApiMiddleware.Service()("ref0/contracts/MachineNameRefusal", { error: CommandRefused }) {};
+Context.Service()("ref0/contracts/ProvedKey");
+/**
+* A request with no credential, signed by a key it names, such as a machine's ask to connect: one
+* `DPoP` header, a proof with no `ath`, since there's no token, checked before the request is
+* read, which says the key that signed it; or no proof, which says none. Every client supplies
+* it, as it does `Authorization`, so its key store's failure, before anything is sent, is typed:
+* one with a key store signs, and every other sends no proof.
+*/
+var KeyProof = class extends HttpApiMiddleware.Service()("ref0/contracts/KeyProof", {
+	requiredForClient: true,
+	error: InvalidDpopProof
+}) {};
 /**
 * An identity token's request whose audience its contract refuses, missing or not an HTTPS
 * origin, answered as `IdentityAudienceRefused`, which never echoes what was sent.
@@ -15367,8 +15557,9 @@ var AttachmentsGroup = class extends HttpApiGroup.make("attachments").add(HttpAp
 })).middleware(Authorization) {};
 /**
 * Connecting a machine, the machine's side: asking, with no credential, to connect to one owner's
-* agent, whose terminal shows the code their person types; then collecting what came of it,
-* confirming it saved the grant, or aborting, with its collecting secret.
+* agent, whose terminal shows the code their person types, signed by the machine key it names;
+* then collecting what came of it, confirming it saved the grant, or aborting, with its collecting
+* secret, which needs no proof: a grant it collects is bound to the key its ask named.
 */
 var MachineAttachmentsGroup = class extends HttpApiGroup.make("machineAttachments").add(HttpApiEndpoint.post("request", "/v1/attachments/requests", {
 	headers: idempotency,
@@ -15378,9 +15569,10 @@ var MachineAttachmentsGroup = class extends HttpApiGroup.make("machineAttachment
 		NotPermitted,
 		CommandRefused,
 		SlowDown,
+		InvalidDpopProof,
 		AuthorityUnavailable
 	]
-}).middleware(MachineNameRefusal), HttpApiEndpoint.post("collect", "/v1/attachments/requests/:approval/result", {
+}).middleware(MachineNameRefusal).middleware(KeyProof), HttpApiEndpoint.post("collect", "/v1/attachments/requests/:approval/result", {
 	params: { approval: ApprovalId },
 	payload: Schema.Struct({ answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64))) }),
 	success: RequestState,
@@ -18854,6 +19046,8 @@ const HookArguments = Schema.Struct({
 	tool_input: ToolValue,
 	tool_response: ToolValue,
 	error: Field,
+	/** How long the tool ran, in milliseconds, at Claude Code's `PostToolUse` and its failure. */
+	duration_ms: Field,
 	/** A string from Claude Code, a boolean from Codex, which keeps a placeholder's JSON type. */
 	stop_hook_active: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.String])),
 	/** Codex names the turn's model in every hook but `SessionEnd`. */
@@ -18998,12 +19192,129 @@ const projectPage = (page, project) => page.replace("/$owner/$project", `/${proj
 * credential it sends, a bearer token or a browser session.
 */
 const ref0Client = (origin) => HttpApiClient.make(Api, origin === void 0 ? {} : { baseUrl: origin });
+/** No proof of a key for a request that asks for one: a client with no key store's. */
+const noKeyProof = HttpApiMiddleware.layerClient(KeyProof, ({ request, next }) => next(request));
 /** A bearer token: an agent's credential, sent with every request. */
-const bearerCredential = (token) => Layer.mergeAll(HttpApiMiddleware.layerClient(Authorization, ({ request, next }) => next(HttpClientRequest.bearerToken(request, token))), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)));
+const bearerCredential = (token) => Layer.mergeAll(HttpApiMiddleware.layerClient(Authorization, ({ request, next }) => next(HttpClientRequest.bearerToken(request, token))), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)), noKeyProof);
 /** No credential: a terminal asking its person, which sends nothing of theirs. */
-const anonymousCredential = Layer.mergeAll(HttpApiMiddleware.layerClient(Authorization, ({ request, next }) => next(request)), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)));
+const anonymousCredential = Layer.mergeAll(HttpApiMiddleware.layerClient(Authorization, ({ request, next }) => next(request)), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)), noKeyProof);
 FetchHttpClient.layer;
 //#endregion
+//#region ../sdk/src/client/proofs.ts
+/**
+* How far ref0's clock is ahead of this machine's, in milliseconds, as the `Date` of a refused
+* proof's answer said: provided once for a process, so every proof it signs after is dated by it.
+*/
+var ProofClock = class ProofClock extends Context.Service()("ref0/sdk/ProofClock") {
+	static layer = Layer.effect(ProofClock, Effect.map(Ref.make(0), (offset) => ProofClock.of({ offset })));
+};
+/** How far apart the two clocks may be before a refused proof is signed again by ref0's. */
+const clockSkewMillis = 5e3;
+const encodeHeader = Schema.encodeSync(Schema.fromJsonString(DpopProofHeader));
+const encodeClaims = Schema.encodeSync(Schema.fromJsonString(DpopProofClaims));
+const decodeProofId = Schema.decodeSync(DpopProofId);
+const utf8 = new TextEncoder();
+/** A fresh UUIDv4 from the platform's cryptographic source, a proof's `jti`. */
+const freshProofId = Effect.sync(() => {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	bytes[6] = 64 | (bytes[6] ?? 0) & 15;
+	bytes[8] = 128 | (bytes[8] ?? 0) & 63;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return decodeProofId(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);
+});
+const decodeThumbprint = Schema.decodeSync(KeyThumbprint);
+/**
+* RFC 7638's thumbprint of a P-256 public key: the SHA-256 of its required members, in order, as
+* JSON, in base64url. What a credential bound to the key names it by, as `cnf.jkt`.
+*/
+const keyThumbprint = (jwk) => Effect.promise(async () => decodeThumbprint(Base64Url.encode(new Uint8Array(await crypto.subtle.digest("SHA-256", utf8.encode(`{"crv":"P-256","kty":"EC","x":"${jwk.x}","y":"${jwk.y}"}`))))));
+/** `ath`: the SHA-256 of the whole token, in base64url. */
+const tokenHashOf = (token) => Effect.promise(async () => Base64Url.encode(new Uint8Array(await crypto.subtle.digest("SHA-256", utf8.encode(token)))));
+/**
+* A proof for one attempt at a request: its method, and its URL as built, with no query or
+* fragment; dated by this machine's clock, moved by `offset`; with the token's hash, if it's sent
+* with one; signed by the store.
+*/
+const proofFor = Effect.fnUntraced(function* (store, attempt, offset) {
+	const now = (yield* Clock.currentTimeMillis) + offset;
+	const header = encodeHeader({
+		typ: "dpop+jwt",
+		alg: "ES256",
+		jwk: store.publicKey
+	});
+	const signs = {
+		jti: yield* freshProofId,
+		htm: attempt.method,
+		htu: `${attempt.url.origin}${attempt.url.pathname}`,
+		iat: Math.floor(now / 1e3)
+	};
+	if (attempt.token !== void 0) signs.ath = yield* tokenHashOf(attempt.token);
+	const claims = encodeClaims(signs);
+	const signed = `${Base64Url.encode(header)}.${Base64Url.encode(claims)}`;
+	const signature = yield* store.sign(utf8.encode(signed));
+	if (signature.byteLength !== 64) return yield* Effect.die("a key store answers r||s, 64 bytes");
+	return `${signed}.${Base64Url.encode(signature)}`;
+});
+/**
+* How far ref0's clock was from this machine's, moved by `offset`, by a refused proof's answer:
+* none for any other answer, or one without a `Date`.
+*/
+const skewOf = (response, local) => {
+	const challenge = response.headers["www-authenticate"] ?? "";
+	if (response.status !== 401 || !challenge.includes("DPoP error=\"invalid_dpop_proof\"")) return Option.none();
+	return Option.map(DateTime.make(response.headers["date"] ?? ""), (date) => DateTime.toEpochMillis(date) - local);
+};
+/**
+* Sends one request, with its credential if it has one, signing each attempt afresh: once, and
+* once more, by ref0's clock, after a refused proof whose answer is dated more than five seconds
+* from this machine's. The process keeps the offset for every proof after.
+*/
+const signedAttempts = (credential, offsetRef) => ({ request, next }) => Effect.gen(function* () {
+	const token = credential.token === void 0 ? void 0 : Redacted.value(credential.token);
+	const attempt = {
+		method: request.method,
+		url: new URL(`${credential.origin}${request.url}`),
+		token
+	};
+	const redacted = [...yield* Effect.service(Headers.CurrentRedactedNames), "dpop"];
+	const send = (offset) => proofFor(credential.store, attempt, offset).pipe(Effect.map((proof) => HttpClientRequest.setHeaders(request, token === void 0 ? { dpop: proof } : {
+		authorization: `DPoP ${token}`,
+		dpop: proof
+	})), Effect.flatMap(next), Effect.provideService(Headers.CurrentRedactedNames, redacted));
+	const offset = yield* Ref.get(offsetRef);
+	const answer = yield* send(offset);
+	const skew = skewOf(answer, (yield* Clock.currentTimeMillis) + offset);
+	if (Option.isNone(skew) || Math.abs(skew.value) <= clockSkewMillis) return answer;
+	yield* Effect.ignore(answer.text);
+	yield* Ref.set(offsetRef, offset + skew.value);
+	return yield* send(offset + skew.value);
+});
+/**
+* A token bound to a key, sent as `Authorization: DPoP` with a proof its key store signs afresh
+* for each attempt. Signing in's own endpoints take no token.
+*/
+const dpopCredential = (credential) => Layer.mergeAll(HttpApiMiddleware.layerClient(Authorization, Effect.map(Effect.service(ProofClock), (clock) => signedAttempts(credential, clock.offset))), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)), noKeyProof);
+/**
+* ref0's `/v1` as a typed client at a bound credential's origin, sending its token with a proof
+* its key store signs for each attempt. The client is made at the origin its proofs name, so
+* neither the token nor a proof is sent anywhere else. It needs the process's `ProofClock`. A
+* request's trace redacts its proof, but an error it fails with still holds the request: a
+* program that logs errors adds `dpop` to `Headers.CurrentRedactedNames` at its root.
+*/
+const boundClient = (credential) => ref0Client(credential.origin).pipe(Effect.provide(dpopCredential(credential)));
+/**
+* A request with no credential, signed by the key it names, such as a machine's ask to connect:
+* a proof its key store signs for each attempt, with no `ath`, since there's no token. Any other
+* request is sent with nothing added.
+*/
+const keyProof = (signer) => Layer.mergeAll(HttpApiMiddleware.layerClient(KeyProof, Effect.map(Effect.service(ProofClock), (clock) => signedAttempts(signer, clock.offset))), HttpApiMiddleware.layerClient(Authorization, ({ request, next }) => next(request)), HttpApiMiddleware.layerClient(SignedIn, ({ request, next }) => next(request)));
+/**
+* ref0's `/v1` as a typed client at a key's origin, with no credential, signing each request that
+* asks for a proof, such as a machine's ask to connect, with the key its store holds. It needs the
+* process's `ProofClock`, and its errors still hold their requests, as `boundClient`'s do.
+*/
+const provingClient = (signer) => ref0Client(signer.origin).pipe(Effect.provide(keyProof(signer)));
+//#endregion
 //#region ../sdk/src/client/request-id.ts
 const decodeRequestId$1 = Schema.decodeUnknownEffect(RequestId);
 /**
@@ -19371,7 +19682,7 @@ const refusedBy = (status, refusal, change) => new CallFailed({
 * An answer none of its endpoint's schemas reads: another endpoint's, or one a bug in ref0 or
 * the CLI made. A change it answered may have run.
 */
-const unreadable = (endpoint, change) => new CallFailed({
+const unreadable$1 = (endpoint, change) => new CallFailed({
 	status: 0,
 	kind: "Unexpected",
 	nextStep: change ? `ref0’s answer to ${endpoint} isn’t one that endpoint gives, so it may have run. Check before you run it again.` : `ref0’s answer to ${endpoint} isn’t one that endpoint gives. Try again.`
@@ -19420,7 +19731,7 @@ const waitForAnswer = Effect.fnUntraced(function* (collect, expiresAt, change, e
 		const state = answered.value;
 		heardAt = now;
 		if (state.state === "ran") return yield* Option.match(ranOf(endpoint, state), {
-			onNone: () => Effect.fail(unreadable(endpoint, change)),
+			onNone: () => Effect.fail(unreadable$1(endpoint, change)),
 			onSome: Result.match({
 				onSuccess: () => Effect.succeed(state.result),
 				onFailure: (refusal) => Effect.fail(refusedBy(state.status, refusal, change))
@@ -19537,7 +19848,7 @@ var Ref0 = class Ref0 extends Context.Service()("ref0/cli/Ref0") {
 				onNone: () => asPerson(request.command, change, command.endpoint),
 				onSome: (bearer) => asSession(bearer, request, command.endpoint)
 			});
-			if (!isSuccessOf(request.command.endpoint, answer)) return yield* unreadable(request.command.endpoint, change);
+			if (!isSuccessOf(request.command.endpoint, answer)) return yield* unreadable$1(request.command.endpoint, change);
 			return answer;
 		});
 		return Ref0.of({ call });
@@ -19552,7 +19863,7 @@ const callEndpoint = (command) => Effect.gen(function* () {
 	return {
 		json,
 		value: yield* Option.match(successOf(command.endpoint, json), {
-			onNone: () => Effect.fail(unreadable(command.endpoint, false)),
+			onNone: () => Effect.fail(unreadable$1(command.endpoint, false)),
 			onSome: Effect.succeed
 		})
 	};
@@ -21337,18 +21648,182 @@ var Keychain = class Keychain extends Context.Service()("ref0/cli/Keychain") {
 	static layer = Layer.effect(Keychain, Effect.flatMap(Ref0Config, (config) => Effect.map(keychainIn(`ref0/${originKey(config.api)}`), Keychain.of)));
 };
 //#endregion
+//#region src/machine-key.ts
+/**
+* This machine's key, which signs a proof for its ask to connect and for each request a host
+* grant makes: one ES256 key for each OS account and origin, in the origin's keychain service
+* under account `machine-key`, as `{ store: 'software', jwk }`. `ref0 connect` makes it, under its
+* lock, only when the keychain says it holds none, and nothing else makes one. A process reads it
+* once and keeps it, since each read is a `security` or `secret-tool` process. Its private half
+* goes to the keychain on stdin and into a Web Crypto key that can't be exported, and nowhere
+* else: no argument, environment, config, error or log.
+*/
+/** The keychain account the key is kept under. */
+const account = "machine-key";
+/** How long reading and importing the key may take for a request, and signing with it. */
+const deadline = Duration.seconds(3);
+/**
+* How long `ref0 connect` may wait on the keychain to read, make and keep the key, as its probe
+* may: a prompt to unlock the keychain can take that long.
+*/
+const connectDeadline = Duration.minutes(1);
+/** A P-256 coordinate or private scalar: 32 bytes, in base64url. */
+const Scalar = Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43}$/));
+/** A P-256 private key as a JWK: its public point, and its private scalar `d`. */
+const PrivateJwk = Schema.Struct({
+	kty: Schema.Literal("EC"),
+	crv: Schema.Literal("P-256"),
+	x: Scalar,
+	y: Scalar,
+	d: Scalar
+});
+/** The keychain's record: which store keeps the key, and the key. A hardware store keeps its own. */
+const KeptKey = Schema.Struct({
+	store: Schema.Literal("software"),
+	jwk: PrivateJwk
+});
+const decodeKept$3 = Schema.decodeUnknownOption(Schema.fromJsonString(KeptKey));
+const encodeKept$3 = Schema.encodeSync(Schema.fromJsonString(KeptKey));
+const decodePrivateJwk = Schema.decodeUnknownEffect(PrivateJwk);
+const decodePublicJwk = Schema.decodeSync(PublicJwk);
+const ecdsa = {
+	name: "ECDSA",
+	namedCurve: "P-256"
+};
+const es256 = {
+	name: "ECDSA",
+	hash: "SHA-256"
+};
+/** What a key signs to prove it signs for its public half. */
+const proved = new TextEncoder().encode("ref0 machine key");
+const timedOut = new KeychainError({ nextStep: "The keychain didn’t answer in time. Check that it’s unlocked, and try again." });
+const unreadable = new KeychainError({ nextStep: "ref0 can’t read this machine’s key in the keychain, so it signs nothing and makes no other. Update ref0, which may have kept it in a newer form, or repair the keychain, and try again." });
+const notKept = new KeychainError({ nextStep: "The keychain didn’t keep this machine’s key. Check that it’s unlocked, then run ref0 connect again." });
+const windows = new KeychainError({ nextStep: "ref0 connect doesn’t run on Windows yet: it keeps this machine’s key in the macOS keychain or a Linux secret service. Run it in WSL instead." });
+const didNotSign = new KeyStoreUnavailable({ nextStep: "This machine’s key didn’t sign in time. Try again." });
+/** A fresh key's private JWK, with only the members the record keeps. */
+const freshKey = Effect.promise(async () => {
+	const pair = await crypto.subtle.generateKey(ecdsa, true, ["sign", "verify"]);
+	return await crypto.subtle.exportKey("jwk", pair.privateKey);
+}).pipe(Effect.flatMap(({ kty, crv, x, y, d }) => decodePrivateJwk({
+	kty,
+	crv,
+	x,
+	y,
+	d
+})), Effect.orDie);
+/**
+* A key store over a private JWK: imported once, as a key that can't be exported, and proved to
+* sign for its public half, or it's no key to bind anything to.
+*/
+const softwareStore = Effect.fnUntraced(function* (jwk) {
+	const publicKey = decodePublicJwk({
+		kty: jwk.kty,
+		crv: jwk.crv,
+		x: jwk.x,
+		y: jwk.y
+	});
+	const signs = yield* Effect.tryPromise({
+		try: async () => {
+			const [signing, verifying] = await Promise.all([crypto.subtle.importKey("jwk", jwk, ecdsa, false, ["sign"]), crypto.subtle.importKey("jwk", publicKey, ecdsa, false, ["verify"])]);
+			const signature = await crypto.subtle.sign(es256, signing, proved);
+			return await crypto.subtle.verify(es256, verifying, signature, proved) ? signing : void 0;
+		},
+		catch: () => unreadable
+	});
+	if (signs === void 0) return yield* unreadable;
+	const sign = (bytes) => Effect.tryPromise({
+		try: async () => new Uint8Array(await crypto.subtle.sign(es256, signs, new Uint8Array(bytes))),
+		catch: () => didNotSign
+	}).pipe(Effect.timeoutOrElse({
+		duration: deadline,
+		orElse: () => Effect.fail(didNotSign)
+	}));
+	return {
+		store: {
+			publicKey,
+			sign
+		},
+		binding: { jkt: yield* keyThumbprint(publicKey) }
+	};
+});
+/**
+* This machine's key, read once for the process. `supported` refuses a platform with no keychain
+* that keeps it, such as Windows, before `ref0 connect` asks the keychain anything. `ensure` is
+* `ref0 connect`'s: the key the keychain holds, or one made and kept now if it says it holds none,
+* under the connect lock, once the keychain is probed. `boundTo` is for a kept
+* credential bound to a key: the key it names, read again once if the one held is another, such
+* as one replaced since, or `InvalidDpopProof`, without sending anything, when the keychain has
+* none or another. Neither makes a key from an item it can't read.
+*/
+var MachineKey = class MachineKey extends Context.Service()("ref0/cli/MachineKey") {
+	/** On the platform Node names, such as `win32`, where no keychain keeps the key yet. */
+	static layerOn = (platform) => Layer.effect(MachineKey, Effect.gen(function* () {
+		const keychain = yield* Keychain;
+		const held = yield* Ref.make(Option.none());
+		const reading = yield* Semaphore.make(1);
+		const read = Effect.gen(function* () {
+			const kept = yield* keychain.get(account);
+			if (Option.isNone(kept)) return Option.none();
+			const record = decodeKept$3(Redacted.value(kept.value));
+			if (Option.isNone(record)) return yield* unreadable;
+			const key = yield* softwareStore(record.value.jwk);
+			yield* Ref.set(held, Option.some(key));
+			return Option.some(key);
+		});
+		const made = Effect.gen(function* () {
+			const jwk = yield* freshKey;
+			yield* keychain.set(account, Redacted.make(encodeKept$3({
+				store: "software",
+				jwk
+			})));
+			const back = yield* read;
+			const same = Option.exists(back, (key) => key.store.publicKey.x === jwk.x && key.store.publicKey.y === jwk.y);
+			if (Option.isNone(back) || !same) return yield* notKept;
+			return back.value;
+		});
+		const supported = platform === "win32" ? Effect.fail(windows) : Effect.void;
+		const ensure = Effect.gen(function* () {
+			const kept = yield* read;
+			return Option.isSome(kept) ? kept.value : yield* made;
+		}).pipe(Effect.timeoutOrElse({
+			duration: connectDeadline,
+			orElse: () => Effect.fail(timedOut)
+		}), reading.withPermits(1));
+		const boundTo = (binding) => Effect.gen(function* () {
+			const now = yield* Ref.get(held);
+			if (Option.isSome(now) && now.value.binding.jkt === binding.jkt) return now.value.store;
+			const kept = yield* read.pipe(Effect.timeoutOrElse({
+				duration: deadline,
+				orElse: () => Effect.fail(timedOut)
+			}));
+			if (Option.isSome(kept) && kept.value.binding.jkt === binding.jkt) return kept.value.store;
+			return yield* invalidDpopProof;
+		}).pipe(reading.withPermits(1));
+		return MachineKey.of({
+			supported,
+			ensure,
+			boundTo
+		});
+	}));
+	static layer = MachineKey.layerOn(process.platform);
+};
+//#endregion
 //#region src/host-grant.ts
 /**
 * All lasting authority for one config folder, stored as one keychain value: the agent the folder
-* acts as, by its owner, handle and agent ID, and its token. The ID is kept in the same write as
-* the token, so a folder with a grant always knows which agent its commits name.
+* acts as, by its owner, handle and agent ID, its token, and the key it's bound to, if it is. The
+* ID is kept in the same write as the token, so a folder with a grant always knows which agent its
+* commits name.
 */
 const KeptHostGrant = Schema.Struct({
 	harness: ConnectHarness,
 	owner: OwnerName,
 	agent: AgentHandle,
 	agentId: AgentId,
-	token: Schema.RedactedFromValue(Schema.String)
+	token: Schema.RedactedFromValue(Schema.String),
+	/** This machine's key, by its thumbprint, when ref0 bound the grant to it: none from before. */
+	cnf: Schema.optionalKey(KeyBinding)
 });
 const decodeGrant = Schema.decodeUnknownOption(Schema.fromJsonString(KeptHostGrant));
 const encodeGrant = Schema.encodeSync(Schema.fromJsonString(KeptHostGrant));
@@ -21392,6 +21867,24 @@ const grantForAgent = Effect.fnUntraced(function* (owner, agent) {
 	}
 	return Option.none();
 });
+const decodeProofOrigin$1 = Schema.decodeUnknownEffect(ProofOrigin);
+/**
+* ref0's `/v1` as a typed client acting with a kept host grant: with a proof this machine's key
+* signs for each request when the grant is bound to it, or as a bearer token when it's a grant
+* from before binding. A grant bound to a key the keychain no longer holds is refused here, with
+* `InvalidDpopProof`, and nothing is sent.
+*/
+const grantClient = Effect.fnUntraced(function* (grant) {
+	const config = yield* Ref0Config;
+	if (grant.cnf === void 0) return yield* ref0Client(config.api).pipe(Effect.provide(bearerCredential(grant.token)));
+	const store = yield* (yield* MachineKey).boundTo(grant.cnf);
+	const origin = yield* Effect.orDie(decodeProofOrigin$1(config.api));
+	return yield* boundClient({
+		origin,
+		store,
+		token: grant.token
+	});
+});
 //#endregion
 //#region src/version.ts
 /**
@@ -21400,7 +21893,7 @@ const grantForAgent = Effect.fnUntraced(function* (owner, agent) {
 * an update installs anew. Node, run from source, loads JSON only with the `type` attribute,
 * and only as a default export.
 */
-const cliVersion = "0.12.0";
+const cliVersion = "0.13.0";
 //#endregion
 //#region src/harness/hook-protocol.ts
 /**
@@ -21650,6 +22143,7 @@ const yesOrNoQuestions = Effect.gen(function* () {
 const isAnswerCode = Schema.is(TypedApprovalCode);
 const decodeTokenId$1 = Schema.decodeUnknownOption(TokenId);
 const decodeSecretHash$1 = Schema.decodeUnknownEffect(SecretHash);
+const decodeProofOrigin = Schema.decodeUnknownEffect(ProofOrigin);
 /** How often the machine asks whether its person has answered. */
 const pollMillis = 2e3;
 /** How long one request may take before the machine gives up on it, and asks again. */
@@ -21702,12 +22196,14 @@ const endedWords$1 = (state) => {
 /** The grant a kept record holds, by its ID. */
 const grantOf = (token) => Option.flatMap(parseToken(Redacted.value(token)), (parts) => decodeTokenId$1(parts.token));
 /**
-* Asks with no owner for every folder given, each with a grant secret of its own, shows the
-* link, and takes the answer from the person's own page. Then it keeps each folder ref0
-* connected, confirms exactly the grants it kept, and forgets 0.5.0's grants they replace.
+* Asks with no owner for every folder given, each with a grant secret of its own, signed by this
+* machine's key, which ref0 binds every grant to, shows the link, and takes the answer from the
+* person's own page. Then it keeps each folder ref0 connected, with the key it's bound to,
+* confirms exactly the grants it kept, and forgets 0.5.0's grants they replace.
 */
-const requestAttachment = Effect.fnUntraced(function* (asked) {
+const requestAttachment = Effect.fnUntraced(function* (asked, key) {
 	const config = yield* Ref0Config;
+	const origin = yield* decodeProofOrigin(config.api).pipe(Effect.catchTag("SchemaError", () => sayFailed(`ref0 connect signs its ask only to an HTTPS origin, or HTTP on this machine, and ${config.api} is neither.`)));
 	const machine = yield* Machine;
 	const hostGrant = yield* HostGrant;
 	const oldGrants = yield* OldHostGrants;
@@ -21720,7 +22216,10 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	const opener = yield* browserOpener;
 	const listener = opener === void 0 ? void 0 : yield* listenForAnswer(new URL(config.api).origin).pipe(Effect.catchTag("ListenerUnavailable", () => Effect.as(printBlocks([["Couldn’t listen for the browser. Paste the code instead."]]), void 0)));
 	const machineId = yield* machine.id.pipe(Effect.catchTag("MachineError", said));
-	const client = yield* ref0Client(config.api).pipe(Effect.provide(anonymousCredential), Effect.provideService(HttpClient.HttpClient, http));
+	const client = yield* provingClient({
+		origin,
+		store: key.store
+	}).pipe(Effect.provideService(HttpClient.HttpClient, http));
 	const unreachable = () => sayFailed(`Couldn’t reach ref0 at ${config.api}. Try again.`);
 	const requestId = yield* newRequestId;
 	const asking = yield* Effect.forEach(asked, Effect.fnUntraced(function* (folder) {
@@ -21747,6 +22246,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	const payload = {
 		machine: machineId,
 		machineName: machineNameOf(machine.hostName),
+		publicKey: key.store.publicKey,
 		folders,
 		collectHash: yield* Effect.orDie(decodeSecretHash$1(collecting.hash)),
 		linkHash: yield* Effect.orDie(decodeSecretHash$1(link.hash))
@@ -21762,6 +22262,8 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		NotPermitted: said,
 		CommandRefused: said,
 		SlowDown: said,
+		KeyStoreUnavailable: said,
+		InvalidDpopProof: () => sayFailed(`ref0 refused this machine’s proof of its key, so nothing was asked. Check that this machine’s clock is right, then run ${again$1} again.`),
 		AuthorityUnavailable: unanswered,
 		HttpClientError: unanswered,
 		SchemaError: unanswered
@@ -21785,10 +22287,10 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	const withSecret = HttpApiMiddleware.layerClient(ApprovalSecret, ({ request, next }) => next(HttpClientRequest.bearerToken(request, collecting.secret)));
 	const collector = yield* ref0Client(config.api).pipe(Effect.provide(Layer.merge(anonymousCredential, withSecret)), Effect.provideService(HttpClient.HttpClient, http));
 	const params = { approval: started.approval };
-	const collect = Effect.flatMap(Ref.get(pasted), (answerCode) => collector.machineAttachments.collect({
+	const collect = (answerCode) => collector.machineAttachments.collect({
 		params,
 		payload: answerCode === void 0 ? {} : { answerCode }
-	})).pipe(Effect.map(Option.some), Effect.timeoutOrElse({
+	}).pipe(Effect.map(Option.some), Effect.timeoutOrElse({
 		duration: requestTimeout,
 		orElse: () => Effect.succeedNone
 	}), Effect.catchTags({
@@ -21798,13 +22300,19 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		HttpClientError: () => Effect.succeedNone,
 		SchemaError: () => Effect.succeedNone
 	}));
+	const lapsing = asking.some((folder) => Option.isSome(folder.replaces)) ? "Its new grants expire unconfirmed, and each folder’s connection from before still works." : "Its new grants expire unconfirmed.";
 	const giveUpAt = DateTime.toEpochMillis(started.expiresAt) + giveUpAfterMillis;
+	let confirmBy;
 	const answered = Effect.gen(function* () {
 		while (true) {
-			const state = yield* collect;
-			if (Option.isSome(state) && isEnded(state.value)) return state.value;
-			if ((yield* Clock.currentTimeMillis) > giveUpAt) {
+			const sent = yield* Ref.get(pasted);
+			const state = Option.getOrUndefined(yield* collect(sent));
+			if (state !== void 0 && isEnded(state)) return state;
+			if (state?.confirmBy !== void 0) confirmBy = DateTime.toEpochMillis(state.confirmBy);
+			if ((yield* Ref.get(pasted)) !== sent) continue;
+			if ((yield* Clock.currentTimeMillis) > (confirmBy ?? giveUpAt)) {
 				yield* endWait;
+				if (confirmBy !== void 0 && sent === void 0) return yield* sayFailed(`It was approved, but no code was pasted in time, so this machine kept nothing. ${lapsing} To connect this machine, run: ${again$1}`);
 				return yield* sayFailed(`ref0 hasn’t said how it ended, so this machine kept nothing. If it was approved, ref0 revokes its grants 10 minutes after it connected. To connect this machine, run: ${again$1}`);
 			}
 			yield* Effect.sleep(pollMillis);
@@ -21827,7 +22335,8 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		owner: connection.owner,
 		agent: connection.handle,
 		agentId: connection.agent.id,
-		token: Redacted.make(formatToken(connection.credential.person, connection.credential.id, folder.grant.secret))
+		token: Redacted.make(formatToken(connection.credential.person, connection.credential.id, folder.grant.secret)),
+		cnf: key.binding
 	}, keepBy, "The keychain took too long with the folders before it, so this machine didn’t keep this one’s grant.");
 	const finish = Effect.fnUntraced(function* (state) {
 		if (state.state !== "connected") return yield* sayFailed(endedWords$1(state));
@@ -21949,7 +22458,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 			times: 2
 		}), Effect.catchTag("Unanswered", () => sayFailed("Couldn’t reach ref0 to abort it. If it’s approved anyway, ref0 revokes its grants 10 minutes after they connect, since this machine never kept them.")));
 		if (!isEnded(state)) {
-			if ((yield* Ref.get(pasted)) === void 0) return yield* sayFailed([["It was already answered, but no code was pasted, so this machine kept nothing.", asking.some((folder) => Option.isSome(folder.replaces)) ? "Its new grants expire unconfirmed, and each folder’s connection from before still works." : "Its new grants expire unconfirmed."]]);
+			if ((yield* Ref.get(pasted)) === void 0) return yield* sayFailed([["It was already answered, but no code was pasted, so this machine kept nothing.", lapsing]]);
 			yield* printBlocks([["It was already answered, so this machine waits to hear how."]]);
 		}
 		const connected = yield* finish(isEnded(state) ? state : yield* answered);
@@ -24628,14 +25137,17 @@ const connectCommands = [Command.make("connect", { json }, ({ json: asJson }) =>
 	if (yield* session.current.pipe(Effect.map(Option.isSome), Effect.catchTag("NoSession", () => Effect.succeed(true)))) return yield* sayFailed("ref0 connect runs only in a person’s own terminal, never in an agent’s session: it shows a code, and a yes to that code connects this machine to an agent. If this machine needs connecting, tell your person to run ref0 connect in their own terminal. Never ask them to approve a code for you.");
 	if (!tty.attached) return yield* sayFailed("ref0 connect runs only in a terminal you type into, and this isn’t one. Run it yourself, in your own terminal: not through a script, a pipe or an agent.");
 	yield* (yield* ConnectLock).hold;
+	const machineKey = yield* MachineKey;
+	yield* machineKey.supported;
 	yield* (yield* Keychain).probe;
+	const key = yield* machineKey.ensure;
 	const home = yield* Config.String("HOME").pipe(Config.withDefault("."));
 	const found = yield* findConfigFolders;
 	if (found.length === 0) return yield* sayFailed(`ref0 found no Claude Code or Codex config folder in your home. Start Claude Code or Codex once, then run ${again} again.`);
 	const chosen = yield* choose(found, home).pipe(Effect.catchTag("QuitError", () => sayFailed("Stopped, and nothing was asked.")));
 	if (chosen.length === 0) return yield* sayFailed(`No config folder was ticked, so nothing was asked. To connect one, run ${again} again.`);
 	yield* Console.error("");
-	const connected = yield* requestAttachment(chosen);
+	const connected = yield* requestAttachment(chosen, key);
 	const installed = yield* installInto(connected.kept, { asJson });
 	const others = yield* otherOwners(connected);
 	yield* printAnswer(answerOf(connected, installed, others), asJson, reportOf(connected, installed, others, home));
@@ -25201,9 +25713,9 @@ const signalExits = {
 };
 const decodeSetup = Schema.decodeUnknownOption(Schema.Array(Schema.String));
 /** A duration's milliseconds, as a check writes it, `'30 seconds'`, or a number of them. */
-const millisOf = (duration) => Option.map(Duration.fromInput(duration), (read) => Math.ceil(Duration.toMillis(read)));
+const millisOf$1 = (duration) => Option.map(Duration.fromInput(duration), (read) => Math.ceil(Duration.toMillis(read)));
 /** A duration a command was given, in milliseconds, or why it isn't one. */
-const givenMillis = (duration) => Option.match(millisOf(duration), {
+const givenMillis = (duration) => Option.match(millisOf$1(duration), {
 	onNone: () => Effect.fail(new LocalSandboxFailed({ why: `Not a duration: ${duration}` })),
 	onSome: Effect.succeed
 });
@@ -25546,7 +26058,7 @@ const defaultRetries = {
 };
 const defaultTimeout = 6e5;
 /** A duration as a step's config writes it, in milliseconds, or the run's code's mistake. */
-const stepMillis = (duration) => Option.match(millisOf(duration), {
+const stepMillis = (duration) => Option.match(millisOf$1(duration), {
 	onNone: () => Effect.die(/* @__PURE__ */ new Error(`Not a duration: ${duration}`)),
 	onSome: Effect.succeed
 });
@@ -26866,7 +27378,7 @@ const loadSyncHistory = Effect.fnUntraced(function* (gitDir, repo) {
 * or the thread below, set apart.
 */
 const baseNamed = (on, main = "main") => on === "main" ? main : `#${on.thread}, which this thread is stacked on,`;
-const decodeWritten$1 = Schema.decodeUnknownOption(WrittenRepo);
+const decodeWritten$2 = Schema.decodeUnknownOption(WrittenRepo);
 const decodeCommit$1 = Schema.decodeUnknownOption(CommitOid);
 const refused$1 = (why) => ({
 	kind: "refused",
@@ -26900,7 +27412,7 @@ const syncBase = Effect.fnUntraced(function* (folder) {
 		stdout: "inherit",
 		stderr: "inherit"
 	})).pipe(Effect.map(Number), Effect.catchCause(() => Effect.succeed(-1)));
-	const written = decodeWritten$1((yield* read([
+	const written = decodeWritten$2((yield* read([
 		"config",
 		"--get",
 		"ref0.repo"
@@ -30066,7 +30578,7 @@ const watchCommands = [Command.make("watch", {
 		owner: ownerName,
 		agent: flags.agent
 	});
-	const client = yield* ref0Client(config.api).pipe(Effect.provide(bearerCredential(grant.value.token)));
+	const client = yield* grantClient(grant.value);
 	const watching = {
 		project: flags.project,
 		parent: Option.getOrUndefined(flags.parent),
@@ -30095,7 +30607,7 @@ const watchCommands = [Command.make("watch", {
 				parent: number
 			})
 		})
-	}).pipe(Effect.mapError((error) => Match.value(error).pipe(Match.tag("Unauthenticated", "SessionHasEnded", () => stopped(`ref0 refused the host grant ref0 connect kept for ${as} on this machine: it was revoked or never confirmed, or the machine was disconnected. Connect it again with ref0 connect, then run ref0 watch again.`)), Match.tag("ProjectNotFound", () => stopped(`${flags.project} isn’t a project ${as} can read. Check the owner/project, and that ${flags.agent} is the agent to watch as.`)), Match.tag("ThreadNotFound", () => stopped(`${flags.project} has no thread #${Option.getOrElse(flags.parent, () => 0)} to watch the children of. Find its number with ref0 threads ${flags.project}.`)), Match.tag("NotPermitted", (refused) => stopped(refused.nextStep)), Match.tag("AuthorityUnavailable", () => new ReadUnavailable({ why: "it’s restarting" })), Match.tag("ProjectNotReady", () => new ReadUnavailable({ why: `${flags.project} isn’t ready yet` })), Match.orElse(() => new ReadUnavailable({ why: `couldn’t reach ${config.api}` })))));
+	}).pipe(Effect.mapError((error) => Match.value(error).pipe(Match.tag("Unauthenticated", "SessionHasEnded", () => stopped(`ref0 refused the host grant ref0 connect kept for ${as} on this machine: it was revoked or never confirmed, or the machine was disconnected. Connect it again with ref0 connect, then run ref0 watch again.`)), Match.tag("ProjectNotFound", () => stopped(`${flags.project} isn’t a project ${as} can read. Check the owner/project, and that ${flags.agent} is the agent to watch as.`)), Match.tag("ThreadNotFound", () => stopped(`${flags.project} has no thread #${Option.getOrElse(flags.parent, () => 0)} to watch the children of. Find its number with ref0 threads ${flags.project}.`)), Match.tag("NotPermitted", "InvalidDpopProof", (refused) => stopped(refused.nextStep)), Match.tag("KeyStoreUnavailable", () => new ReadUnavailable({ why: "this machine’s key didn’t sign in time" })), Match.tag("AuthorityUnavailable", () => new ReadUnavailable({ why: "it’s restarting" })), Match.tag("ProjectNotReady", () => new ReadUnavailable({ why: `${flags.project} isn’t ready yet` })), Match.orElse(() => new ReadUnavailable({ why: `couldn’t reach ${config.api}` })))));
 	return yield* Effect.scoped(Effect.gen(function* () {
 		const state = yield* openWatchState(folder, {
 			project: flags.project,
@@ -30115,7 +30627,8 @@ const watchCommands = [Command.make("watch", {
 }).pipe(Effect.catchTags({
 	WatchStopped: (stopped) => sayFailed(stopped.nextStep),
 	WatchStateError: (failed) => sayFailed(failed.nextStep),
-	KeychainError: (failed) => sayFailed(failed.nextStep)
+	KeychainError: (failed) => sayFailed(failed.nextStep),
+	InvalidDpopProof: (refused) => sayFailed(refused.nextStep)
 }))).pipe(Command.withShortDescription("Run a command for each thread started in a project"), Command.withDescription([
 	"Runs a command for each thread started in a project, as one of your agents, through the host grant ref0 connect kept on this machine; it sees only what that agent may. It runs until stopped: the first time from now on, or with --parent from the parent’s first child on, and from where it stopped after that.",
 	"Just before each run it reads the thread again, and skips it, marked done, if it’s settled or closed. Before its first run, it skips one a session is live on, with --skip-live, and one started before the watch did that a session has started on. After, a session may be one its own failed run opened, live until its lease lapses, within 30 minutes: with --skip-live, it waits until none is live, then runs again.",
@@ -30652,7 +31165,7 @@ function editedPaths(hook) {
 /** The most bytes of a file read around an edit; a larger one's edits aren't attributed. */
 const fileBytes = 2e6;
 /** The most edit calls waiting for their `PostToolUse`; a harness that never sends one leaks none. */
-const openCalls = 64;
+const openCalls$1 = 64;
 /** The most line hashes a worktree keeps pending; the oldest edits go first. */
 const pendingLines = 2e4;
 /** A line as it's kept pending: 128 bits of its SHA-256, never its text. */
@@ -31021,7 +31534,7 @@ var Attribution = class Attribution extends Context.Service()("ref0/cli/Attribut
 					turn,
 					files
 				});
-				for (const key of calls.keys()) if (calls.size > openCalls) calls.delete(key);
+				for (const key of calls.keys()) if (calls.size > openCalls$1) calls.delete(key);
 				return {
 					...latest,
 					calls
@@ -31269,7 +31782,7 @@ const optionsWithValues = /* @__PURE__ */ new Set([
 	"--git-dir",
 	"--work-tree"
 ]);
-const decodeWritten = Schema.decodeUnknownOption(WrittenRepo);
+const decodeWritten$1 = Schema.decodeUnknownOption(WrittenRepo);
 const hunkHeader = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
 /** The command a Git run's arguments name, past Git's own options. */
 const commandOf = (args) => {
@@ -31617,7 +32130,7 @@ const checkBase = Effect.fnUntraced(function* (folder, base, delivered, within)
 					"--get",
 					"ref0.repo"
 				]);
-				const repo = decodeWritten(named.out.trim());
+				const repo = decodeWritten$1(named.out.trim());
 				if (Option.isNone(repo)) return yield* failed("this checkout has no ref0.repo to load history for");
 				yield* loadSyncHistory(store, repo.value).pipe(Effect.mapError((error) => failed(error.why)));
 				yield* fs.writeFileString(loaded, "");
@@ -32375,6 +32888,321 @@ var HarnessTasks = class HarnessTasks extends Context.Service()("ref0/cli/Harnes
 	}));
 };
 //#endregion
+//#region src/harness/turn-facts.ts
+const Written = Schema.Struct({ timestamp: Schema.String });
+const decodeWritten = Schema.decodeUnknownOption(Schema.fromJsonString(Written));
+/** When a transcript's line says it was written, by the harness's clock, if it says. */
+const writtenAt = (line) => {
+	const at = Option.match(decodeWritten(line), {
+		onNone: () => NaN,
+		onSome: (written) => Date.parse(written.timestamp)
+	});
+	return Number.isFinite(at) ? at : void 0;
+};
+/** The most tool names a turn's record counts. */
+const toolNames = 100;
+/** The most replies a turn's tally remembers; a turn with more has its tokens unknown. */
+const turnReplies = 1e4;
+/**
+* The most calls a turn remembers as begun and not ended, its newest kept: a call that never
+* ends, as one a `PreToolUse` answer denied, is never counted.
+*/
+const openCalls = 100;
+const nothingRead = {
+	known: "waiting",
+	models: /* @__PURE__ */ new Map(),
+	replies: /* @__PURE__ */ new Map()
+};
+const nothingReadOf = {
+	tokens: nothingRead,
+	context: {
+		known: "waiting",
+		peak: void 0,
+		compactions: []
+	},
+	subagents: /* @__PURE__ */ new Map(),
+	moreSubagents: 0
+};
+const nothingCalled = {
+	known: true,
+	totalMs: 0,
+	longest: void 0,
+	open: /* @__PURE__ */ new Map()
+};
+const nothingSeen = {
+	...nothingReadOf,
+	tools: /* @__PURE__ */ new Map(),
+	calls: nothingCalled,
+	addresses: [],
+	more: 0,
+	model: void 0,
+	startedAt: void 0,
+	stoppedAt: void 0
+};
+/**
+* A call's `PreToolUse` or its end seen at `at`: its time Claude Code's `duration_ms`, or, where
+* the harness says none, as Codex, from its `PreToolUse` to its end. One whose time can't be
+* told makes the turn's unknown, as does a tool name ref0 refuses.
+*/
+function timeCall(calls, hook, at) {
+	const name = hook.tool?.name;
+	const callId = hook.tool?.callId;
+	if (name === void 0) return calls;
+	if (hook.event === "PreToolUse") {
+		if (callId === void 0) return calls;
+		const open = new Map(calls.open).set(callId, at);
+		for (const [oldest] of open) {
+			if (open.size <= openCalls) break;
+			open.delete(oldest);
+		}
+		return {
+			...calls,
+			open
+		};
+	}
+	if (hook.event !== "PostToolUse" && hook.event !== "PostToolUseFailure") return calls;
+	const open = new Map(calls.open);
+	const began = callId === void 0 ? void 0 : open.get(callId);
+	if (callId !== void 0) open.delete(callId);
+	const ms = hook.durationMs ?? (began === void 0 ? void 0 : Math.max(at - began, 0));
+	if (ms === void 0 || name.length > 128) return {
+		...calls,
+		known: false,
+		open
+	};
+	const longest = calls.longest === void 0 || ms > calls.longest.ms ? {
+		tool: name,
+		ms
+	} : calls.longest;
+	return {
+		...calls,
+		totalMs: calls.totalMs + ms,
+		longest,
+		open
+	};
+}
+/**
+* A hook seen at `at`: a tool call counted by its tool once it ran, and timed, the files an edit
+* is about to touch kept, at most 50 and the rest counted, the model, where the hook names one,
+* and a `Stop` as when the agent last stopped.
+*/
+function seeHook(seen, hook, edited, at) {
+	const tools = new Map(seen.tools);
+	const name = hook.tool?.name;
+	if (hook.event === "PostToolUse" && name !== void 0) {
+		const counted = tools.get(name);
+		if (counted !== void 0 || tools.size < toolNames) tools.set(name, (counted ?? 0) + 1);
+	}
+	const addresses = [...seen.addresses];
+	let more = seen.more;
+	for (const each of edited) {
+		if (addresses.some((kept) => kept.repo === each.repo && kept.path === each.path)) continue;
+		if (addresses.length < 50) addresses.push(each);
+		else more += 1;
+	}
+	return {
+		...seen,
+		tools,
+		calls: timeCall(seen.calls, hook, at),
+		addresses,
+		more,
+		model: hook.model ?? seen.model,
+		stoppedAt: hook.event === "Stop" ? at : seen.stoppedAt
+	};
+}
+/**
+* A read's replies added to a turn's, each by its message ID at the most any of its lines says:
+* a subagent's transcript writes a reply's output as it grows, line by line, so a line of a reply
+* already counted adds only what it grew. `own` when the read was of the session's own
+* transcript, which makes the turn's tokens known; nothing makes them known once a read has
+* failed.
+*/
+function addReplies(tally, replies, own) {
+	if (tally.known === "failed") return tally;
+	const models = new Map(tally.models);
+	const counted = new Map(tally.replies);
+	for (const reply of replies) {
+		const before = counted.get(reply.id);
+		const most = {
+			model: before?.model ?? reply.model,
+			input: Math.max(before?.input ?? 0, reply.input),
+			output: Math.max(before?.output ?? 0, reply.output),
+			cacheWrite: Math.max(before?.cacheWrite ?? 0, reply.cacheWrite),
+			cacheRead: Math.max(before?.cacheRead ?? 0, reply.cacheRead)
+		};
+		const sum = models.get(most.model);
+		counted.set(reply.id, most);
+		models.set(most.model, {
+			input: (sum?.input ?? 0) + most.input - (before?.input ?? 0),
+			output: (sum?.output ?? 0) + most.output - (before?.output ?? 0),
+			cacheWrite: (sum?.cacheWrite ?? 0) + most.cacheWrite - (before?.cacheWrite ?? 0),
+			cacheRead: (sum?.cacheRead ?? 0) + most.cacheRead - (before?.cacheRead ?? 0)
+		});
+	}
+	if (counted.size > turnReplies) return readFailed(tally);
+	return {
+		known: own ? "read" : tally.known,
+		models,
+		replies: counted
+	};
+}
+/**
+* A read's requests added to a turn's, by model, as Codex's rollout steps its running total.
+* `own` as for `addReplies`: a rollout is always the session's own.
+*/
+function addSteps(tally, steps, own) {
+	if (tally.known === "failed") return tally;
+	const models = new Map(tally.models);
+	for (const step of steps) {
+		const sum = models.get(step.model);
+		models.set(step.model, {
+			input: (sum?.input ?? 0) + step.input,
+			output: (sum?.output ?? 0) + step.output,
+			cacheWrite: (sum?.cacheWrite ?? 0) + step.cacheWrite,
+			cacheRead: (sum?.cacheRead ?? 0) + step.cacheRead
+		});
+	}
+	return {
+		...tally,
+		known: own ? "read" : tally.known,
+		models
+	};
+}
+/** A read that failed: the turn's tokens are unknown from then on. */
+const readFailed = (tally) => ({
+	...tally,
+	known: "failed"
+});
+/** A read's replies and requests added to a turn's tokens, or its tokens unknown if it failed. */
+const addTokens = (tally, read, own) => read.whole ? addSteps(addReplies(tally, read.replies, own), read.steps, own) : readFailed(tally);
+/** What one request sent: its input, cached or not. */
+const sentBy = (tokens) => tokens.input + tokens.cacheWrite + tokens.cacheRead;
+/**
+* A read of the session's own transcript added to its context: the most any request sent, each
+* Claude Code reply at the most its lines said, and each compaction. Unknown once a read fails.
+*/
+function addContext(context, read) {
+	if (context.known === "failed") return context;
+	if (!read.whole) return {
+		...context,
+		known: "failed"
+	};
+	return {
+		known: "read",
+		peak: [...read.replies, ...read.steps].reduce((most, request) => Math.max(most ?? 0, sentBy(request)), context.peak),
+		compactions: [...context.compactions, ...read.compactions]
+	};
+}
+/**
+* A read added to a turn's: to its tokens, and, from the session's own transcript, to its
+* context, or, from a subagent's, to that subagent's own tokens too, each subagent kept by its
+* transcript as first read, past the first 100 only counted.
+*/
+function addRead(reads, read, of) {
+	const tokens = addTokens(reads.tokens, read, of.own);
+	if (of.own) return {
+		...reads,
+		tokens,
+		context: addContext(reads.context, read)
+	};
+	const before = reads.subagents.get(of.subagent);
+	if (before === void 0 && reads.subagents.size >= 100) return {
+		...reads,
+		tokens,
+		moreSubagents: reads.moreSubagents + 1
+	};
+	const subagent = {
+		type: before?.type ?? of.type,
+		tokens: addTokens(before?.tokens ?? nothingRead, read, true)
+	};
+	return {
+		...reads,
+		tokens,
+		subagents: new Map(reads.subagents).set(of.subagent, subagent)
+	};
+}
+/**
+* A turn's tokens as ref0 keeps them: each model's counts once the session's own transcript is
+* read, or unknown, with no counts, where it wasn't, a read failed, or a count passes what a
+* turn may hold.
+*/
+function turnTokens(tally) {
+	if (tally.known !== "read" || tally.models.size > 16) return { known: "unknown" };
+	const models = [...tally.models].map(([model, counts]) => ({
+		model,
+		...counts
+	}));
+	return models.every((each) => Math.max(each.input, each.output, each.cacheWrite, each.cacheRead) <= 1e8 && each.model.length >= 1 && each.model.length <= 128) ? {
+		known: "read",
+		models
+	} : { known: "unknown" };
+}
+/** A turn's tool calls' time as ref0 keeps it: unknown once a call's time couldn't be told. */
+function toolTime(calls) {
+	if (!calls.known) return { known: "unknown" };
+	return calls.longest === void 0 ? {
+		known: "timed",
+		totalMs: calls.totalMs
+	} : {
+		known: "timed",
+		totalMs: calls.totalMs,
+		longest: calls.longest
+	};
+}
+/**
+* A turn's context as ref0 keeps it, each compaction's time as how long after ref0 started the
+* turn, 0 for one before its start landed: unknown until the session's own transcript is read,
+* once a read fails, or with more compactions than a turn names.
+*/
+function turnContext(context, startedAt) {
+	if (context.known !== "read" || context.compactions.length > 100) return { known: "unknown" };
+	if (context.peak !== void 0 && context.peak > 1e8) return { known: "unknown" };
+	const compactions = context.compactions.map((each) => {
+		const compaction = {};
+		if (each.trigger !== void 0) compaction.trigger = each.trigger;
+		if (each.at !== void 0 && startedAt !== void 0) compaction.afterMs = Math.max(each.at - startedAt, 0);
+		return compaction;
+	});
+	return context.peak === void 0 ? {
+		known: "read",
+		compactions
+	} : {
+		known: "read",
+		peak: context.peak,
+		compactions
+	};
+}
+/**
+* The facts a turn's reads give ref0: its tokens, its context and each subagent's tokens, with
+* its type where the harness named it.
+*/
+const readFacts = (reads, startedAt) => ({
+	tokens: turnTokens(reads.tokens),
+	context: turnContext(reads.context, startedAt),
+	subagents: [...reads.subagents.values()].map((subagent) => subagent.type === void 0 || subagent.type.length > 128 ? { tokens: turnTokens(subagent.tokens) } : {
+		type: subagent.type,
+		tokens: turnTokens(subagent.tokens)
+	}),
+	moreSubagents: reads.moreSubagents
+});
+/**
+* A turn's facts as ref0 keeps them, with its stop as how long after ref0 started it the agent last
+* stopped: none until both are seen, and 0 for a `Stop` before its start landed.
+*/
+function turnFacts(seen) {
+	const facts = {
+		modelSource: seen.model === void 0 ? "unknown" : "hook",
+		tools: Object.fromEntries(seen.tools),
+		addresses: seen.addresses,
+		more: seen.more,
+		toolTime: toolTime(seen.calls),
+		...readFacts(seen, seen.startedAt)
+	};
+	if (seen.model !== void 0) facts.model = seen.model;
+	if (seen.startedAt !== void 0 && seen.stoppedAt !== void 0) facts.stoppedAfterMs = Math.max(seen.stoppedAt - seen.startedAt, 0);
+	return facts;
+}
+//#endregion
 //#region src/harness/rollouts.ts
 /**
 * Codex's rollouts, as `ref0 mcp` reads a turn's tokens from them: each hook names the
@@ -32394,7 +33222,8 @@ var HarnessTasks = class HarnessTasks extends Context.Service()("ref0/cli/Harnes
 * `token_count`s, then the subagent's own turn, its total from zero, a forked subagent's as a
 * fresh one's (Codex 0.163.0's subagents, 20 Oct 2026). So its requests are those past its own
 * turn's `task_started`, and what its total carried over, nothing so far, is its first request's
-* total less that request's own usage.
+* total less that request's own usage. Each compaction of the session's context writes a
+* `compacted` record, with its time and none of what started it (Codex 0.163.0's, 23 Oct 2026).
 */
 const Count$1 = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 /** A session's running total, as far as ref0 counts it: reasoning is inside output. */
@@ -32442,12 +33271,16 @@ const zero = {
 	cacheWrite: 0,
 	output: 0
 };
-/** The records a read decodes: each request's total, each turn's model, start and cutting short. */
+/**
+* The records a read decodes: each request's total, each turn's model, start and cutting short,
+* and each compaction.
+*/
 const counted = [
 	"\"token_count\"",
 	"\"turn_context\"",
 	"\"task_started\"",
-	"\"turn_aborted\""
+	"\"turn_aborted\"",
+	"\"compacted\""
 ];
 /** A line, as far as telling Codex's records apart, and the turn an event is of. */
 const Line$1 = Schema.Struct({
@@ -32532,6 +33365,7 @@ const tokensOf = (model, step) => ({
 */
 function stepsIn(text, from, until) {
 	const steps = [];
+	const compactions = [];
 	const lines = text.split("\n");
 	let { top, total, model } = from;
 	let whole = true;
@@ -32548,6 +33382,7 @@ function stepsIn(text, from, until) {
 		const event = kind.value.type === "event_msg" ? kind.value.payload : void 0;
 		if (event?.type === "task_started" && until !== void 0 && event.turn_id === until) return {
 			steps,
+			compactions,
 			running: {
 				top,
 				total,
@@ -32556,6 +33391,11 @@ function stepsIn(text, from, until) {
 			whole,
 			before: index
 		};
+		if (kind.value.type === "compacted") {
+			const at = writtenAt(line);
+			compactions.push(at === void 0 ? {} : { at });
+			continue;
+		}
 		if (event?.type === "turn_aborted") {
 			whole = false;
 			continue;
@@ -32586,6 +33426,7 @@ function stepsIn(text, from, until) {
 	}
 	return {
 		steps,
+		compactions,
 		running: {
 			top,
 			total,
@@ -32603,7 +33444,9 @@ function stepsIn(text, from, until) {
 * Each holds one JSON object a line, and writes an assistant reply over several lines, each with
 * the reply's `message.usage` so far: the session's own repeat it, and a subagent's grow its
 * output line by line. So a reply counts once, by its `message.id`, at the most its lines say,
-* with its own model (Claude Code 2.1.304's transcripts, 20 Oct 2026). Codex's: the session's
+* with its own model (Claude Code 2.1.304's transcripts, 20 Oct 2026), and a compaction as a
+* `system` line, `compact_boundary`, with its time and its trigger (2.1.310's, 24 Oct 2026).
+* Codex's: the session's
 * rollout, whose running total `rollouts.ts` reads, kept with its place, and each subagent's,
 * which its `SubagentStop` names, read first from where its own turn starts, past the parent's
 * history it copies. Each is read from the
@@ -32629,8 +33472,13 @@ const linesEnd = (bytes, count) => {
 	return end;
 };
 const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-/** A line, as far as telling an assistant's from the rest. */
-const Line = Schema.Struct({ type: Schema.String });
+/** A line, as far as telling an assistant's and a compaction's from the rest. */
+const Line = Schema.Struct({
+	type: Schema.String,
+	subtype: Schema.optionalKey(Schema.Unknown)
+});
+/** A compaction's line, as far as what started it. */
+const CompactionLine = Schema.Struct({ compactMetadata: Schema.Struct({ trigger: Schema.Literals(["auto", "manual"]) }) });
 /** An assistant line: a reply's ID, its model and its usage, which every line of it repeats. */
 const AssistantLine = Schema.Struct({ message: Schema.Struct({
 	model: Schema.String,
@@ -32644,18 +33492,34 @@ const AssistantLine = Schema.Struct({ message: Schema.Struct({
 }) });
 const decodeLine = Schema.decodeUnknownOption(Schema.fromJsonString(Line));
 const decodeAssistant = Schema.decodeUnknownOption(Schema.fromJsonString(AssistantLine));
+const decodeCompaction = Schema.decodeUnknownOption(Schema.fromJsonString(CompactionLine));
+/** A compaction's line read: one is counted whatever else it says. */
+const compactionOf = (line) => {
+	const trigger = Option.getOrUndefined(decodeCompaction(line))?.compactMetadata.trigger;
+	const at = writtenAt(line);
+	const compaction = {};
+	if (trigger !== void 0) compaction.trigger = trigger;
+	if (at !== void 0) compaction.at = at;
+	return compaction;
+};
 /** What Claude Code names the model of a reply it wrote itself, such as an error: no model's. */
 const synthetic = "<synthetic>";
 /**
-* The replies in a transcript's whole lines, in order, or none if an assistant line can't be read,
-* since its tokens would go missing unseen. A line that isn't JSON is passed over: a read that
-* starts inside a line, after a transcript shrank, reads its tail as one.
+* The replies and compactions in a transcript's whole lines, in order, or none if an assistant
+* line can't be read, since its tokens would go missing unseen. A line that isn't JSON is passed
+* over: a read that starts inside a line, after a transcript shrank, reads its tail as one.
 */
-function repliesIn(text) {
+function transcriptIn(text) {
 	const replies = [];
+	const compactions = [];
 	for (const line of text.split("\n")) {
 		const kind = decodeLine(line);
-		if (Option.isNone(kind) || kind.value.type !== "assistant") continue;
+		if (Option.isNone(kind)) continue;
+		if (kind.value.type === "system" && kind.value.subtype === "compact_boundary") {
+			compactions.push(compactionOf(line));
+			continue;
+		}
+		if (kind.value.type !== "assistant") continue;
 		const assistant = decodeAssistant(line);
 		if (Option.isNone(assistant)) return Option.none();
 		const { model, id, usage } = assistant.value.message;
@@ -32670,8 +33534,17 @@ function repliesIn(text) {
 			cacheRead: usage.cache_read_input_tokens ?? 0
 		});
 	}
-	return Option.some(replies);
+	return Option.some({
+		replies,
+		compactions
+	});
 }
+/** A read that found nothing. */
+const nothingIn = {
+	replies: [],
+	steps: [],
+	compactions: []
+};
 /** A transcript never read: its top. */
 const top = {
 	offset: 0,
@@ -32704,6 +33577,23 @@ const KeptCounts = Schema.Struct({
 	cacheWrite: Count,
 	cacheRead: Count
 });
+const Known = Schema.Literals([
+	"waiting",
+	"read",
+	"failed"
+]);
+const KeptTally = Schema.Struct({
+	known: Known,
+	models: Schema.Array(Schema.Struct({
+		model: Schema.String,
+		...KeptCounts.fields
+	})),
+	replies: Schema.Array(Schema.Struct({
+		id: Schema.String,
+		model: Schema.String,
+		...KeptCounts.fields
+	}))
+});
 const KeptFile = Schema.Struct({
 	generation: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
 	read: Schema.Array(Schema.Struct({
@@ -32716,24 +33606,42 @@ const KeptFile = Schema.Struct({
 	turn: Schema.optionalKey(Schema.Struct({
 		number: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
 		facts: TurnFacts,
-		known: Schema.Literals([
-			"waiting",
-			"read",
-			"failed"
-		]),
-		models: Schema.Array(Schema.Struct({
-			model: Schema.String,
-			...KeptCounts.fields
+		startedAt: Schema.optionalKey(Count),
+		tokens: KeptTally,
+		context: Schema.Struct({
+			known: Known,
+			peak: Schema.optionalKey(Count),
+			compactions: Schema.Array(Schema.Struct({
+				trigger: Schema.optionalKey(Schema.Literals(["auto", "manual"])),
+				at: Schema.optionalKey(Count)
+			}))
+		}),
+		subagents: Schema.Array(Schema.Struct({
+			transcript: Schema.String,
+			type: Schema.optionalKey(Schema.String),
+			tokens: KeptTally
 		})),
-		replies: Schema.Array(Schema.Struct({
-			id: Schema.String,
-			model: Schema.String,
-			...KeptCounts.fields
-		}))
+		moreSubagents: Count
 	}))
 });
 const encodeKept = Schema.encodeSync(Schema.fromJsonString(KeptFile));
 const decodeKept = Schema.decodeUnknownOption(Schema.fromJsonString(KeptFile));
+const tallyFromFile = (tally) => ({
+	known: tally.known,
+	models: new Map(tally.models.map(({ model, ...counts }) => [model, counts])),
+	replies: new Map(tally.replies.map(({ id, ...reply }) => [id, reply]))
+});
+const tallyToFile = (tally) => ({
+	known: tally.known,
+	models: [...tally.models].map(([model, counts]) => ({
+		model,
+		...counts
+	})),
+	replies: [...tally.replies].map(([id, reply]) => ({
+		id,
+		...reply
+	}))
+});
 const fromFile = (file) => ({
 	generation: file.generation,
 	places: new Map(file.read.map(({ path, ...place }) => [path, place])),
@@ -32741,10 +33649,19 @@ const fromFile = (file) => ({
 	turn: Option.fromNullishOr(file.turn).pipe(Option.map((turn) => ({
 		number: turn.number,
 		facts: turn.facts,
-		tokens: {
-			known: turn.known,
-			models: new Map(turn.models.map(({ model, ...counts }) => [model, counts])),
-			replies: new Map(turn.replies.map(({ id, ...reply }) => [id, reply]))
+		startedAt: turn.startedAt,
+		reads: {
+			tokens: tallyFromFile(turn.tokens),
+			context: {
+				known: turn.context.known,
+				peak: turn.context.peak,
+				compactions: turn.context.compactions
+			},
+			subagents: new Map(turn.subagents.map(({ transcript, type, tokens }) => [transcript, {
+				type,
+				tokens: tallyFromFile(tokens)
+			}])),
+			moreSubagents: turn.moreSubagents
 		}
 	})))
 });
@@ -32758,20 +33675,32 @@ const toFile = (kept) => {
 		own: kept.own
 	};
 	if (Option.isSome(kept.turn)) {
-		const { number, facts, tokens } = kept.turn.value;
-		file.turn = {
+		const { number, facts, reads, startedAt } = kept.turn.value;
+		const { known, peak, compactions } = reads.context;
+		const turn = {
 			number,
 			facts,
-			known: tokens.known,
-			models: [...tokens.models].map(([model, counts]) => ({
-				model,
-				...counts
-			})),
-			replies: [...tokens.replies].map(([id, reply]) => ({
-				id,
-				...reply
-			}))
+			tokens: tallyToFile(reads.tokens),
+			context: peak === void 0 ? {
+				known,
+				compactions
+			} : {
+				known,
+				peak,
+				compactions
+			},
+			subagents: [...reads.subagents].map(([transcript, { type, tokens }]) => type === void 0 ? {
+				transcript,
+				tokens: tallyToFile(tokens)
+			} : {
+				transcript,
+				type,
+				tokens: tallyToFile(tokens)
+			}),
+			moreSubagents: reads.moreSubagents
 		};
+		if (startedAt !== void 0) turn.startedAt = startedAt;
+		file.turn = turn;
 	}
 	return file;
 };
@@ -32868,8 +33797,7 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 		const readOne = Effect.fnUntraced(function* (harness, transcript, from, until) {
 			const info = yield* fs.stat(transcript);
 			if (info.type !== "File") return {
-				replies: [],
-				steps: [],
+				...nothingIn,
 				whole: false,
 				to: from,
 				reached: false
@@ -32881,6 +33809,7 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 				const lost = harness === "codex" && (!same || from.running === void 0);
 				const replies = [];
 				const steps = [];
+				const compactions = [];
 				let at = lost ? yield* tailOf(file, size) : same ? from.offset : 0;
 				let running = lost ? totalLost : from.running;
 				let whole = !lost;
@@ -32899,6 +33828,7 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 					if (harness === "codex") {
 						const found = stepsIn(text, running ?? totalLost, until);
 						steps.push(...found.steps);
+						compactions.push(...found.compactions);
 						running = found.running;
 						whole &&= found.whole;
 						if (found.before !== void 0) {
@@ -32907,8 +33837,11 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 							break;
 						}
 					} else {
-						const found = repliesIn(text);
-						replies.push(...Option.getOrElse(found, () => []));
+						const found = transcriptIn(text);
+						if (Option.isSome(found)) {
+							replies.push(...found.value.replies);
+							compactions.push(...found.value.compactions);
+						}
 						whole &&= Option.isSome(found);
 					}
 					at += lines;
@@ -32917,6 +33850,7 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 				return {
 					replies,
 					steps,
+					compactions,
 					whole,
 					to: placeOf(at, hash, running),
 					reached
@@ -32969,25 +33903,27 @@ var Transcripts = class Transcripts extends Context.Service()("ref0/cli/Transcri
 			const state = yield* stateOf(owner);
 			const replies = [];
 			const steps = [];
+			const compactions = [];
 			const places = /* @__PURE__ */ new Map();
 			let whole = true;
 			for (const transcript of transcripts) {
 				const since = harness === "codex" ? turn?.since : void 0;
 				const from = state.places.get(transcript) ?? (since === void 0 ? top : yield* subagentStartOf(transcript, since));
 				const one = yield* readOne(harness, transcript, from, turn?.until).pipe(Effect.orElseSucceed(() => ({
-					replies: [],
-					steps: [],
+					...nothingIn,
 					whole: false,
 					to: from
 				})));
 				replies.push(...one.replies);
 				steps.push(...one.steps);
+				compactions.push(...one.compactions);
 				places.set(transcript, one.to);
 				whole &&= one.whole;
 			}
 			return {
 				replies,
 				steps,
+				compactions,
 				places,
 				whole
 			};
@@ -33172,6 +34108,8 @@ function withContext(answer, event, delivered) {
 //#region src/harness/hook-input.ts
 const decodeObjectText = Schema.decodeUnknownOption(Schema.fromJsonString(JsonObject));
 const filled = (text) => text === "" || text === null ? void 0 : text;
+/** Milliseconds as a hook's text says them, rounded; none for text that isn't a number. */
+const millisOf = (text) => text !== void 0 && /^\d{1,15}(\.\d+)?$/.test(text) ? Math.round(Number(text)) : void 0;
 const toolValue = (value) => {
 	if (value === void 0 || value === "") return void 0;
 	if (value instanceof Object) return value;
@@ -33185,22 +34123,26 @@ function readHook(args) {
 	};
 	const turn = filled(args.prompt_id) ?? filled(args.turn_id);
 	const agent = filled(args.agent_id);
+	const agentType = filled(args.agent_type);
 	const name = filled(args.tool_name);
 	const callId = filled(args.tool_use_id);
 	const input = toolValue(args.tool_input);
 	const response = toolValue(args.tool_response);
+	const durationMs = millisOf(filled(args.duration_ms));
 	const model = filled(args.model);
 	const cwd = filled(args.cwd);
 	const transcript = filled(args.transcript_path);
 	const agentTranscript = filled(args.agent_transcript_path);
 	if (turn !== void 0) hook.harnessTurn = turn;
 	if (agent !== void 0) hook.agent = agent;
+	if (agentType !== void 0) hook.agentType = agentType;
 	if (name !== void 0) hook.tool = callId === void 0 ? { name } : {
 		name,
 		callId
 	};
 	if (input instanceof Object) hook.toolInput = input;
 	if (response !== void 0) hook.toolResponse = response;
+	if (durationMs !== void 0) hook.durationMs = durationMs;
 	if (model !== void 0) hook.model = model;
 	if (cwd !== void 0) hook.cwd = cwd;
 	if (transcript !== void 0) hook.transcript = transcript;
@@ -33257,11 +34199,11 @@ const whyNotSaidYet = "Not said yet: the agent says why this thread is needed, a
 const startHarnessSession = Effect.fnUntraced(function* (input) {
 	const hostGrant = yield* HostGrant;
 	const keychain = yield* Keychain;
-	const config = yield* Ref0Config;
 	const harness = input.binding.harness === "codex" ? "codex" : "claude-code";
 	const folder = yield* (yield* ConfigFolders).folder(harness);
 	const grant = yield* hostGrant.get(folder);
 	if (Option.isNone(grant) || grant.value.harness !== harness) return Option.none();
+	const client = yield* grantClient(grant.value);
 	const pending = pendingAccount(input.binding);
 	const held = Option.flatMap(yield* keychain.get(sessionAccount(input.binding)), (kept) => parseToken(Redacted.value(kept)));
 	const resent = Option.filter(Option.flatMap(yield* keychain.get(pending), (kept) => decodePending(Redacted.value(kept))), (one) => !Option.exists(held, (parts) => parts.secret === one.secret));
@@ -33296,7 +34238,7 @@ const startHarnessSession = Effect.fnUntraced(function* (input) {
 		trigger: input.trigger,
 		attended: "reported"
 	});
-	const started = yield* (yield* ref0Client(config.api).pipe(Effect.provide(bearerCredential(grant.value.token)))).sessions.start({
+	const started = yield* client.sessions.start({
 		headers: { "idempotency-key": requestId },
 		payload
 	}).pipe(Effect.tapError((error) => Match.value(error).pipe(Match.tag("ProjectNotFound", "ProjectNotReady", "ThreadNotFound", "ThreadIsClosed", "TextRefused", "NotPermitted", "DeliveryOutsideWindow", () => keychain.remove(pending)), Match.orElse(() => Effect.void))));
@@ -33626,175 +34568,53 @@ const sessionTasks = Effect.gen(function* () {
 	};
 });
 //#endregion
-//#region src/harness/turn-facts.ts
-/** The most tool names a turn's record counts. */
-const toolNames = 100;
-/** The most replies a turn's tally remembers; a turn with more has its tokens unknown. */
-const turnReplies = 1e4;
-const nothingSeen = {
-	tools: /* @__PURE__ */ new Map(),
-	addresses: [],
-	more: 0,
-	model: void 0,
-	tokens: {
-		known: "waiting",
-		models: /* @__PURE__ */ new Map(),
-		replies: /* @__PURE__ */ new Map()
-	},
-	startedAt: void 0,
-	stoppedAt: void 0
-};
-/**
-* A hook seen at `at`: a tool call counted by its tool once it ran, the files an edit is about to
-* touch kept, at most 50 and the rest counted, the model, where the hook names one, and a `Stop`
-* as when the agent last stopped.
-*/
-function seeHook(seen, hook, edited, at) {
-	const tools = new Map(seen.tools);
-	const name = hook.tool?.name;
-	if (hook.event === "PostToolUse" && name !== void 0) {
-		const counted = tools.get(name);
-		if (counted !== void 0 || tools.size < toolNames) tools.set(name, (counted ?? 0) + 1);
-	}
-	const addresses = [...seen.addresses];
-	let more = seen.more;
-	for (const each of edited) {
-		if (addresses.some((kept) => kept.repo === each.repo && kept.path === each.path)) continue;
-		if (addresses.length < 50) addresses.push(each);
-		else more += 1;
-	}
-	return {
-		...seen,
-		tools,
-		addresses,
-		more,
-		model: hook.model ?? seen.model,
-		stoppedAt: hook.event === "Stop" ? at : seen.stoppedAt
-	};
-}
-/**
-* A read's replies added to a turn's, each by its message ID at the most any of its lines says:
-* a subagent's transcript writes a reply's output as it grows, line by line, so a line of a reply
-* already counted adds only what it grew. `own` when the read was of the session's own
-* transcript, which makes the turn's tokens known; nothing makes them known once a read has
-* failed.
-*/
-function addReplies(tally, replies, own) {
-	if (tally.known === "failed") return tally;
-	const models = new Map(tally.models);
-	const counted = new Map(tally.replies);
-	for (const reply of replies) {
-		const before = counted.get(reply.id);
-		const most = {
-			model: before?.model ?? reply.model,
-			input: Math.max(before?.input ?? 0, reply.input),
-			output: Math.max(before?.output ?? 0, reply.output),
-			cacheWrite: Math.max(before?.cacheWrite ?? 0, reply.cacheWrite),
-			cacheRead: Math.max(before?.cacheRead ?? 0, reply.cacheRead)
-		};
-		const sum = models.get(most.model);
-		counted.set(reply.id, most);
-		models.set(most.model, {
-			input: (sum?.input ?? 0) + most.input - (before?.input ?? 0),
-			output: (sum?.output ?? 0) + most.output - (before?.output ?? 0),
-			cacheWrite: (sum?.cacheWrite ?? 0) + most.cacheWrite - (before?.cacheWrite ?? 0),
-			cacheRead: (sum?.cacheRead ?? 0) + most.cacheRead - (before?.cacheRead ?? 0)
-		});
-	}
-	if (counted.size > turnReplies) return readFailed(tally);
-	return {
-		known: own ? "read" : tally.known,
-		models,
-		replies: counted
-	};
-}
-/**
-* A read's requests added to a turn's, by model, as Codex's rollout steps its running total.
-* `own` as for `addReplies`: a rollout is always the session's own.
-*/
-function addSteps(tally, steps, own) {
-	if (tally.known === "failed") return tally;
-	const models = new Map(tally.models);
-	for (const step of steps) {
-		const sum = models.get(step.model);
-		models.set(step.model, {
-			input: (sum?.input ?? 0) + step.input,
-			output: (sum?.output ?? 0) + step.output,
-			cacheWrite: (sum?.cacheWrite ?? 0) + step.cacheWrite,
-			cacheRead: (sum?.cacheRead ?? 0) + step.cacheRead
-		});
-	}
-	return {
-		...tally,
-		known: own ? "read" : tally.known,
-		models
-	};
-}
-/** A read that failed: the turn's tokens are unknown from then on. */
-const readFailed = (tally) => ({
-	...tally,
-	known: "failed"
-});
-/** A read's replies and requests added to a turn's tokens, or its tokens unknown if it failed. */
-const addRead = (tally, read, own) => read.whole ? addSteps(addReplies(tally, read.replies, own), read.steps, own) : readFailed(tally);
-/**
-* A turn's tokens as ref0 keeps them: each model's counts once the session's own transcript is
-* read, or unknown, with no counts, where it wasn't, a read failed, or a count passes what a
-* turn may hold.
-*/
-function turnTokens(tally) {
-	if (tally.known !== "read" || tally.models.size > 16) return { known: "unknown" };
-	const models = [...tally.models].map(([model, counts]) => ({
-		model,
-		...counts
-	}));
-	return models.every((each) => Math.max(each.input, each.output, each.cacheWrite, each.cacheRead) <= 1e8 && each.model.length >= 1 && each.model.length <= 128) ? {
-		known: "read",
-		models
-	} : { known: "unknown" };
-}
-/**
-* A turn's facts as ref0 keeps them, with its stop as how long after ref0 started it the agent last
-* stopped: none until both are seen, and 0 for a `Stop` before its start landed.
-*/
-function turnFacts(seen) {
-	const facts = {
-		modelSource: seen.model === void 0 ? "unknown" : "hook",
-		tools: Object.fromEntries(seen.tools),
-		addresses: seen.addresses,
-		more: seen.more,
-		tokens: turnTokens(seen.tokens)
-	};
-	if (seen.model !== void 0) facts.model = seen.model;
-	if (seen.startedAt !== void 0 && seen.stoppedAt !== void 0) facts.stoppedAfterMs = Math.max(seen.stoppedAt - seen.startedAt, 0);
-	return facts;
-}
-//#endregion
 //#region src/harness/session-turns.ts
 /** The open turn as `SessionEnd` tells it once more: none until ref0 has numbered it. */
 const keptOf = (now) => now.kind === "open" ? Option.some({
 	number: now.number,
 	facts: turnFacts(now.seen),
-	tokens: now.seen.tokens
+	reads: now.seen,
+	startedAt: now.seen.startedAt
 }) : Option.none();
 /**
-* The transcripts a hook's read takes, and whether the session's own is among them: at the
-* tracked turn's own `Stop`, the session's; at any subagent's `SubagentStop`, its own, whichever
-* turn started it, since it adds to the turn still open, with the turn Codex names there, the
-* subagent's own, where its rollout's own part starts. A new turn's prompt reads the session's
-* first, for the turn it ends.
+* The transcripts a hook's read takes, and whose they are: at the tracked turn's own `Stop`, the
+* session's; at any subagent's `SubagentStop`, its own, whichever turn started it, since it adds
+* to the turn still open, with the turn Codex names there, the subagent's own, where its
+* rollout's own part starts, and its type. A new turn's prompt reads the session's first, for
+* the turn it ends.
 */
 const toRead = (hook, ownHook) => {
 	if (hook.event === "Stop" && ownHook && hook.transcript !== void 0) return {
 		transcripts: [hook.transcript],
-		own: true
+		of: { own: true }
 	};
 	if (hook.event === "SubagentStop" && hook.agentTranscript !== void 0) return {
 		transcripts: [hook.agentTranscript],
-		own: false,
+		of: {
+			own: false,
+			subagent: hook.agentTranscript,
+			type: hook.agentType
+		},
 		turn: { since: hook.harnessTurn }
 	};
 };
+/** A read that couldn't happen, as of a subagent whose harness kept no transcript of it. */
+const unread = {
+	replies: [],
+	steps: [],
+	compactions: [],
+	whole: false
+};
+/**
+* A subagent's `SubagentStop` that names no transcript of it, as Codex's in a session kept
+* nowhere: the subagent counted by its ID, with its type, and its tokens, and so the turn's,
+* unknown, since what it used can't be read.
+*/
+const untranscribed = (hook) => hook.event === "SubagentStop" && hook.agentTranscript === void 0 ? {
+	own: false,
+	subagent: `agent:${hook.agent ?? ""}`,
+	type: hook.agentType
+} : void 0;
 /** A harness session's turns, each numbered by ref0 as it starts. */
 const sessionTurns = Effect.fnUntraced(function* (edges) {
 	const transcripts = yield* Transcripts;
@@ -33815,7 +34635,11 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 		const ending = prompted === void 0 ? void 0 : yield* transcripts.read(owner, harness, [prompted], { until: harnessTurn });
 		const fresh = late && harness === "claude-code" ? {
 			...nothingSeen,
-			tokens: readFailed(nothingSeen.tokens)
+			tokens: readFailed(nothingSeen.tokens),
+			context: {
+				...nothingSeen.context,
+				known: "failed"
+			}
 		} : nothingSeen;
 		const tracked = isNew ? Option.some({
 			kind: "starting",
@@ -33824,7 +34648,7 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 				turn: now.number,
 				seen: ending === void 0 ? now.seen : {
 					...now.seen,
-					tokens: addRead(now.seen.tokens, ending, true)
+					...addRead(now.seen, ending, { own: true })
 				}
 			}) : now.previous),
 			seen: fresh
@@ -33836,9 +34660,13 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 		const hooked = ownHook && !isNew ? seeHook(tracked.value.seen, hook, edited, yield* Clock.currentTimeMillis) : tracked.value.seen;
 		const reading = toRead(hook, ownHook);
 		const read = reading === void 0 ? void 0 : yield* transcripts.read(owner, harness, reading.transcripts, reading.turn);
-		const seen = read === void 0 || reading === void 0 ? hooked : {
+		const unseen = untranscribed(hook);
+		const seen = read === void 0 || reading === void 0 ? unseen === void 0 ? hooked : {
+			...hooked,
+			...addRead(hooked, unread, unseen)
+		} : {
 			...hooked,
-			tokens: addRead(hooked.tokens, read, reading.own)
+			...addRead(hooked, read, reading.of)
 		};
 		const places = (read ?? ending)?.places;
 		let now = {
@@ -33847,7 +34675,7 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 		};
 		yield* Effect.uninterruptible(Effect.gen(function* () {
 			yield* Ref.set(turn, Option.some(now));
-			if (places !== void 0) yield* transcripts.keep(owner, places, keptOf(now));
+			if (places !== void 0 || unseen !== void 0) yield* transcripts.keep(owner, places ?? /* @__PURE__ */ new Map(), keptOf(now));
 		}));
 		if (now.kind === "starting") {
 			if (Option.isSome(now.previous)) yield* edges.tasksLanded(client, bound, deadline);
@@ -33898,7 +34726,7 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 		if (ownHook && hook.event === "Stop") {
 			yield* edges.tasksLanded(client, bound, deadline);
 			yield* tellFacts;
-		} else if (hook.event === "SubagentStop" && read !== void 0) yield* tellFacts;
+		} else if (hook.event === "SubagentStop" && (read !== void 0 || unseen !== void 0)) yield* tellFacts;
 	});
 	return {
 		now: Ref.get(turn),
@@ -34302,7 +35130,7 @@ const endWithin = "5 seconds";
 const lastReadWithin = "2 seconds";
 /**
 * The turn `ref0 mcp` last told ref0 of, told once more with what the session's transcript
-* gained since: a reply written after its last `Stop` counts in it, and a `Stop` whose facts
+* gained since: a reply or a compaction written after its last `Stop` counts in it, and a `Stop` whose facts
 * didn't land has them sent again. Nothing for a turn ref0 hasn't numbered.
 */
 const lastRead = Effect.fnUntraced(function* (client, session, harness, transcript) {
@@ -34315,7 +35143,7 @@ const lastRead = Effect.fnUntraced(function* (client, session, harness, transcri
 	};
 	const turn = kept.value.turn.value;
 	const read = transcript === null || transcript === void 0 || transcript === "" ? void 0 : yield* transcripts.read(owner, harness, [transcript]);
-	const tokens = read === void 0 ? turn.tokens : addRead(turn.tokens, read, true);
+	const reads = read === void 0 ? turn.reads : addRead(turn.reads, read, { own: true });
 	yield* client.sessions.turnFacts({
 		params: {
 			session,
@@ -34325,7 +35153,7 @@ const lastRead = Effect.fnUntraced(function* (client, session, harness, transcri
 			generation: owner.generation,
 			facts: {
 				...turn.facts,
-				tokens: turnTokens(tokens)
+				...readFacts(reads, turn.startedAt)
 			}
 		}
 	});
@@ -34872,25 +35700,35 @@ const wordsOf = (report, home) => {
 	}, ...check.next === void 0 ? [] : [{ command: check.next }]])];
 };
 const refused = () => Effect.succeed({ kind: "refused" });
-const whoIs = Effect.fnUntraced(function* (token) {
-	const config = yield* Ref0Config;
-	return yield* (yield* ref0Client(config.api).pipe(Effect.provide(bearerCredential(token)))).me.get().pipe(Effect.timeout("10 seconds"), Effect.map((me) => ({
-		kind: "accepted",
-		me
-	})), Effect.catchTags({
-		Unauthenticated: refused,
-		SessionHasEnded: refused
-	}), Effect.orElseSucceed(() => ({ kind: "unanswered" })));
-});
+const unsigned = (failed) => Effect.succeed({
+	kind: "unsigned",
+	nextStep: failed.nextStep
+});
+/** Asks ref0 who a client's credential is. */
+const whoIs = (client) => client.me.get().pipe(Effect.timeout("10 seconds"), Effect.map((me) => ({
+	kind: "accepted",
+	me
+})), Effect.catchTags({
+	Unauthenticated: refused,
+	SessionHasEnded: refused,
+	InvalidDpopProof: refused,
+	KeyStoreUnavailable: unsigned
+}), Effect.orElseSucceed(() => ({ kind: "unanswered" })));
+/** A session's token, as a bearer token: sessions aren't bound to a key yet. */
+const sessionClient = (token) => Effect.flatMap(Ref0Config, (config) => ref0Client(config.api).pipe(Effect.provide(bearerCredential(token))));
 const unansweredWords = (api) => `ref0 didn’t answer at ${api}.`;
 /** Check the grant kept for this folder, without borrowing another folder's authority. */
 const grantChecks = Effect.fnUntraced(function* (grant, configFolder) {
-	const asked = yield* whoIs(grant.token);
+	const asked = yield* grantClient(grant).pipe(Effect.flatMap(whoIs), Effect.catchTags({
+		InvalidDpopProof: refused,
+		KeychainError: unsigned
+	}));
 	const connected = checkOf("connected", "yes", "this machine holds its grant");
 	switch (asked.kind) {
 		case "accepted": return [connected, checkOf("accepted", "yes", "ref0 accepts its grant")];
 		case "refused": return [connected, checkOf("accepted", "no", "ref0 refuses its grant", yield* connectLineFor(grant.harness, configFolder))];
 		case "unanswered": return [connected, checkOf("accepted", "unknown", unansweredWords((yield* Ref0Config).api), "ref0 status")];
+		case "unsigned": return [connected, checkOf("accepted", "unknown", "this machine’s key couldn’t sign to ask", asked.nextStep)];
 	}
 });
 /** Protocol mismatches either update this CLI or reinstall this folder's plugin. */
@@ -34982,11 +35820,12 @@ const sessionCheck = Effect.fnUntraced(function* (harness, configFolder) {
 	const token = yield* Effect.result((yield* Keychain).get(sessionAccount(binding.value)));
 	if (Result.isFailure(token)) return checkOf("session", "unknown", `The keychain didn’t say whether ref0 follows this ${configFolders[harness].name} session.`, token.failure.nextStep);
 	if (Option.isNone(token.success)) return checkOf("session", "no", "start a new session in this folder", launch);
-	const asked = yield* whoIs(token.success.value);
+	const asked = yield* Effect.flatMap(sessionClient(token.success.value), whoIs);
 	switch (asked.kind) {
 		case "accepted": return asked.me.session === void 0 ? checkOf("session", "no", "start a new session in this folder", launch) : checkOf("session", "yes", `ref0 follows this session as ${asked.me.session.session}`);
 		case "refused": return checkOf("session", "no", "ref0 no longer follows this session", launch);
-		case "unanswered": return checkOf("session", "unknown", unansweredWords((yield* Ref0Config).api), "ref0 status");
+		case "unanswered":
+		case "unsigned": return checkOf("session", "unknown", unansweredWords((yield* Ref0Config).api), "ref0 status");
 	}
 });
 const statusCommands = [Command.make(harnessCommandNames.status, { json }, ({ json: asJson }) => Effect.gen(function* () {
@@ -35090,9 +35929,19 @@ const services = Layer.mergeAll(cliOutput, Ref0.layer.pipe(Layer.provide([
 	Ref0Config.layer,
 	sessionToken,
 	FetchHttpClient.layer
-])), sessionToken, harnessSessionThread.pipe(Layer.provide([keychain, harnessProcess])), FetchHttpClient.layer, keychain, HostGrant.layer.pipe(Layer.provide(keychain)), OldHostGrants.layer, ConnectLock.layer.pipe(Layer.provide(Processes.layer)), Machine.layer, Tty.layer, harnessProcess, Checkout.layer.pipe(Layer.provide(NodeServices.layer)), BaseChecks.layer.pipe(Layer.provide([Ref0Config.layer, FetchHttpClient.layer])), Attribution.layer.pipe(Layer.provide([Commits.layer, Checkout.layer])), HarnessTasks.layer, Transcripts.layer, Waker.layer, LiveHints.layer).pipe(Layer.provideMerge(ConfigFolders.layer), Layer.provideMerge(Ref0Config.layer), Layer.provideMerge(NodeServices.layer));
+])), sessionToken, harnessSessionThread.pipe(Layer.provide([keychain, harnessProcess])), FetchHttpClient.layer, keychain, MachineKey.layer.pipe(Layer.provide(keychain)), ProofClock.layer, HostGrant.layer.pipe(Layer.provide(keychain)), OldHostGrants.layer, ConnectLock.layer.pipe(Layer.provide(Processes.layer)), Machine.layer, Tty.layer, harnessProcess, Checkout.layer.pipe(Layer.provide(NodeServices.layer)), BaseChecks.layer.pipe(Layer.provide([Ref0Config.layer, FetchHttpClient.layer])), Attribution.layer.pipe(Layer.provide([Commits.layer, Checkout.layer])), HarnessTasks.layer, Transcripts.layer, Waker.layer, LiveHints.layer).pipe(Layer.provideMerge(ConfigFolders.layer), Layer.provideMerge(Ref0Config.layer), Layer.provideMerge(NodeServices.layer));
+//#endregion
+//#region src/root.ts
+/**
+* The CLI's root, around every command and the services it's given. A request's error holds the
+* request it was sent with, and a request a key signed holds its proof, which is good for a
+* minute, so `dpop` is redacted wherever one is printed, as `authorization` is. A failure no
+* command said, a service that couldn't be built included, is logged here, inside that redaction,
+* rather than by `runMain`, which logs outside it.
+*/
+const atRoot = (services) => (program) => program.pipe(Effect.provide(services), Effect.tapCause((cause) => Cause.hasInterruptsOnly(cause) || !Runtime.getErrorReported(Cause.squash(cause)) ? Effect.void : Effect.logError(cause)), Effect.provideServiceEffect(Headers.CurrentRedactedNames, Effect.map(Effect.service(Headers.CurrentRedactedNames), (names) => [...names, "dpop"])));
 //#endregion
 //#region src/main.ts
-ref0.pipe(Command.run({ version: cliVersion }), Effect.provide(services), NodeRuntime.runMain);
+ref0.pipe(Command.run({ version: cliVersion }), atRoot(services), NodeRuntime.runMain({ disableErrorReporting: true }));
 //#endregion
 export {};