@ref0/cli 0.9.0 → 0.11.0

package/dist/main.mjs

@@ -1,6 +1,6 @@
 #!/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, 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 { 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 { HttpApi, HttpApiClient, HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, HttpApiSecurity } from "effect/http-api";
@@ -11,7 +11,7 @@ import { access, constants } from "node:fs/promises";
 import { hostname } from "node:os";
 import { connect, createServer as createServer$1 } from "node:net";
 import { join } from "node:path";
-import { McpProtocol, McpServer, Tool, Toolkit } from "effect/ai";
+import { McpProtocol, McpSchema, McpServer, Tool, Toolkit } from "effect/ai";
 //#region ../contracts/src/typeid.ts
 /**
 * TypeIDs: a prefix, an underscore, then a UUID in 26 characters of Crockford's base32,
@@ -5486,12 +5486,15 @@ const name$1 = ownerNamePattern.source.replace(/^\^|\$$/g, "");
 const projectPattern = new RegExp(`^(${name$1})/(${name$1})$`);
 const threadPattern = new RegExp(`^(${name$1})(?:/(${name$1}))?#([1-9][0-9]*)$`);
 const repoPattern = new RegExp(`^(${name$1})/(${repoNamePattern.source.replace(/^\^|\$$/g, "")})$`);
+const pullRequestPattern = new RegExp(`${repoPattern.source.replace(/\$$/, "")}#[1-9][0-9]*$`);
 /** A project, `owner/project`. */
 const WrittenProject = Schema.String.check(Schema.isPattern(projectPattern)).pipe(Schema.brand("WrittenProject"));
 /** A thread, `owner/project#number`, or an org thread, `owner#number`. */
 const WrittenThread = Schema.String.check(Schema.isPattern(threadPattern)).pipe(Schema.brand("WrittenThread"));
 /** A repo, `owner/repo`. */
 const WrittenRepo = Schema.String.check(Schema.isPattern(repoPattern)).pipe(Schema.brand("WrittenRepo"));
+/** A pull request, `owner/repo#number`. */
+const WrittenPullRequest = Schema.String.check(Schema.isPattern(pullRequestPattern)).pipe(Schema.brand("WrittenPullRequest"));
 /** A written repo's parts: its owner, as an endpoint's path takes it, and its name. */
 const repoParts = (written) => {
 	const [, owner = "", repo = ""] = repoPattern.exec(written) ?? [];
@@ -6767,383 +6770,6 @@ Schema.Union([Schema.Struct({ found: Schema.Literal(false) }), Schema.Struct({
 	attachGrant: Schema.optionalKey(EventId)
 })]);
 //#endregion
-//#region ../contracts/src/approvals.ts
-/**
-* Approvals, as their commands travel: what a terminal, a page or an agent asks its person to
-* say yes to. A command is one endpoint, by its name in the surface table, and its request, as
-* that endpoint encodes it. ref0 decodes each part by the endpoint's own `Schema` before it
-* keeps or shows anything, so a command is exactly what the endpoint would take.
-*/
-/**
-* An endpoint by its name in the surface table, `group.endpoint`. Checked against the table
-* where the command is made canonical, since the table is typed from the API this is part of.
-*/
-const CommandEndpoint = Schema.String.check(Schema.isPattern(/^[a-zA-Z]+\.[a-zA-Z]+$/));
-/** One command, as asked: its endpoint, and its request's path, query and payload, encoded. */
-const ApprovalCommand = Schema.Struct({
-	endpoint: CommandEndpoint,
-	params: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
-	query: Schema.optionalKey(Schema.JsonObject),
-	payload: Schema.optionalKey(Schema.Json)
-});
-/** A command ref0 won't ask anyone about: not an endpoint's request, or not one an approval runs. */
-var CommandRefused = class extends Schema.TaggedError()("CommandRefused", { nextStep: Schema.String }, { httpApiStatus: 400 }) {};
-/** A terminal asking: its command, and the hash of the secret it collects the result with. */
-const StartApproval = Schema.Struct({
-	command: ApprovalCommand,
-	secretHash: SecretHash
-});
-/** A terminal's approval, started: what to show its person, and until when. */
-const ApprovalStarted = Schema.Struct({
-	approval: ApprovalId,
-	code: ApprovalCode,
-	expiresAt: Timestamp
-});
-/**
-* An answer that waits for the person: the call only the person may make, or that agents ask
-* for, became an approval, which the person answers on their own page. A `202`, never a failure
-* of the call: whoever asked collects the result with `GET /v1/approvals/{approval}`.
-*/
-var ApprovalNeeded = class extends Schema.TaggedError()("ApprovalNeeded", {
-	approval: ApprovalId,
-	says: Schema.String,
-	expiresAt: Timestamp
-}, { httpApiStatus: 202 }) {};
-const terminalAsker = Schema.Struct({ kind: Schema.Literal("terminal") });
-const pageAsker = Schema.Struct({ kind: Schema.Literal("page") });
-const agentAsker = Schema.Struct({
-	kind: Schema.Literal("agent"),
-	agent: AgentId,
-	handle: AgentHandle,
-	session: SessionId,
-	/** The attachment its credential was made under, for a person's agent in an organization. */
-	attachment: Schema.optionalKey(CredentialRef)
-});
-/**
-* Who asked, as a receipt keeps it: a terminal, one of ref0's pages, an agent, or a machine
-* asking to connect, by its ID and its own word for itself, and from where.
-*/
-const ApprovalAsker = Schema.Union([
-	terminalAsker,
-	pageAsker,
-	Schema.Struct({
-		kind: Schema.Literal("machine"),
-		machine: MachineId,
-		machineName: MachineName,
-		askedFrom: Schema.optionalKey(Schema.String)
-	}),
-	agentAsker
-]);
-/**
-* Who asked, as the person reads a request before they answer: a terminal, a page or an agent.
-* A machine's request is read as an `AttachmentRequestView`, never as a command.
-*/
-const ApprovalViewAsker = Schema.Union([
-	terminalAsker,
-	pageAsker,
-	agentAsker
-]);
-/** A request, as the person reads it before they answer. */
-const ApprovalView = Schema.Struct({
-	approval: ApprovalId,
-	/** The command as its CLI line. */
-	says: Schema.String,
-	/** Everything the command carries, each named, in order: nothing it would run is left out. */
-	fields: Schema.Array(Schema.Struct({
-		name: Schema.String,
-		value: Schema.String,
-		part: Schema.Literals([
-			"path",
-			"query",
-			"payload"
-		])
-	})),
-	command: ApprovalCommand,
-	asker: ApprovalViewAsker,
-	askedFrom: Schema.optionalKey(Schema.String),
-	askedAt: Timestamp,
-	expiresAt: Timestamp,
-	/**
-	* An agent's ask: the kind of action its answer may set agents' permission for, and whether a
-	* yes may let agents take it without asking. A no with the passkey may always stop them asking.
-	*/
-	agentPermission: Schema.optionalKey(Schema.Struct({
-		action: ScopeAction,
-		mayAllow: Schema.Boolean
-	})),
-	/**
-	* What the command acts on, drawn as ref0 resolves it for the person reading, where its
-	* endpoint names a preview. Without one the page can draw, it offers only no.
-	*/
-	preview: Schema.optionalKey(ApprovalPreview)
-});
-/** A statement's hash: the SHA-256 of its words and quoted values as JSON, as lowercase hex. */
-const StatementHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
-/**
-* Who asks for a yes to a statement: a workflow's run, `passkey.run`'s, by the workflow and the
-* run; or a gate's check, `passkey.check`'s, by the check, the pull request's version it gates and
-* the check run its statement is over.
-*/
-const StatementAsker = Schema.Union([Schema.Struct({
-	kind: Schema.Literal("workflow"),
-	workflow: WorkflowName,
-	run: WorkflowRunId
-}), Schema.Struct({
-	kind: Schema.Literal("gate"),
-	check: CheckKey,
-	pullRequest: PullRequestNumber,
-	version: VersionNumber,
-	run: CheckRunId
-})]);
-/**
-* A passkey request, as the person reads it before they answer: the statement, its words as its
-* asker wrote them and each value it quotes, and its hash; who asks; where, a workflow's
-* `owner/repo` or a thread's `owner/project#number`, or a gate's pull request, `owner/repo#number`;
-* whom it asks, the run's accountable person, or for a gate the person behind its run, a person by
-* name, or a permission's holders; and until when.
-*/
-const StatementView = Schema.Struct({
-	approval: ApprovalId,
-	statement: WorkflowText,
-	hash: StatementHash,
-	asker: StatementAsker,
-	home: Schema.String,
-	from: Schema.Union([Schema.Literals(["accountable", "person"]), Schema.Struct({ permission: RepoPermissionName })]),
-	askedAt: Timestamp,
-	expiresAt: Timestamp
-});
-/**
-* The person's own requests, waiting for them; the passkey requests workflows' runs and gates asked
-* them; and each machine's request this browser session is the answerer of, so a reload finds it
-* again without its code.
-*/
-const ApprovalsWaiting = Schema.Struct({
-	approvals: Schema.Array(ApprovalView),
-	statements: Schema.Array(StatementView),
-	requests: Schema.Array(AttachmentRequestView)
-});
-/** Finding a terminal's request by the code it showed. */
-const FindApproval = Schema.Union([Schema.Struct({ code: TypedApprovalCode }), Schema.Struct({ link: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{22}$/)) })]);
-/**
-* Asking for the passkey's options to answer a request: a terminal's request needs its code
-* again, so its ID alone, which travels where its code doesn't, never answers it. A machine's
-* request needs its answerer, and the agent it chooses to connect, before a yes has options.
-*/
-const ApprovalOptionsRequest = Schema.Struct({
-	code: Schema.optionalKey(TypedApprovalCode),
-	folders: Schema.optionalKey(ConnectFolderChoices)
-});
-/**
-* An answer: yes, with the passkey, or no. For an agent's ask, each answer can set the owner's
-* permission its own way, so a pairing that can't happen can't be sent: yes, and let agents do
-* it without asking; no, and stop agents asking, with the passkey too.
-*/
-const AnswerApproval = Schema.Union([
-	Schema.Struct({
-		answer: Schema.Literal("yes"),
-		permission: Schema.optionalKey(Schema.Literal("allow")),
-		assertion: PasskeyAsserted,
-		code: Schema.optionalKey(TypedApprovalCode),
-		/** The preview the page drew, where the command's endpoint names one. */
-		preview: Schema.optionalKey(PreviewEcho),
-		/** The statement the page showed, by its hash, for a workflow run's or a gate's passkey request. */
-		statement: Schema.optionalKey(Schema.Struct({ hash: StatementHash }))
-	}),
-	Schema.Struct({
-		answer: Schema.Literal("no"),
-		permission: Schema.Literal("deny"),
-		assertion: PasskeyAsserted,
-		code: Schema.optionalKey(TypedApprovalCode)
-	}),
-	Schema.Struct({
-		answer: Schema.Literal("no"),
-		code: Schema.optionalKey(TypedApprovalCode)
-	})
-]);
-/**
-* What running an approved command came to: its status, and its endpoint's answer or refusal,
-* as JSON. ref0 reads it by the command's endpoint before anyone sees it, and whoever asked reads
-* it the same way, with `ranOf`: this schema is part of the API the endpoints' types come from,
-* so it can't be typed by them itself.
-*/
-const Ran = Schema.Struct({
-	status: Schema.Int,
-	result: Schema.Json
-});
-/**
-* A ran command whose answer its endpoint's schemas no longer read, such as one kept from
-* before they changed: it ran, and what it came to can't be said.
-*/
-var ResultUnreadable = class extends Schema.TaggedError()("ResultUnreadable", { nextStep: Schema.String }, { httpApiStatus: 500 }) {};
-/**
-* Where a request stands, for whoever asked: still waiting; approved, and running as soon as
-* ref0 can; refused; expired; or what it ran to, with the endpoint it ran, whose schemas read it.
-*/
-const ApprovalState = Schema.Union([
-	Schema.Struct({
-		state: Schema.Literal("waiting"),
-		expiresAt: Timestamp
-	}),
-	Schema.Struct({
-		state: Schema.Literal("approved"),
-		/** A machine's answering browser may forget its saved answer once the terminal kept it. */
-		collected: Schema.optionalKey(Schema.Literal(true))
-	}),
-	Schema.Struct({ state: Schema.Literal("refused") }),
-	Schema.Struct({ state: Schema.Literal("expired") }),
-	Schema.Struct({
-		state: Schema.Literal("ran"),
-		endpoint: CommandEndpoint,
-		...Ran.fields
-	})
-]);
-/** Only the answering browser receives a machine's answer code; state reads never carry it. */
-const ApprovalAnswer = Schema.Union([
-	Schema.Struct({
-		...ApprovalState.members[1].fields,
-		answerCode: ApprovalCode
-	}),
-	Schema.Struct({
-		...ApprovalState.members[4].fields,
-		answerCode: ApprovalCode
-	}),
-	ApprovalState
-]);
-/** A request that isn't there, or isn't the caller's to see, answers the same. */
-var ApprovalNotFound = class extends Schema.TaggedError()("ApprovalNotFound", { nextStep: Schema.String }, { httpApiStatus: 404 }) {};
-/** Too many asked, or too many codes typed, from here in the last hour. */
-var SlowDown = class extends Schema.TaggedError()("SlowDown", { nextStep: Schema.String }, { httpApiStatus: 429 }) {};
-/** A command's hash: the SHA-256 of its canonical JSON, as lowercase hex. */
-const CommandHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
-Schema.Struct({
-	approval: ApprovalId,
-	endpoint: CommandEndpoint,
-	/** The command's canonical JSON. */
-	command: Schema.String,
-	commandHash: CommandHash,
-	asker: ApprovalAsker,
-	/** The browser session the person answered in, for their log. */
-	credential: CredentialRef,
-	generation: Generation,
-	/** When the request expires, in epoch milliseconds. */
-	deadline: Schema.Int,
-	challenge: Schema.String,
-	/** A machine answer retries only from its answering session, with this key. */
-	answerKey: Schema.optionalKey(RequestId),
-	/** An agent's ask: the credential it asked with, checked again before the answer counts. */
-	asking: Schema.optionalKey(TokenId),
-	/** The kind of action the person, answering, let agents take without asking from now on. */
-	allow: Schema.optionalKey(ScopeAction)
-});
-Schema.Struct({
-	approval: ApprovalId,
-	action: ScopeAction,
-	credential: CredentialRef,
-	generation: Generation
-});
-Schema.Union([Schema.Struct({ denied: Schema.Literal(true) }), Schema.Struct({
-	denied: Schema.Literal(false),
-	reason: Schema.Literals(["generation moved", "not set up"])
-})]);
-Schema.Union([Schema.Struct({
-	admitted: Schema.Literal(true),
-	admittedAt: Schema.Int,
-	answerCode: Schema.optionalKey(ApprovalCode)
-}), Schema.Struct({
-	admitted: Schema.Literal(false),
-	reason: Schema.Literals([
-		"expired",
-		"generation moved",
-		"challenge used",
-		"not set up",
-		"asker gone"
-	])
-})]);
-Schema.Union([Schema.Struct({ found: Schema.Literal(false) }), Schema.Struct({
-	found: Schema.Literal(true),
-	endpoint: CommandEndpoint,
-	command: Schema.String,
-	commandHash: CommandHash,
-	generation: Generation,
-	generationNow: Generation,
-	/** The `approval.answered` its admission recorded in the person's log. */
-	answeredEvent: EventId,
-	/** Who asked, as that `approval.answered` says. */
-	asker: ApprovalAsker,
-	/** What running it came to, once it ran, as `KeptRan` keeps it. */
-	result: Schema.optionalKey(Schema.String)
-})]);
-/**
-* A `Ran` as it's kept, on its receipt and on its approval: its JSON, as text. The Owner DO
-* keeps it as it comes and runs no endpoint's schemas, so it's read only by its endpoint, with
-* `keptRan`, which refuses one they don't take.
-*/
-const KeptRan = Schema.fromJsonString(Ran);
-Schema.Struct({
-	approval: ApprovalId,
-	result: Schema.String
-});
-Schema.Struct({ result: Schema.String });
-Schema.Struct({ approval: ApprovalId });
-Schema.Struct({ approval: ApprovalId });
-Schema.Union([Schema.Struct({ expired: Schema.Literal(true) }), Schema.Struct({ expired: Schema.Literal(false) })]);
-Schema.Struct({
-	person: PersonId,
-	approval: ApprovalId
-});
-//#endregion
-//#region ../contracts/src/browser-sessions.ts
-/**
-* A browser session's cookie: Better Auth's, named for ref0, `Secure` and host-only on the
-* app's one origin. It holds the session's token, signed; the directory and the person's Owner DO hold
-* only the token's SHA-256.
-*/
-const browserSessionCookie = "__Secure-ref0.session_token";
-Schema.Struct({
-	token: TokenId,
-	secretHash: SecretHash,
-	expiresAt: Schema.DateTimeUtcFromMillis
-});
-Schema.Struct({ registered: Schema.Boolean });
-/**
-* Where a signed-in person stands: naming, when the name their GitHub login gave was taken or
-* kept back, with that login as a suggestion; setting up, once their owner is made and before
-* it's ready with this session registered, which naming again finishes; or ready.
-*/
-const Welcome = Schema.Union([Schema.Struct({
-	state: Schema.Literals(["ready", "setting up"]),
-	person: PersonId,
-	owner: OwnerId,
-	name: OwnerName
-}), Schema.Struct({
-	state: Schema.Literal("naming"),
-	person: PersonId,
-	suggestion: Schema.optionalKey(Schema.String)
-})]);
-/**
-* A browser session renewed: its expiry, in its person's Owner DO and in the directory, and on its cookie.
-* Renewed at most once a day, so one asked sooner answers its expiry unchanged.
-*/
-const SessionRenewed = Schema.Struct({ expiresAt: Schema.DateTimeUtcFromMillis });
-/**
-* What starting a GitHub sign-in at `POST /auth/sign-in/social` answers: GitHub's address to go
-* to, with the sign-in's state in a cookie set alongside. Better Auth's answer, which ref0 serves.
-*/
-const NavigationUrl = Schema.String.check(Schema.isPattern(/^https?:\/\/[^\s/]+(?:\/[^\s]*)?$/), Schema.makeFilter((url) => URL.canParse(url) || "an HTTP(S) URL the platform can parse")).pipe(Schema.brand("NavigationUrl"));
-Schema.Struct({ url: NavigationUrl });
-/**
-* Where signing in sends the browser back to, as `POST /auth/sign-in/social` takes it: a path on
-* ref0's own origin, such as `/welcome`, or a whole URL. Never a socket's.
-*/
-const SignInDestination = Schema.String.pipe(Schema.brand("SignInDestination"));
-Schema.Struct({
-	provider: Schema.Literal("github"),
-	callbackURL: SignInDestination,
-	errorCallbackURL: SignInDestination
-});
-/** The name a naming person chose for their owner. */
-const NameOwner = Schema.Struct({ name: OwnerName });
-//#endregion
 //#region ../contracts/src/plan-events.ts
 /**
 * A plan's events, in its thread's project's log, written by the Project DO. A version's
@@ -7282,6 +6908,21 @@ const DecisionView = Schema.Struct({
 	closedWhy: Schema.optionalKey(DecisionClosedWhy)
 });
 /**
+* Where a decision is, as people write it: its thread, `pip/default#3`, or an org thread's,
+* `acme#7`; and a gate's pull request, `pip/notes#1`. Its Project DO writes them as it answers,
+* from its own threads and repos and the owner's name the Worker gives it, so each reads as it's
+* called now.
+*/
+const DecisionNames = Schema.Struct({
+	thread: WrittenThread,
+	pullRequest: Schema.optionalKey(WrittenPullRequest)
+});
+/** A decision as `/v1` answers it: as it stands, and where it is, in words. */
+const NamedDecision = Schema.Struct({
+	...DecisionView.fields,
+	names: DecisionNames
+});
+/**
 * A version as it stands: its content, its state, and, once proposed, where its approval is: its
 * repos still being checked, or who accepted it.
 */
@@ -7435,7 +7076,7 @@ const GateAnswerRoute = Schema.TaggedStruct("GateAnswerRoute", {
 	reason: Schema.optionalKey(TextId)
 });
 Schema.Union([
-	DecisionView,
+	NamedDecision,
 	GateAnswerRoute,
 	DecisionNotFound,
 	AnswerRefused,
@@ -7467,14 +7108,29 @@ Schema.Union([
 	]) }),
 	DeliveryOutsideWindow
 ]);
-Schema.Struct({
+/** Someone decisions wait on: a person, or an agent, and the roles the Worker found they hold. */
+const Waiter = Schema.Struct({
 	decider: DeciderRef,
-	roles: Schema.optionalKey(Schema.Array(Schema.Struct({
+	roles: Schema.Array(Schema.Struct({
 		role: Schema.Literal("admin"),
 		owner: OwnerId
-	})))
+	}))
 });
-const WaitingPage = Schema.Struct({ decisions: Schema.Array(DecisionView) });
+Schema.Struct({
+	ownerName: OwnerName,
+	you: Waiter,
+	person: Schema.optionalKey(Waiter),
+	decisions: Schema.optionalKey(Schema.Array(DecisionId).check(Schema.isMaxLength(100)))
+});
+/**
+* An open decision that waits on the caller: on them, or, for an agent, on its person, who
+* answers it. A gate never takes an agent's answer, so an agent's gate always waits on its person.
+*/
+const WaitingDecision = Schema.Struct({
+	...NamedDecision.fields,
+	waitsOn: Schema.Literals(["you", "your person"])
+});
+const WaitingPage = Schema.Struct({ decisions: Schema.Array(WaitingDecision) });
 Schema.Struct({
 	ownerName: OwnerName,
 	number: ThreadNumber
@@ -7492,7 +7148,7 @@ Schema.Struct({
 	decision: DecisionId,
 	wait: Schema.optionalKey(DecisionWait)
 });
-Schema.Union([DecisionView, DecisionNotFound]);
+Schema.Union([NamedDecision, DecisionNotFound]);
 /**
 * `POST …/plans`: a version, as a draft unless it's proposed at once, and why it was written.
 * A first version needs no reason, and a later one may leave it out.
@@ -7541,6 +7197,385 @@ const ChildStageView = Schema.Struct({
 });
 Schema.Union([ChildStageView, ThreadNotFound]);
 //#endregion
+//#region ../contracts/src/approvals.ts
+/**
+* Approvals, as their commands travel: what a terminal, a page or an agent asks its person to
+* say yes to. A command is one endpoint, by its name in the surface table, and its request, as
+* that endpoint encodes it. ref0 decodes each part by the endpoint's own `Schema` before it
+* keeps or shows anything, so a command is exactly what the endpoint would take.
+*/
+/**
+* An endpoint by its name in the surface table, `group.endpoint`. Checked against the table
+* where the command is made canonical, since the table is typed from the API this is part of.
+*/
+const CommandEndpoint = Schema.String.check(Schema.isPattern(/^[a-zA-Z]+\.[a-zA-Z]+$/));
+/** One command, as asked: its endpoint, and its request's path, query and payload, encoded. */
+const ApprovalCommand = Schema.Struct({
+	endpoint: CommandEndpoint,
+	params: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	query: Schema.optionalKey(Schema.JsonObject),
+	payload: Schema.optionalKey(Schema.Json)
+});
+/** A command ref0 won't ask anyone about: not an endpoint's request, or not one an approval runs. */
+var CommandRefused = class extends Schema.TaggedError()("CommandRefused", { nextStep: Schema.String }, { httpApiStatus: 400 }) {};
+/** A terminal asking: its command, and the hash of the secret it collects the result with. */
+const StartApproval = Schema.Struct({
+	command: ApprovalCommand,
+	secretHash: SecretHash
+});
+/** A terminal's approval, started: what to show its person, and until when. */
+const ApprovalStarted = Schema.Struct({
+	approval: ApprovalId,
+	code: ApprovalCode,
+	expiresAt: Timestamp
+});
+/**
+* An answer that waits for the person: the call only the person may make, or that agents ask
+* for, became an approval, which the person answers on their own page. A `202`, never a failure
+* of the call: whoever asked collects the result with `GET /v1/approvals/{approval}`.
+*/
+var ApprovalNeeded = class extends Schema.TaggedError()("ApprovalNeeded", {
+	approval: ApprovalId,
+	says: Schema.String,
+	expiresAt: Timestamp
+}, { httpApiStatus: 202 }) {};
+const terminalAsker = Schema.Struct({ kind: Schema.Literal("terminal") });
+const pageAsker = Schema.Struct({ kind: Schema.Literal("page") });
+const agentAsker = Schema.Struct({
+	kind: Schema.Literal("agent"),
+	agent: AgentId,
+	handle: AgentHandle,
+	session: SessionId,
+	/** The attachment its credential was made under, for a person's agent in an organization. */
+	attachment: Schema.optionalKey(CredentialRef)
+});
+/**
+* Who asked, as a receipt keeps it: a terminal, one of ref0's pages, an agent, or a machine
+* asking to connect, by its ID and its own word for itself, and from where.
+*/
+const ApprovalAsker = Schema.Union([
+	terminalAsker,
+	pageAsker,
+	Schema.Struct({
+		kind: Schema.Literal("machine"),
+		machine: MachineId,
+		machineName: MachineName,
+		askedFrom: Schema.optionalKey(Schema.String)
+	}),
+	agentAsker
+]);
+/**
+* Who asked, as the person reads a request before they answer: a terminal, a page or an agent.
+* A machine's request is read as an `AttachmentRequestView`, never as a command.
+*/
+const ApprovalViewAsker = Schema.Union([
+	terminalAsker,
+	pageAsker,
+	agentAsker
+]);
+/** A request, as the person reads it before they answer. */
+const ApprovalView = Schema.Struct({
+	approval: ApprovalId,
+	/** The command as its CLI line. */
+	says: Schema.String,
+	/** Everything the command carries, each named, in order: nothing it would run is left out. */
+	fields: Schema.Array(Schema.Struct({
+		name: Schema.String,
+		value: Schema.String,
+		part: Schema.Literals([
+			"path",
+			"query",
+			"payload"
+		])
+	})),
+	command: ApprovalCommand,
+	asker: ApprovalViewAsker,
+	askedFrom: Schema.optionalKey(Schema.String),
+	askedAt: Timestamp,
+	expiresAt: Timestamp,
+	/**
+	* An agent's ask: the kind of action its answer may set agents' permission for, and whether a
+	* yes may let agents take it without asking. A no with the passkey may always stop them asking.
+	*/
+	agentPermission: Schema.optionalKey(Schema.Struct({
+		action: ScopeAction,
+		mayAllow: Schema.Boolean
+	})),
+	/**
+	* What the command acts on, drawn as ref0 resolves it for the person reading, where its
+	* endpoint names a preview. Without one the page can draw, it offers only no.
+	*/
+	preview: Schema.optionalKey(ApprovalPreview)
+});
+/** A statement's hash: the SHA-256 of its words and quoted values as JSON, as lowercase hex. */
+const StatementHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
+/**
+* Who asks for a yes to a statement: a workflow's run, `passkey.run`'s, by the workflow and the
+* run; or a gate's check, `passkey.check`'s, by the check, the pull request's version it gates and
+* the check run its statement is over.
+*/
+const StatementAsker = Schema.Union([Schema.Struct({
+	kind: Schema.Literal("workflow"),
+	workflow: WorkflowName,
+	run: WorkflowRunId
+}), Schema.Struct({
+	kind: Schema.Literal("gate"),
+	check: CheckKey,
+	pullRequest: PullRequestNumber,
+	version: VersionNumber,
+	run: CheckRunId
+})]);
+/**
+* A passkey request, as the person reads it before they answer: the statement, its words as its
+* asker wrote them and each value it quotes, and its hash; who asks; where, a workflow's
+* `owner/repo` or a thread's `owner/project#number`, or a gate's pull request, `owner/repo#number`;
+* whom it asks, the run's accountable person, or for a gate the person behind its run, a person by
+* name, or a permission's holders; and until when.
+*/
+const StatementView = Schema.Struct({
+	approval: ApprovalId,
+	statement: WorkflowText,
+	hash: StatementHash,
+	asker: StatementAsker,
+	home: Schema.String,
+	from: Schema.Union([Schema.Literals(["accountable", "person"]), Schema.Struct({ permission: RepoPermissionName })]),
+	askedAt: Timestamp,
+	expiresAt: Timestamp
+});
+/**
+* The person's own requests, waiting for them; the passkey requests workflows' runs and gates asked
+* them; each machine's request this browser session is the answerer of, so a reload finds it
+* again without its code; and the gates' decisions that wait on their yes or no, in every project
+* they see, oldest first.
+*/
+const ApprovalsWaiting = Schema.Struct({
+	approvals: Schema.Array(ApprovalView),
+	statements: Schema.Array(StatementView),
+	requests: Schema.Array(AttachmentRequestView),
+	decisions: Schema.Array(NamedDecision)
+});
+/** Finding a terminal's request by the code it showed. */
+const FindApproval = Schema.Union([Schema.Struct({ code: TypedApprovalCode }), Schema.Struct({ link: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{22}$/)) })]);
+/**
+* Asking for the passkey's options to answer a request: a terminal's request needs its code
+* again, so its ID alone, which travels where its code doesn't, never answers it. A machine's
+* request needs its answerer, and the agent it chooses to connect, before a yes has options.
+*/
+const ApprovalOptionsRequest = Schema.Struct({
+	code: Schema.optionalKey(TypedApprovalCode),
+	folders: Schema.optionalKey(ConnectFolderChoices)
+});
+/**
+* An answer: yes, with the passkey, or no. For an agent's ask, each answer can set the owner's
+* permission its own way, so a pairing that can't happen can't be sent: yes, and let agents do
+* it without asking; no, and stop agents asking, with the passkey too.
+*/
+const AnswerApproval = Schema.Union([
+	Schema.Struct({
+		answer: Schema.Literal("yes"),
+		permission: Schema.optionalKey(Schema.Literal("allow")),
+		assertion: PasskeyAsserted,
+		code: Schema.optionalKey(TypedApprovalCode),
+		/** The preview the page drew, where the command's endpoint names one. */
+		preview: Schema.optionalKey(PreviewEcho),
+		/** The statement the page showed, by its hash, for a workflow run's or a gate's passkey request. */
+		statement: Schema.optionalKey(Schema.Struct({ hash: StatementHash }))
+	}),
+	Schema.Struct({
+		answer: Schema.Literal("no"),
+		permission: Schema.Literal("deny"),
+		assertion: PasskeyAsserted,
+		code: Schema.optionalKey(TypedApprovalCode)
+	}),
+	Schema.Struct({
+		answer: Schema.Literal("no"),
+		code: Schema.optionalKey(TypedApprovalCode)
+	})
+]);
+/**
+* What running an approved command came to: its status, and its endpoint's answer or refusal,
+* as JSON. ref0 reads it by the command's endpoint before anyone sees it, and whoever asked reads
+* it the same way, with `ranOf`: this schema is part of the API the endpoints' types come from,
+* so it can't be typed by them itself.
+*/
+const Ran = Schema.Struct({
+	status: Schema.Int,
+	result: Schema.Json
+});
+/**
+* A ran command whose answer its endpoint's schemas no longer read, such as one kept from
+* before they changed: it ran, and what it came to can't be said.
+*/
+var ResultUnreadable = class extends Schema.TaggedError()("ResultUnreadable", { nextStep: Schema.String }, { httpApiStatus: 500 }) {};
+/**
+* Where a request stands, for whoever asked: still waiting; approved, and running as soon as
+* ref0 can; refused; expired; or what it ran to, with the endpoint it ran, whose schemas read it.
+*/
+const ApprovalState = Schema.Union([
+	Schema.Struct({
+		state: Schema.Literal("waiting"),
+		expiresAt: Timestamp
+	}),
+	Schema.Struct({
+		state: Schema.Literal("approved"),
+		/** A machine's answering browser may forget its saved answer once the terminal kept it. */
+		collected: Schema.optionalKey(Schema.Literal(true))
+	}),
+	Schema.Struct({ state: Schema.Literal("refused") }),
+	Schema.Struct({ state: Schema.Literal("expired") }),
+	Schema.Struct({
+		state: Schema.Literal("ran"),
+		endpoint: CommandEndpoint,
+		...Ran.fields
+	})
+]);
+/** Only the answering browser receives a machine's answer code; state reads never carry it. */
+const ApprovalAnswer = Schema.Union([
+	Schema.Struct({
+		...ApprovalState.members[1].fields,
+		answerCode: ApprovalCode
+	}),
+	Schema.Struct({
+		...ApprovalState.members[4].fields,
+		answerCode: ApprovalCode
+	}),
+	ApprovalState
+]);
+/** A request that isn't there, or isn't the caller's to see, answers the same. */
+var ApprovalNotFound = class extends Schema.TaggedError()("ApprovalNotFound", { nextStep: Schema.String }, { httpApiStatus: 404 }) {};
+/** Too many asked, or too many codes typed, from here in the last hour. */
+var SlowDown = class extends Schema.TaggedError()("SlowDown", { nextStep: Schema.String }, { httpApiStatus: 429 }) {};
+/** A command's hash: the SHA-256 of its canonical JSON, as lowercase hex. */
+const CommandHash = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/));
+Schema.Struct({
+	approval: ApprovalId,
+	endpoint: CommandEndpoint,
+	/** The command's canonical JSON. */
+	command: Schema.String,
+	commandHash: CommandHash,
+	asker: ApprovalAsker,
+	/** The browser session the person answered in, for their log. */
+	credential: CredentialRef,
+	generation: Generation,
+	/** When the request expires, in epoch milliseconds. */
+	deadline: Schema.Int,
+	challenge: Schema.String,
+	/** A machine answer retries only from its answering session, with this key. */
+	answerKey: Schema.optionalKey(RequestId),
+	/** An agent's ask: the credential it asked with, checked again before the answer counts. */
+	asking: Schema.optionalKey(TokenId),
+	/** The kind of action the person, answering, let agents take without asking from now on. */
+	allow: Schema.optionalKey(ScopeAction)
+});
+Schema.Struct({
+	approval: ApprovalId,
+	action: ScopeAction,
+	credential: CredentialRef,
+	generation: Generation
+});
+Schema.Union([Schema.Struct({ denied: Schema.Literal(true) }), Schema.Struct({
+	denied: Schema.Literal(false),
+	reason: Schema.Literals(["generation moved", "not set up"])
+})]);
+Schema.Union([Schema.Struct({
+	admitted: Schema.Literal(true),
+	admittedAt: Schema.Int,
+	answerCode: Schema.optionalKey(ApprovalCode)
+}), Schema.Struct({
+	admitted: Schema.Literal(false),
+	reason: Schema.Literals([
+		"expired",
+		"generation moved",
+		"challenge used",
+		"not set up",
+		"asker gone"
+	])
+})]);
+Schema.Union([Schema.Struct({ found: Schema.Literal(false) }), Schema.Struct({
+	found: Schema.Literal(true),
+	endpoint: CommandEndpoint,
+	command: Schema.String,
+	commandHash: CommandHash,
+	generation: Generation,
+	generationNow: Generation,
+	/** The `approval.answered` its admission recorded in the person's log. */
+	answeredEvent: EventId,
+	/** Who asked, as that `approval.answered` says. */
+	asker: ApprovalAsker,
+	/** What running it came to, once it ran, as `KeptRan` keeps it. */
+	result: Schema.optionalKey(Schema.String)
+})]);
+/**
+* A `Ran` as it's kept, on its receipt and on its approval: its JSON, as text. The Owner DO
+* keeps it as it comes and runs no endpoint's schemas, so it's read only by its endpoint, with
+* `keptRan`, which refuses one they don't take.
+*/
+const KeptRan = Schema.fromJsonString(Ran);
+Schema.Struct({
+	approval: ApprovalId,
+	result: Schema.String
+});
+Schema.Struct({ result: Schema.String });
+Schema.Struct({ approval: ApprovalId });
+Schema.Struct({ approval: ApprovalId });
+Schema.Union([Schema.Struct({ expired: Schema.Literal(true) }), Schema.Struct({ expired: Schema.Literal(false) })]);
+Schema.Struct({
+	person: PersonId,
+	approval: ApprovalId
+});
+//#endregion
+//#region ../contracts/src/browser-sessions.ts
+/**
+* A browser session's cookie: Better Auth's, named for ref0, `Secure` and host-only on the
+* app's one origin. It holds the session's token, signed; the directory and the person's Owner DO hold
+* only the token's SHA-256.
+*/
+const browserSessionCookie = "__Secure-ref0.session_token";
+Schema.Struct({
+	token: TokenId,
+	secretHash: SecretHash,
+	expiresAt: Schema.DateTimeUtcFromMillis
+});
+Schema.Struct({ registered: Schema.Boolean });
+/**
+* Where a signed-in person stands: naming, when the name their GitHub login gave was taken or
+* kept back, with that login as a suggestion; setting up, once their owner is made and before
+* it's ready with this session registered, which naming again finishes; or ready.
+*/
+const Welcome = Schema.Union([Schema.Struct({
+	state: Schema.Literals(["ready", "setting up"]),
+	person: PersonId,
+	owner: OwnerId,
+	name: OwnerName
+}), Schema.Struct({
+	state: Schema.Literal("naming"),
+	person: PersonId,
+	suggestion: Schema.optionalKey(Schema.String)
+})]);
+/**
+* A browser session renewed: its expiry, in its person's Owner DO and in the directory, and on its cookie.
+* Renewed at most once a day, so one asked sooner answers its expiry unchanged.
+*/
+const SessionRenewed = Schema.Struct({ expiresAt: Schema.DateTimeUtcFromMillis });
+/**
+* What starting a GitHub sign-in at `POST /auth/sign-in/social` answers: GitHub's address to go
+* to, with the sign-in's state in a cookie set alongside. Better Auth's answer, which ref0 serves.
+*/
+const NavigationUrl = Schema.String.check(Schema.isPattern(/^https?:\/\/[^\s/]+(?:\/[^\s]*)?$/), Schema.makeFilter((url) => URL.canParse(url) || "an HTTP(S) URL the platform can parse")).pipe(Schema.brand("NavigationUrl"));
+Schema.Struct({ url: NavigationUrl });
+/**
+* Where signing in sends the browser back to, as `POST /auth/sign-in/social` takes it: a path on
+* ref0's own origin, such as `/welcome`, or a whole URL. Never a socket's.
+*/
+const SignInDestination = Schema.String.pipe(Schema.brand("SignInDestination"));
+Schema.Struct({
+	provider: Schema.Literal("github"),
+	callbackURL: SignInDestination,
+	errorCallbackURL: SignInDestination
+});
+/** The name a naming person chose for their owner. */
+const NameOwner = Schema.Struct({ name: OwnerName });
+//#endregion
 //#region ../contracts/src/ask-calls.ts
 /**
 * Asks: a question that waits on an answer, from an agent's session or a person, on a thread,
@@ -11659,6 +11694,151 @@ 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",
@@ -11911,6 +12091,71 @@ const GateAddition = Schema.Struct({
 	from: NeedFrom
 });
 /**
+* A yes that met a need: its decider's, given by the person `by` when one gave it, such as an
+* admin answering as the owner's admins; or, `overridden`, a check ref0 said no to, met by the
+* yes of each of its overrides.
+*/
+const NeedYes = Schema.Struct({
+	decider: DeciderRef,
+	by: Schema.optionalKey(PersonId),
+	overridden: Schema.optionalKey(Schema.Literal(true))
+});
+/**
+* An override left of a check ref0 said no to: of a part's failed run, or of the check not running,
+* and who answers it.
+*/
+const OverrideLeft = Schema.Struct({
+	of: Schema.Literals(["failed run", "not run"]),
+	by: OverrideAnswerer
+});
+/**
+* A decider a need waits on. For a check ref0 said no to, `overrides` lists each of its overrides
+* left, every one of whose yeses meets it in a pass's place, none when it has none: one yes to a
+* gate answers every decider its person may answer as, each override among them.
+*/
+const NeedWait = Schema.Struct({
+	decider: DeciderRef,
+	overrides: Schema.optionalKey(Schema.Array(OverrideLeft).check(Schema.isMaxLength(maxGateDeciders)))
+});
+/**
+* How one of a version's needs stands under its gate's answers now, as the gate is decided from
+* them: `met` by each yes in `by`; `met` with nothing to wait for, `as` `no checks`, for `checks`
+* when none of the repo's checks runs on the change, or `on the tip`, for a check only the merge
+* queue's tip runs, which judges it before `main` moves; `waiting` on each decider in `on`, when
+* `all`, or else on a yes from any one of them; `waiting` for ref0 to read which of `main`'s
+* checks run on the change; or `refused` by a person's no to one of its deciders, or to an
+* override of one, which decides the whole gate no.
+*/
+const NeedStanding = Schema.Union([
+	Schema.Struct({
+		state: Schema.Literal("met"),
+		by: Schema.Array(NeedYes).check(Schema.isMaxLength(maxGateDeciders))
+	}),
+	Schema.Struct({
+		state: Schema.Literal("met"),
+		as: Schema.Literals(["no checks", "on the tip"])
+	}),
+	Schema.Struct({
+		state: Schema.Literal("waiting"),
+		on: Schema.Array(NeedWait).check(Schema.isMaxLength(maxGateDeciders)),
+		all: Schema.Boolean
+	}),
+	Schema.Struct({
+		state: Schema.Literal("waiting"),
+		for: Schema.Literal("checks read")
+	}),
+	Schema.Struct({
+		state: Schema.Literal("refused"),
+		decider: DeciderRef,
+		by: PersonId
+	})
+]);
+/** A version's need, with every place it came from, and how it stands once its gate is open. */
+const GateNeedView = Schema.Struct({
+	...GateNeed.fields,
+	standing: Schema.optionalKey(NeedStanding)
+});
+/**
 * The version's gate decided again in place under `main`'s `.ref0/` now (Q7c): on which `main`
 * and under its tree, `pending` until `main`'s gate answers, then `held` or `grew`; the needs
 * it answered, joined to ref0's floor, absent while pending; what `main`'s gate read of the
@@ -12012,8 +12257,21 @@ const GateView = Schema.Struct({
 	state: GateState,
 	/** Why the gate failed; null otherwise. */
 	why: Schema.NullOr(Schema.String),
-	/** None while pending; once answered, the floor's too, sorted as they're spelled. */
-	needs: Schema.Array(GateNeed),
+	/**
+	* None while pending; once answered, the floor's too, sorted as they're spelled, each with how
+	* it stands once the version's gate is open.
+	*/
+	needs: Schema.Array(GateNeedView),
+	/** The repo's owner, whose admins answer its admins' needs: at home, its person alone. */
+	owner: OwnerId,
+	/**
+	* The names of the owner and of the people its needs' standings name, where the directory has
+	* them.
+	*/
+	names: Schema.optionalKey(Schema.Array(Schema.Struct({
+		owner: OwnerId,
+		name: OwnerName
+	})).check(Schema.isMaxLength(maxGateDeciders + 1))),
 	/** What the gate read of the change's trees, each read once, in order; none while pending. */
 	reads: GateReads,
 	/** The project gate revision the version was decided under; none for 0. */
@@ -14133,6 +14391,7 @@ const KnownEvent = Schema.Union([
 	ThreadListingChanged,
 	SessionStarted,
 	SessionEnded,
+	IdentityTokenIssued,
 	MemberRoleChanged,
 	MemberRemoved,
 	InvitationSent,
@@ -14994,6 +15253,11 @@ 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 }) {};
+/**
+* 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.
+*/
+var IdentityAudienceRefusal = class extends HttpApiMiddleware.Service()("ref0/contracts/IdentityAudienceRefusal", { error: IdentityAudienceRefused }) {};
 const idempotency = { "idempotency-key": RequestId };
 const inProject$1 = {
 	owner: OwnerRef,
@@ -15216,7 +15480,18 @@ var MeGroup = class extends HttpApiGroup.make("me").add(HttpApiEndpoint.get("get
 		UsageRangeRefused,
 		AuthorityUnavailable
 	]
-})).middleware(Authorization) {};
+}), HttpApiEndpoint.post("identityToken", identityTokenPath, {
+	payload: IdentityTokenRequest,
+	success: IssuedIdentityToken,
+	error: [
+		IdentityAudienceRefused,
+		IdentityTokenNotReady,
+		NotPermitted,
+		SessionHasEnded,
+		SlowDown,
+		AuthorityUnavailable
+	]
+}).middleware(IdentityAudienceRefusal)).middleware(Authorization) {};
 /**
 * A thread's endpoints, as one of a project's threads and an org thread take them alike, by
 * where they are: `at` is a project's path parameters, or the owner's alone for its own scope.
@@ -16152,15 +16427,18 @@ const decisionEndpoints = (at) => {
 		HttpApiEndpoint.get("get", "/:decision", {
 			params: onDecision,
 			query: { wait: Schema.optionalKey(DecisionWait) },
-			success: DecisionView,
+			success: NamedDecision,
 			error: [...projectErrors, DecisionNotFound]
 		}),
 		HttpApiEndpoint.post("answer", "/:decision/answers", {
 			params: onDecision,
 			headers: idempotency,
 			payload: AnswerRequest,
-			success: DecisionView,
+			success: NamedDecision,
 			error: [
+				ApprovalNeeded,
+				CommandRefused,
+				SlowDown,
 				...projectErrors,
 				DecisionNotFound,
 				AnswerRefused,
@@ -17007,6 +17285,15 @@ const ownSurfaces = {
 		cli: "meters",
 		mcp: null
 	},
+	"me.identityToken": {
+		action: "session:change",
+		actors: "agent",
+		target: "session",
+		stepUp: "never",
+		asks: "never",
+		cli: "identity-token",
+		mcp: null
+	},
 	"threads.list": {
 		action: "project:read",
 		actors: "both",
@@ -18464,7 +18751,7 @@ const HooksFile = Schema.Struct({ hooks: Schema.Record(Schema.String, Schema.Arr
 const McpServersFile = Schema.Struct({ mcpServers: Schema.Record(Schema.String, Schema.Struct({
 	command: Schema.String,
 	args: Schema.Array(Schema.String),
-	/** The variables Codex passes the server beside `HOME`, `PATH` and `SHELL`. */
+	/** The variables Codex passes the server beside the few it always passes, such as `HOME`. */
 	env_vars: Schema.optionalKey(Schema.Array(Schema.String))
 })) });
 const PluginManifest = Schema.Struct({
@@ -18669,6 +18956,7 @@ const StatusCheck = Schema.Struct({
 		"accepted",
 		"plugin",
 		"trusted",
+		"server",
 		"session"
 	]),
 	answer: StatusAnswer,
@@ -18823,6 +19111,12 @@ const freshLinkSecret = Effect.suspend(() => hashed(Buffer.from(crypto.getRandom
 //#endregion
 //#region src/session.ts
 /**
+* An agent's command in a harness session that has no ref0 session, though an agent is connected
+* for its config folder: why, as far as ref0 can tell, and what to do. It never runs as its
+* person instead.
+*/
+var NoSession = class extends Schema.TaggedError()("NoSession", { nextStep: Schema.String }) {};
+/**
 * The token of the session this command runs in, if it runs in one: an agent's, which its
 * harness bound when the session started. Where it's found is the harness's to say. Outside a
 * session, there's none, and every command is the person's, asked by approval.
@@ -20173,10 +20467,10 @@ const blockerLines = (list, address) => {
 	].join("\n");
 };
 /** How many blockers stand on the thread now, in words. */
-const standingWords = (changed) => changed.standing === 0 ? "None stands now, so ref0 merges it once it’s ready." : `${changed.standing} ${changed.standing === 1 ? "stands" : "stand"}, so ref0 won’t merge it yet.`;
+const standingWords$1 = (changed) => changed.standing === 0 ? "None stands now, so ref0 merges it once it’s ready." : `${changed.standing} ${changed.standing === 1 ? "stands" : "stand"}, so ref0 won’t merge it yet.`;
 /** A blocker added, in words: which, its ask, how many stand, and a publish it didn't stop. */
 const addedWords = (changed, address) => [
-	`Blocked ${address} by ${changed.blocker}. ${standingWords(changed)}`,
+	`Blocked ${address} by ${changed.blocker}. ${standingWords$1(changed)}`,
 	...changed.decision === void 0 ? [] : [`It waits on a person’s answer to the ask ${changed.decision}.`],
 	...changed.admitted === void 0 ? [] : [`A merge carrying it was already under way in ${changed.admitted.join(", ")}; the blocker doesn’t stop that one.`]
 ].join("\n");
@@ -20323,7 +20617,7 @@ const clearing = (name, description) => Command.make(name, {
 		payload
 	}));
 	const done = name === "remove" ? "Removed" : "Marked met";
-	yield* printAnswer(answer.json, asJson, `${done} ${answer.value.blocker} on ${address}. ${standingWords(answer.value)}`);
+	yield* printAnswer(answer.json, asJson, `${done} ${answer.value.blocker} on ${address}. ${standingWords$1(answer.value)}`);
 }).pipe(Effect.catchTag("CallFailed", (failed) => sayFailed(failed.nextStep)))).pipe(Command.withDescription(description));
 /** `ref0 blocked` and its subcommands. */
 const blockedCommands = [Command.make("blocked").pipe(Command.withDescription("What a thread is blocked by, which stops ref0 merging it: list, add, hold, remove, and mark met"), Command.withShortDescription("List and manage a thread’s blockers"), Command.withSubcommands([
@@ -20454,6 +20748,18 @@ const harnessFlagNames = { protocol: "protocol" };
 * release, which no hook's declaration carries.
 */
 const pluginVersionVariable = "REF0_PLUGIN_VERSION";
+/**
+* What the launcher puts in `ref0 mcp`'s environment in a checkout of another origin: that
+* origin. The server runs all the same, answering every hook with nothing, since a harness
+* takes a server that exits before `initialize` as broken.
+*/
+const otherOriginVariable = "REF0_OTHER_ORIGIN";
+/**
+* What `ref0 status` puts in the environment of a folder's ref0 server, which it starts to check
+* it starts: the harness it plays. No harness sets it, so a harness's server finds its harness up
+* its parent chain.
+*/
+const serverCheckVariable = "REF0_SERVER_CHECK";
 /** A flag as a command line writes it. */
 const flagWord = (name) => `--${name}`;
 /**
@@ -20561,10 +20867,19 @@ const sessionStartHook = ref0Hook(harnessCommandNames.sessionStart);
 /** Ends the session, as a command too. */
 const sessionEndHook = ref0Hook(harnessCommandNames.sessionEnd);
 /**
+* What Linux's keychain needs to be reached: `secret-tool` finds the session bus by its address,
+* or else in the runtime folder, and with neither it can't read a grant. Codex 0.164.0 passes a
+* server neither unless asked. macOS's keychain needs neither, and Codex passes an unset one as
+* unset.
+*/
+const keychainVariables = ["DBUS_SESSION_BUS_ADDRESS", "XDG_RUNTIME_DIR"];
+/**
 * The plugin's server, `ref0 mcp`, started by M0's inline launcher, the lookup in one line: a
 * script path in a server's arguments stays literal in Codex. It has no `cwd`, so the server
-* keeps the project's folder in both harnesses. Codex starts its servers with only `HOME`, `PATH`
-* and `SHELL`, so it's asked for `CODEX_HOME`, which an unset one leaves unset.
+* keeps the project's folder in both harnesses. Codex starts its servers with only a few of its
+* variables, such as `HOME`, `PATH` and `SHELL` (`server-check.ts` lists them), so it's asked for
+* `CODEX_HOME` and the keychain's, each passed through as Codex has it and never written down: a
+* bus address changes with each login. Claude Code passes its whole environment.
 */
 const mcpFile = (version, api, server = "ref0") => ({
 	path: "ref0/.mcp.json",
@@ -20579,133 +20894,14 @@ const mcpFile = (version, api, server = "ref0") => ({
 		env_vars: [
 			"CODEX_HOME",
 			"CLAUDE_CONFIG_DIR",
-			"REF0_API"
+			"REF0_API",
+			...keychainVariables
 		]
 	} } })
 });
 /** Each event a harness's hooks send `ref0 mcp`, with the fields it reads, as an `mcp_tool` hook. */
 const mcpToolHooks = (server, hookFields) => Object.fromEntries(Object.entries(hookFields).map(([event, fields]) => [event, [mcpToolHook(server, event, fields)]]));
 //#endregion
-//#region src/keychain.ts
-/**
-* The machine's keychain, where the CLI keeps what lets it act: the host grant `ref0 connect`
-* makes, and a session's token. Never a file. On macOS through `security`, on Linux through
-* `secret-tool`, under an origin-specific `ref0/<origin>` service, by account. A secret goes in through stdin, never as
-* an argument, since any process on the machine can read another's arguments.
-*/
-var KeychainError = class extends Schema.TaggedError()("KeychainError", {
-	nextStep: Schema.String,
-	/** The keychain answered, with an item ref0 can't read, rather than not answering. */
-	unreadable: Schema.optionalKey(Schema.Literal(true))
-}) {};
-/**
-* The keychain under one service. Each API origin has its own, `ref0/<origin>`; 0.5.0 kept its
-* grants under `ref0`, which only `ref0 connect` reads, to replace and delete them.
-*/
-const keychainIn = Effect.fnUntraced(function* (service) {
-	const crypto = yield* Crypto.Crypto;
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const macOS = (yield* spawner.string(ChildProcess.make("uname", ["-s"])).pipe(Effect.orElseSucceed(() => ""))).trim() === "Darwin";
-	const unavailable = new KeychainError({ nextStep: macOS ? "The keychain didn’t answer. Unlock it, and try again." : "The keychain didn’t answer. Unlock the keychain or start a secret service, and try again." });
-	const missing = new KeychainError({ nextStep: "The keychain didn’t answer: ref0 needs `secret-tool`, from libsecret. Install `secret-tool` with `sudo apt install libsecret-tools` on Debian or Ubuntu, `sudo dnf install libsecret` on Fedora or `sudo pacman -S libsecret` on Arch." });
-	const run = (command, args, stdin) => Effect.scoped(Effect.gen(function* () {
-		const handle = yield* spawner.spawn(ChildProcess.make(command, args, { stdin: Stream.make(new TextEncoder().encode(stdin)) })).pipe(Effect.mapError((error) => !macOS && Predicate.isTagged(error.reason, "NotFound") ? missing : unavailable));
-		const [output, complaint] = yield* Effect.all([handle.stdout.pipe(Stream.decodeText(), Stream.mkString), handle.stderr.pipe(Stream.decodeText(), Stream.mkString)], { concurrency: "unbounded" });
-		const code = yield* handle.exitCode;
-		return {
-			output: output.trim(),
-			complaint: complaint.trim(),
-			code,
-			succeeded: code === ChildProcessSpawner.ExitCode(0)
-		};
-	})).pipe(Effect.catchTag("PlatformError", () => Effect.fail(unavailable)));
-	const get = Effect.fn("Keychain.get")(function* (account) {
-		const found = macOS ? yield* run("security", [
-			"find-generic-password",
-			"-s",
-			service,
-			"-a",
-			account,
-			"-w"
-		], "") : yield* run("secret-tool", [
-			"lookup",
-			"service",
-			service,
-			"account",
-			account
-		], "");
-		if (found.succeeded) return found.output.length > 0 ? Option.some(Redacted.make(found.output)) : Option.none();
-		if (macOS) {
-			if (found.code === ChildProcessSpawner.ExitCode(44)) return Option.none();
-			return yield* unavailable;
-		}
-		if (found.code !== ChildProcessSpawner.ExitCode(1) || found.complaint.length > 0) return yield* unavailable;
-		const listed = yield* run("secret-tool", [
-			"search",
-			"--all",
-			"service",
-			service,
-			"account",
-			account
-		], "");
-		if (listed.output.length > 0 || listed.complaint.length > 0) return yield* unavailable;
-		return Option.none();
-	});
-	const set = Effect.fn("Keychain.set")(function* (account, secret) {
-		const quote = (text) => `"${text.replace(/[\\"]/g, "\\$&")}"`;
-		const value = Redacted.value(secret);
-		if (macOS && /[\r\n\0]/.test(account + value)) return yield* unavailable;
-		const input = macOS ? `add-generic-password -U -s ${quote(service)} -a ${quote(account)} -w ${quote(value)}\n` : value;
-		if (macOS && new TextEncoder().encode(input).length >= 4096) return yield* unavailable;
-		if (!(macOS ? yield* run("security", ["-i"], input) : yield* run("secret-tool", [
-			"store",
-			"--label",
-			`ref0 ${account}`,
-			"service",
-			service,
-			"account",
-			account
-		], Redacted.value(secret))).succeeded) return yield* unavailable;
-	});
-	const remove = Effect.fn("Keychain.remove")(function* (account) {
-		if (!(yield* macOS ? run("security", [
-			"delete-generic-password",
-			"-s",
-			service,
-			"-a",
-			account
-		], "") : run("secret-tool", [
-			"clear",
-			"service",
-			service,
-			"account",
-			account
-		], "")).succeeded) return yield* unavailable;
-	});
-	const random = crypto.randomUUIDv4.pipe(Effect.mapError(() => unavailable));
-	return {
-		probe: Effect.gen(function* () {
-			const account = `connect-probe/${yield* random}`;
-			const value = Redacted.make(yield* random);
-			yield* Effect.gen(function* () {
-				yield* set(account, value);
-				const kept = yield* get(account);
-				if (Option.isNone(kept) || Redacted.value(kept.value) !== Redacted.value(value)) return yield* unavailable;
-				yield* remove(account);
-			}).pipe(Effect.catch((error) => remove(account).pipe(Effect.ignore, Effect.andThen(Effect.fail(error)))));
-		}).pipe(Effect.timeoutOrElse({
-			duration: Duration.minutes(1),
-			orElse: () => Effect.fail(unavailable)
-		})),
-		get,
-		set,
-		remove
-	};
-});
-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/harness/binding.ts
 /**
 * Where a session's token is kept: the machine's keychain, under the API origin’s keychain service, by an
@@ -20743,9 +20939,8 @@ function bindingFromEnvironment(environment, found, hookSession) {
 //#endregion
 //#region src/harness/session-token.ts
 /**
-* The session token of the harness session a command runs in, from the keychain, under the
-* account its binding names. Outside a harness, or in one whose session ref0 never started,
-* there's none, and a command is its person's, asked by approval.
+* The harness session a command runs in: the harness process up its parent chain, and the
+* binding its session's token is kept under, which `command-token.ts` reads.
 */
 const optional$1 = (name) => Config.String(name).pipe(Config.option, Config.map(Option.getOrUndefined));
 /** What the harness put in this process's environment, as far as a binding needs. */
@@ -20753,7 +20948,6 @@ const harnessEnvironment = Config.all({
 	CLAUDE_CODE_SESSION_ID: optional$1("CLAUDE_CODE_SESSION_ID"),
 	CLAUDE_PID: optional$1("CLAUDE_PID"),
 	CODEX_SESSION_ID: optional$1("CODEX_SESSION_ID"),
-	CODEX_HOME: optional$1("CODEX_HOME"),
 	CODEX_SANDBOX: optional$1("CODEX_SANDBOX")
 });
 /**
@@ -20828,17 +21022,6 @@ const bindingForServer = Effect.fnUntraced(function* (harnessSession) {
 		process: found.value.process
 	});
 });
-/** `SessionToken` from the keychain, by the binding of the harness session this runs in. */
-const harnessSessionToken = Layer.effect(SessionToken, Effect.gen(function* () {
-	const keychain = yield* Keychain;
-	const harness = yield* HarnessProcess;
-	const current = Effect.gen(function* () {
-		const binding = yield* bindingHere().pipe(Effect.provideService(HarnessProcess, harness), Effect.orElseSucceed(() => Option.none()));
-		if (Option.isNone(binding)) return Option.none();
-		return yield* keychain.get(sessionAccount(binding.value));
-	});
-	return SessionToken.of({ current });
-}));
 //#endregion
 //#region src/harness/config-folders.ts
 const Folders = Schema.Array(Schema.String);
@@ -20951,6 +21134,126 @@ const connectLineFor = Effect.fnUntraced(function* (harness, configFolder) {
 	return `${configFolders[harness].variable}=${shellWord(configFolder)} ref0 connect`;
 });
 //#endregion
+//#region src/keychain.ts
+/**
+* The machine's keychain, where the CLI keeps what lets it act: the host grant `ref0 connect`
+* makes, and a session's token. Never a file. On macOS through `security`, on Linux through
+* `secret-tool`, under an origin-specific `ref0/<origin>` service, by account. A secret goes in through stdin, never as
+* an argument, since any process on the machine can read another's arguments.
+*/
+var KeychainError = class extends Schema.TaggedError()("KeychainError", {
+	nextStep: Schema.String,
+	/** The keychain answered, with an item ref0 can't read, rather than not answering. */
+	unreadable: Schema.optionalKey(Schema.Literal(true))
+}) {};
+/**
+* The keychain under one service. Each API origin has its own, `ref0/<origin>`; 0.5.0 kept its
+* grants under `ref0`, which only `ref0 connect` reads, to replace and delete them.
+*/
+const keychainIn = Effect.fnUntraced(function* (service) {
+	const crypto = yield* Crypto.Crypto;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const macOS = (yield* spawner.string(ChildProcess.make("uname", ["-s"])).pipe(Effect.orElseSucceed(() => ""))).trim() === "Darwin";
+	const unavailable = new KeychainError({ nextStep: macOS ? "The keychain didn’t answer. Unlock it, and try again." : "The keychain didn’t answer. Unlock the keychain or start a secret service, and try again." });
+	const missing = new KeychainError({ nextStep: "The keychain didn’t answer: ref0 needs `secret-tool`, from libsecret. Install `secret-tool` with `sudo apt install libsecret-tools` on Debian or Ubuntu, `sudo dnf install libsecret` on Fedora or `sudo pacman -S libsecret` on Arch." });
+	const run = (command, args, stdin) => Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(ChildProcess.make(command, args, { stdin: Stream.make(new TextEncoder().encode(stdin)) })).pipe(Effect.mapError((error) => !macOS && Predicate.isTagged(error.reason, "NotFound") ? missing : unavailable));
+		const [output, complaint] = yield* Effect.all([handle.stdout.pipe(Stream.decodeText(), Stream.mkString), handle.stderr.pipe(Stream.decodeText(), Stream.mkString)], { concurrency: "unbounded" });
+		const code = yield* handle.exitCode;
+		return {
+			output: output.trim(),
+			complaint: complaint.trim(),
+			code,
+			succeeded: code === ChildProcessSpawner.ExitCode(0)
+		};
+	})).pipe(Effect.catchTag("PlatformError", () => Effect.fail(unavailable)));
+	const get = Effect.fn("Keychain.get")(function* (account) {
+		const found = macOS ? yield* run("security", [
+			"find-generic-password",
+			"-s",
+			service,
+			"-a",
+			account,
+			"-w"
+		], "") : yield* run("secret-tool", [
+			"lookup",
+			"service",
+			service,
+			"account",
+			account
+		], "");
+		if (found.succeeded) return found.output.length > 0 ? Option.some(Redacted.make(found.output)) : Option.none();
+		if (macOS) {
+			if (found.code === ChildProcessSpawner.ExitCode(44)) return Option.none();
+			return yield* unavailable;
+		}
+		if (found.code !== ChildProcessSpawner.ExitCode(1) || found.complaint.length > 0) return yield* unavailable;
+		const listed = yield* run("secret-tool", [
+			"search",
+			"--all",
+			"service",
+			service,
+			"account",
+			account
+		], "");
+		if (listed.output.length > 0 || listed.complaint.length > 0) return yield* unavailable;
+		return Option.none();
+	});
+	const set = Effect.fn("Keychain.set")(function* (account, secret) {
+		const quote = (text) => `"${text.replace(/[\\"]/g, "\\$&")}"`;
+		const value = Redacted.value(secret);
+		if (macOS && /[\r\n\0]/.test(account + value)) return yield* unavailable;
+		const input = macOS ? `add-generic-password -U -s ${quote(service)} -a ${quote(account)} -w ${quote(value)}\n` : value;
+		if (macOS && new TextEncoder().encode(input).length >= 4096) return yield* unavailable;
+		if (!(macOS ? yield* run("security", ["-i"], input) : yield* run("secret-tool", [
+			"store",
+			"--label",
+			`ref0 ${account}`,
+			"service",
+			service,
+			"account",
+			account
+		], Redacted.value(secret))).succeeded) return yield* unavailable;
+	});
+	const remove = Effect.fn("Keychain.remove")(function* (account) {
+		if (!(yield* macOS ? run("security", [
+			"delete-generic-password",
+			"-s",
+			service,
+			"-a",
+			account
+		], "") : run("secret-tool", [
+			"clear",
+			"service",
+			service,
+			"account",
+			account
+		], "")).succeeded) return yield* unavailable;
+	});
+	const random = crypto.randomUUIDv4.pipe(Effect.mapError(() => unavailable));
+	return {
+		probe: Effect.gen(function* () {
+			const account = `connect-probe/${yield* random}`;
+			const value = Redacted.make(yield* random);
+			yield* Effect.gen(function* () {
+				yield* set(account, value);
+				const kept = yield* get(account);
+				if (Option.isNone(kept) || Redacted.value(kept.value) !== Redacted.value(value)) return yield* unavailable;
+				yield* remove(account);
+			}).pipe(Effect.catch((error) => remove(account).pipe(Effect.ignore, Effect.andThen(Effect.fail(error)))));
+		}).pipe(Effect.timeoutOrElse({
+			duration: Duration.minutes(1),
+			orElse: () => Effect.fail(unavailable)
+		})),
+		get,
+		set,
+		remove
+	};
+});
+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/host-grant.ts
 /**
 * All lasting authority for one config folder, stored as one keychain value: the agent the folder
@@ -20966,6 +21269,11 @@ const KeptHostGrant = Schema.Struct({
 });
 const decodeGrant = Schema.decodeUnknownOption(Schema.fromJsonString(KeptHostGrant));
 const encodeGrant = Schema.encodeSync(Schema.fromJsonString(KeptHostGrant));
+/**
+* The token alone, from any record that's JSON with a string `token`, so a record this ref0 can't
+* read as a grant, such as one an earlier ref0 kept, still names the grant it held.
+*/
+const decodeHeldToken = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({ token: KeptHostGrant.fields.token })));
 /** Grants in the origin’s keychain service, account host-grant/<resolved config folder>. */
 var HostGrant = class HostGrant extends Context.Service()("ref0/cli/HostGrant") {
 	static layer = Layer.effect(HostGrant, Effect.gen(function* () {
@@ -20981,6 +21289,7 @@ var HostGrant = class HostGrant extends Context.Service()("ref0/cli/HostGrant")
 					unreadable: true
 				}));
 			})),
+			heldToken: (folder) => account(folder).pipe(Effect.flatMap(keychain.get), Effect.map(Option.flatMap((kept) => Option.map(decodeHeldToken(Redacted.value(kept)), (held) => held.token)))),
 			keep: (folder, grant) => Effect.gen(function* () {
 				yield* keychain.set(yield* account(folder), Redacted.make(encodeGrant(grant)));
 				yield* folders.keep(folder).pipe(Effect.mapError(() => new KeychainError({ nextStep: "Couldn’t record this connected config folder in ~/.ref0. Check that it’s writable, then run ref0 connect." })));
@@ -21008,7 +21317,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.9.0";
+const cliVersion = "0.11.0";
 //#endregion
 //#region src/harness/hook-protocol.ts
 /**
@@ -21332,12 +21641,12 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	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) {
-		const previous = yield* hostGrant.get(folder.configFolder).pipe(Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeedNone), Effect.catchTag("KeychainError", said));
+		const held = yield* hostGrant.heldToken(folder.configFolder).pipe(Effect.catchTag("KeychainError", said));
 		return {
 			...folder,
 			shown: shownConfigFolder(home, folder.configFolder),
 			grant: yield* freshTokenSecret,
-			replaces: Option.isSome(previous) ? grantOf(previous.value.token) : yield* oldGrants.replaces(folder).pipe(Effect.catchTag("KeychainError", said))
+			replaces: Option.isSome(held) ? grantOf(held.value) : yield* oldGrants.replaces(folder).pipe(Effect.catchTag("KeychainError", said))
 		};
 	}));
 	const folders = yield* Effect.forEach(asking, Effect.fnUntraced(function* (folder) {
@@ -21386,9 +21695,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		"Approve it only if you ran this ref0 connect yourself, just now: a yes gives this machine a lasting credential for each agent it connects.",
 		"Waiting for the answer. Ctrl-C stops it."
 	]]);
-	let typed = "";
-	const show = (text) => Effect.ignore(terminal.display(text));
-	const endWait = yield* Effect.cached(Effect.suspend(() => typed === "" ? Effect.void : show("\n")).pipe(Effect.andThen(Console.error(""))));
+	const endWait = yield* Effect.cached(Console.error(""));
 	const saidAfterWait = (refusal) => Effect.andThen(endWait, said(refusal));
 	if (opener !== void 0) yield* openBrowser(opener, `${config.api}/connect#${link.secret}`);
 	const withSecret = HttpApiMiddleware.layerClient(ApprovalSecret, ({ request, next }) => next(HttpClientRequest.bearerToken(request, collecting.secret)));
@@ -21547,25 +21854,21 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	});
 	const typedCode = Effect.gen(function* () {
 		const keys = yield* terminal.readInput;
+		let typed = "";
 		while (true) {
 			const pressed = yield* Effect.option(Queue.take(keys));
 			if (Option.isNone(pressed) || quits(pressed.value.key)) return yield* Effect.interrupt;
 			const { input, key } = pressed.value;
 			if (key.name === "backspace") {
-				if (typed === "") continue;
 				typed = takeBack(typed);
-				yield* show("\b \b");
 				continue;
 			}
 			if (key.name !== "return" && key.name !== "enter") {
 				const text = Option.getOrElse(input, () => "");
-				if (!typesText(text)) continue;
-				typed += text;
-				yield* show(text);
+				if (typesText(text)) typed += text;
 				continue;
 			}
 			const line = typed.trim();
-			if (typed !== "") yield* show("\n");
 			typed = "";
 			if (line === "") continue;
 			if (isAnswerCode(line)) return line;
@@ -21573,7 +21876,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		}
 	}).pipe(Effect.scoped);
 	const readAnswer = Effect.gen(function* () {
-		yield* printBlocks([[`Paste the code from your own page on ${config.api}.`]]);
+		if (listener === void 0) yield* printBlocks([[`Paste the code from your own page on ${config.api}.`]]);
 		const code = yield* typedCode;
 		yield* Ref.update(pasted, (first) => first ?? code);
 		if (listener !== void 0) yield* listener.stop;
@@ -22710,7 +23013,7 @@ var CodexAnswerMismatch = class extends Schema.TaggedError()("CodexAnswerMismatc
 	issue: Schema.String
 }) {};
 const encodeRequest = Schema.encodeUnknownEffect(Schema.fromJsonString(CodexRequest));
-const decodeAnswer$1 = Schema.decodeUnknownOption(Schema.fromJsonString(CodexAnswer));
+const decodeAnswer$2 = Schema.decodeUnknownOption(Schema.fromJsonString(CodexAnswer));
 /** The IDs of the exchange's two requests: the opening's, and the one asked. */
 const initializeId = "ref0-initialize";
 const askedId = "ref0-asked";
@@ -22744,7 +23047,7 @@ const exchange = (codex, lines, ids, env) => Effect.scoped(Effect.gen(function*
 			stream: Stream.fromIterable(lines.map((line) => `${line}\n`)).pipe(Stream.encodeText),
 			endOnDone: false
 		}
-	}))).stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.map((line) => decodeAnswer$1(line)), Stream.filter(Option.isSome), Stream.scan(() => /* @__PURE__ */ new Map(), (answers, { value: answer }) => ids.includes(answer.id) && !answers.has(answer.id) ? new Map(answers).set(answer.id, answer) : answers), Stream.takeUntil((answers) => answers.size === ids.length), Stream.runLast);
+	}))).stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.map((line) => decodeAnswer$2(line)), Stream.filter(Option.isSome), Stream.scan(() => /* @__PURE__ */ new Map(), (answers, { value: answer }) => ids.includes(answer.id) && !answers.has(answer.id) ? new Map(answers).set(answer.id, answer) : answers), Stream.takeUntil((answers) => answers.size === ids.length), Stream.runLast);
 	return Option.filter(answered, (answers) => answers.size === ids.length);
 })).pipe(Effect.timeoutOption("15 seconds"), Effect.map(Option.flatten), Effect.catchCause(() => Effect.succeed(Option.none())));
 /** `answer`'s result, read by `method`'s own schema, or why it can't be. */
@@ -23088,16 +23391,19 @@ const codexAgentConfig = Effect.fnUntraced(function* (agent, root, home) {
 		parameters: shellWord(`include.path=${file}`)
 	};
 });
-/** Codex has no environment file: its install selects a file; session start fills its checkout. */
+/**
+* Codex has no environment file: its install selects a file; session start fills its checkout,
+* for the agent of the config folder `CODEX_HOME` names, or the default `~/.codex`.
+*/
 const setCodexCommitEnvironment = Effect.fnUntraced(function* (cwd, checkout) {
 	const folders = yield* ConfigFolders;
 	const fs = yield* FileSystem.FileSystem;
 	const path = yield* Path.Path;
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const agent = yield* (yield* HostGrant).get(yield* folders.folder("codex"));
+	const agent = yield* (yield* HostGrant).get(yield* folders.folder("codex")).pipe(Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeedNone));
 	if (Option.isNone(agent)) return false;
 	const pluginRoot = yield* Config.String("CLAUDE_PLUGIN_ROOT").pipe(Config.withDefault(""));
-	if (pluginRoot === "") return false;
+	if (pluginRoot === "") return yield* new CodexCommitFailed({ detail: "Codex gave the hook no plugin root." });
 	const gitFolder = path.join(path.dirname(pluginRoot), "@git");
 	const home = yield* Config.String("HOME");
 	const author = yield* codexAgentConfig(agent.value, gitFolder, home);
@@ -23867,6 +24173,7 @@ const writeRef0Launcher = Effect.fnUntraced(function* (home, git) {
 	const gitPath = yield* fs.realPath(git);
 	yield* fs.writeFileString(next, [
 		"#!/bin/sh",
+		`unset ${otherOriginVariable}`,
 		"if [ \"$REF0_SELECT_ORIGIN\" = 1 ]; then",
 		`  checkout=$(${shellWord(gitPath)} config --get ref0.api 2>/dev/null)`,
 		"  result=$?",
@@ -23876,7 +24183,11 @@ const writeRef0Launcher = Effect.fnUntraced(function* (home, git) {
 		`    *) printf '%s\\n' ${shellWord("ref0: could not read the checkout origin with Git. Restore Git, then run ref0 install again.")} >&2; exit 1 ;;`,
 		"  esac",
 		"  export REF0_SELECTED_API",
-		`  ${shellWord(node)} -e ${shellWord("try { process.exit(new URL(process.env.REF0_SELECTED_API).origin === process.argv[1] ? 0 : 1) } catch { process.exit(1) }")} ${shellWord(config.api)} || exit 0`,
+		`  if ! ${shellWord(node)} -e ${shellWord("try { process.exit(new URL(process.env.REF0_SELECTED_API).origin === process.argv[1] ? 0 : 1) } catch { process.exit(1) }")} ${shellWord(config.api)}; then`,
+		`    [ "$1" = ${harnessCommandNames.mcp} ] || exit 0`,
+		`    ${otherOriginVariable}=$REF0_SELECTED_API`,
+		`    export ${otherOriginVariable}`,
+		"  fi",
 		"fi",
 		"unset REF0_SELECT_ORIGIN REF0_SELECTED_API",
 		`export REF0_API=${shellWord(config.api)}`,
@@ -24032,8 +24343,16 @@ const mostFolders = 8;
 const isConfigFolderPath = Schema.is(ConfigFolderPath);
 /** The line that asks again. */
 const again = "ref0 connect";
-/** Every folder found, each ticked but one ref0 can't be shown; Enter keeps the ticked ones. */
+/** The widest a line of ref0's own words runs, as its help does, in a terminal at least as wide. */
+const mostColumns = 100;
+/**
+* Every folder found, each ticked but one ref0 can't be shown; Enter keeps the ticked ones. The
+* question is said first, wrapped between words to the terminal, and the chooser shows only the
+* folders: once Enter chooses, it leaves the ticked ones on one line after any question it was
+* given, which the terminal would break mid-word.
+*/
 const choose = Effect.fnUntraced(function* (found, home) {
+	const columns = yield* (yield* Terminal.Terminal).columns;
 	const choices = found.map((folder) => {
 		const shown = shownConfigFolder(home, folder.configFolder);
 		const sendable = isConfigFolderPath(shown);
@@ -24049,8 +24368,9 @@ const choose = Effect.fnUntraced(function* (found, home) {
 		};
 	});
 	const ticked = choices.filter((choice) => choice.selected).length;
+	const keys = "Space ticks or unticks one; Enter connects those ticked.";
+	yield* printBlocks([[{ label: "Connect which config folders?" }, ...wrapWords(ticked > mostFolders ? `One request connects at most ${mostFolders}, so untick ${ticked - mostFolders} or more. ${keys}` : keys, columns > 0 ? Math.min(columns, mostColumns) : mostColumns)]]);
 	return yield* Prompt.run(Prompt.MultiSelect({
-		message: ticked > mostFolders ? `Connect which config folders? One request connects at most ${mostFolders}, so untick ${ticked - mostFolders} or more. Space ticks or unticks one; Enter connects those ticked.` : "Connect which config folders? Space ticks or unticks one; Enter connects those ticked.",
 		choices,
 		max: mostFolders
 	}));
@@ -24158,7 +24478,7 @@ const answerOf = (connected, installed, others) => ({
 const connectCommands = [Command.make("connect", { json }, ({ json: asJson }) => Effect.gen(function* () {
 	const session = yield* SessionToken;
 	const tty = yield* Tty;
-	if (Option.isSome(yield* session.current)) 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 (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;
 	yield* (yield* Keychain).probe;
@@ -24167,6 +24487,7 @@ const connectCommands = [Command.make("connect", { json }, ({ json: asJson }) =>
 	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 installed = yield* installInto(connected.kept, { asJson });
 	const others = yield* otherOwners(connected);
@@ -24552,7 +24873,7 @@ const paramValues = (params) => {
 * its params, and when it ends; under it, each workflow's run, by its title and its file, and
 * how it stands; and under each, its newest asks and passkeys.
 */
-const waitingLines = (wait, now) => [`${wait.check}${paramValues(wait.params)} · waiting, until ${minute(wait.endsAt)} · ${wait.start}`, ...wait.runs.flatMap((run, index) => {
+const waitingLines$1 = (wait, now) => [`${wait.check}${paramValues(wait.params)} · waiting, until ${minute(wait.endsAt)} · ${wait.start}`, ...wait.runs.flatMap((run, index) => {
 	const last = index === wait.runs.length - 1;
 	const under = last ? "   " : "│  ";
 	return [`${last ? "└─" : "├─"} ${run.title ?? run.workflow} · ${waitedText[run.state]} · ${run.workflow}.ts`, ...run.leaves.map((leaf, at) => `${under}${at === run.leaves.length - 1 ? "└─" : "├─"} ${leafText(leaf, now)}`)];
@@ -25026,7 +25347,7 @@ const isPlainJson = (value, depth = 0) => {
 	const proto = Object.getPrototypeOf(value);
 	return (proto === Object.prototype || proto === null) && Object.values(value).every(inner);
 };
-const decodeAnswer = Schema.decodeUnknownOption(CheckRunAnswer);
+const decodeAnswer$1 = Schema.decodeUnknownOption(CheckRunAnswer);
 const encodeJson$1 = Schema.encodeSync(Schema.fromJsonString(Schema.Json));
 /**
 * A check's bundle, written for `import()` under a name of its code's and this process's, in the
@@ -25167,7 +25488,7 @@ const runPart = Effect.fnUntraced(function* (own, part) {
 			error: "timeout",
 			why: `It ran past its timeout, ${part.timeoutSeconds} seconds`
 		}),
-		onSome: (answer) => isPlainJson(answer, 0) ? Option.getOrElse(decodeAnswer(answer), () => ({
+		onSome: (answer) => isPlainJson(answer, 0) ? Option.getOrElse(decodeAnswer$1(answer), () => ({
 			error: "invalid output",
 			why: "Its answer isn't one a check gives"
 		})) : {
@@ -25364,7 +25685,7 @@ const runLocally = Effect.fnUntraced(function* (folder, check, named, asJson) {
 	if (Option.isNone(thread)) return yield* sayFailed("Name the thread with --thread owner/project#number.");
 	const root = yield* gitIn(folder, ["rev-parse", "--show-toplevel"]);
 	if (Option.isNone(root) || root.value === "") return yield* sayFailed("Git couldn’t find this checkout’s root.");
-	const session = yield* (yield* SessionToken).current.pipe(Effect.catchTag("KeychainError", (failed) => sayFailed(failed.nextStep)));
+	const session = yield* (yield* SessionToken).current.pipe(Effect.catchTag(["KeychainError", "NoSession"], (failed) => sayFailed(failed.nextStep)));
 	if (Option.isSome(session) && Option.isSome(named.agent)) return yield* sayFailed("A session’s local run is signed by the session: leave out --agent.");
 	if (Option.isNone(session) && Option.isNone(named.agent)) return yield* sayFailed("Outside a session, name the agent this machine is attached as, with --agent owner/handle: a local run is signed by the attachment it ran on.");
 	const attachment = Option.isSome(named.agent) ? { attachment: yield* namedAttachment(named.agent.value, Option.none(), true) } : {};
@@ -25462,7 +25783,7 @@ const nextStepsFor = (place, wait) => `Wait on it with ref0 runs waiting ${wait.
 /** Says a waiting start's tree on stderr, as it stands now. */
 const sayTree = Effect.fnUntraced(function* (wait) {
 	const now = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
-	yield* Console.error(printable(waitingLines(wait, now)));
+	yield* Console.error(printable(waitingLines$1(wait, now)));
 });
 /**
 * Waits on a start that waits until it goes on or ends, or 9 minutes pass: what it got, printed
@@ -25609,7 +25930,7 @@ const run = Command.make("run", {
 		value
 	}, asJson, rerunCommand);
 	const now = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
-	yield* printAnswer(answer.json, asJson, `${waitingLines(value.waiting, now)}\n${nextStepsFor(place, value.waiting)}`);
+	yield* printAnswer(answer.json, asJson, `${waitingLines$1(value.waiting, now)}\n${nextStepsFor(place, value.waiting)}`);
 }).pipe(Effect.catchTag("CallFailed", failedWith$13))).pipe(Command.withDescription("Run a check on main, or on a thread’s head: a run it ran already is answered, not run again, unless the check says reuse: false. A start its check’s start rule makes wait shows what it waits on, and waits up to 9 minutes for it, unless --no-wait. With --local, run a check of the thread’s open version on this machine, and report it"), Command.withShortDescription("Run a check on main or a thread’s head"));
 const trace = Command.make("trace", {
 	run: Argument.String("run").pipe(Argument.withDescription("The run, as checkrun_… or workflowrun_…")),
@@ -25687,7 +26008,7 @@ const waiting$1 = Command.make("waiting", {
 		value
 	}, asJson, rerunCommand);
 	const now = DateTime.makeUnsafe(yield* Clock.currentTimeMillis);
-	yield* printAnswer(answer.json, asJson, `${waitingLines(value.waiting, now)}\n${nextStepsFor(place, value.waiting)}`);
+	yield* printAnswer(answer.json, asJson, `${waitingLines$1(value.waiting, now)}\n${nextStepsFor(place, value.waiting)}`);
 }).pipe(Effect.catchTag("CallFailed", failedWith$13))).pipe(Command.withDescription("A start of yours its check’s start rule made wait: what it waits on, as a tree, waiting up to 9 minutes for it to go on or end, unless --no-wait"), Command.withShortDescription("Show what a waiting start waits on"));
 /** What a cancel did, in words. */
 const cancelledText = {
@@ -25806,19 +26127,21 @@ const checksCommands = [Command.make("checks").pipe(Command.withDescription("A r
 //#endregion
 //#region src/gate-lines.ts
 /**
-* A pull request's gate as `ref0 gate` says it: its current version, whether its needs are
-* answered, the project gate's revision and whether it failed, and each need on its own line
-* with where it came from, ref0's floor or the line of `.ref0/gate.ts`, or of the project gate's,
-* that returned it, with that line's code. A need for one of the project's checks says the
-* project gate revision whose checks run for it, the version's own. Then what each gate read of
-* the change, each read's tree, path and the object it found, short. Then its gate decided again
-* in place under `main`'s `.ref0/`, with `main`'s commit: the needs it held, or those that grew,
-* and why. Then the additions standing on the pull request now, each with the ID `ref0 pr needs
-* remove` takes: the version's own say who added its needs when it was made, and one may have gone
-* since. Then the local runs of its parts' identities, each with its signer; each part that takes
-* local or needs a yes, with its wrappers, the run and the yeses that meet it or what it waits for;
-* and last, each signer revoked from answering one of their checks, an attachment or a person by
-* name, with how an admin restores them.
+* A pull request's gate as `ref0 gate` says it: its current version, whether its gate returned its
+* needs, and once it's open, how many still wait and whose one yes would meet them all; the project
+* gate's revision and whether it failed; and each need on its own line with where it came from,
+* ref0's floor or the line of `.ref0/gate.ts`, or of the project gate's, that returned it, with
+* that line's code, and under it whether it's met, by whose yes, or on whom or what it waits; in an
+* organization, what one yes gives its giver. A need for one of the project's checks says the
+* project gate revision whose checks run for it, the version's own. Then what each gate read of the
+* change, each read's tree, path and the object it found, short. Then its gate decided again in
+* place under `main`'s `.ref0/`, with `main`'s commit: the needs it held, or those that grew, and
+* why. Then the additions standing on the pull request now, each with the ID `ref0 pr needs remove`
+* takes: the version's own say who added its needs when it was made, and one may have gone since.
+* Then the local runs of its parts' identities, each with its signer; each part that takes local or
+* needs a yes, with its wrappers, the run and the yeses that meet it or what it waits for; and
+* last, each signer revoked from answering one of their checks, an attachment or a person by name,
+* with how an admin restores them.
 */
 const fromWords = (from) => {
 	switch (from.kind) {
@@ -25849,11 +26172,116 @@ const columns = (lines) => {
 * version was decided under, whose checks run for it, never `main`'s.
 */
 const noteOf = (need, view) => need.kind === "check" && need.source === "project" && view.projectRevision !== void 0 ? `  at gate revision ${view.projectRevision}` : "";
-const stateWords = (view) => {
+const isPerson = Schema.is(PersonId);
+/** An owner or a person, by name where it's known. */
+const nameOf = (id, named) => named.names.get(id) ?? id;
+/** The admins of an owner, in words: at home, its person alone, by name. */
+const adminsOf = (owner, named) => isPerson(owner) ? nameOf(owner, named) : `an admin of ${nameOf(owner, named)}`;
+/** Who answers as a decider, in words: a person by their name, a check by its key. */
+const whoWords = (decider, named) => {
+	switch (decider.kind) {
+		case "person": return nameOf(decider.id, named);
+		case "role": return adminsOf(decider.owner, named);
+		case "permission": return adminsOf(named.owner, named);
+		case "check": return checkKey(decider);
+		case "agent": return decider.id;
+		case "override": return whoWords(decider.by, named);
+	}
+};
+/** Alternatives in words, each once: `pip or an admin of acme`. */
+const anyOf = (deciders, named) => [...new Set(deciders.map((each) => whoWords(each, named)))].join(" or ");
+/** A yes that met a need, in words: whose, or the check that passed or was overridden. */
+const needYesWords = (yes, named) => {
+	if (yes.decider.kind === "check") return `${checkKey(yes.decider)} ${yes.overridden === true ? "overridden" : "passed"}`;
+	if (yes.by === void 0) return `${whoWords(yes.decider, named)}’s yes`;
+	const by = nameOf(yes.by, named);
+	return yes.decider.kind === "person" ? `${by}’s yes` : `${by}’s yes, as an admin`;
+};
+/** An override left of a check, in words: whose yes overrides which of its noes. */
+const overrideWords = (check, left, named) => `a yes from ${whoWords(left.by, named)} to override ${left.of === "failed run" ? `${check}’s failed run` : `${check} not running`}`;
+/**
+* One decider a need waits on, in words: a check to pass, or its parts when the need wraps it,
+* or, once ref0 said no to it, every override left.
+*/
+const waitWords = (wait, need, named) => {
+	if (wait.decider.kind !== "check") return whoWords(wait.decider, named);
+	const check = checkKey(wait.decider);
+	if (wait.overrides === void 0) return need.kind === "check" && (need.local === true || need.passkey !== void 0) ? `${check}’s parts, as below` : `${check} to pass`;
+	if (wait.overrides.length === 0) return `${check}, which ref0 said no to`;
+	return [...new Set(wait.overrides.map((left) => overrideWords(check, left, named)))].join(", and ");
+};
+/** The decider keys whose answers meet a need, for telling two needs met by the same yes. */
+const yesKey = (standing) => {
+	if (standing.state === "met" && "by" in standing && standing.by.every(({ decider }) => decider.kind !== "check")) return standing.by.map(({ decider }) => deciderKey(decider)).join(" ");
+	if (standing.state === "waiting" && "on" in standing && !standing.all) return standing.on.map(({ decider }) => deciderKey(decider)).join(" ");
+};
+/** How a need stands, in words. */
+const standingWords = (standing, need, named) => {
+	switch (standing.state) {
+		case "refused": return `refused: ${nameOf(standing.by, named)} said no, which decides the gate no`;
+		case "met": {
+			if ("as" in standing) return standing.as === "no checks" ? "met: no check runs on this change" : "met: the merge queue’s tip runs it, and main moves only once it passes there";
+			const people = /* @__PURE__ */ new Map();
+			for (const yes of standing.by) {
+				const who = yes.by ?? deciderKey(yes.decider);
+				if (!people.has(who)) people.set(who, yes);
+			}
+			const yeses = [...new Set([...people.values()].map((yes) => needYesWords(yes, named)))];
+			return standing.by.some(({ decider }) => decider.kind === "check") ? `met: ${yeses.join(", ")}` : `met by ${yeses.join(" and ")}`;
+		}
+		case "waiting": {
+			if ("for" in standing) return "waiting for ref0 to read which of main’s checks run on this change";
+			if (standing.all) return `waiting for ${standing.on.map((wait) => waitWords(wait, need, named)).join(", and ")}`;
+			const asked = `a yes from ${anyOf(standing.on.map(({ decider }) => decider), named)}`;
+			return need.kind === "check" || need.kind === "checks" ? `waiting on ${asked}: no run can meet it before main moves` : `waiting on ${asked}`;
+		}
+	}
+};
+/**
+* Who one yes would meet a waiting need with, in words, each alone: anyone it asks a yes of, or
+* the one answerer of every override it waits on; none for a check to pass.
+*/
+const meetersOf = (standing, named) => {
+	if (standing.state !== "waiting" || !("on" in standing)) return [];
+	if (!standing.all) return standing.on.map(({ decider }) => whoWords(decider, named));
+	const answerers = new Set(standing.on.flatMap(({ overrides }) => overrides === void 0 || overrides.length === 0 ? [""] : overrides.map((left) => whoWords(left.by, named))));
+	return answerers.size === 1 && !answerers.has("") ? [...answerers] : [];
+};
+/** An open gate's standings, or none until every need has one. */
+const standingsOf = (needs) => {
+	const standings = needs.flatMap(({ standing }) => standing === void 0 ? [] : [standing]);
+	return standings.length === 0 || standings.length < needs.length ? void 0 : standings;
+};
+/**
+* Where an open gate's needs stand, after its state: each met; refused, by whom; or how many
+* still wait, and whose one yes would meet them all, since one yes answers every decider its
+* person may answer as.
+*/
+const standsWords = (needs, named) => {
+	const standings = standingsOf(needs);
+	if (standings === void 0) return "";
+	const refused = standings.find((each) => each.state === "refused");
+	if (refused !== void 0 && refused.state === "refused") return `; ${nameOf(refused.by, named)} said no, which decides it no`;
+	const waiting = standings.filter((each) => each.state === "waiting");
+	if (waiting.length === 0) return "; each need is met";
+	const [first, ...rest] = waiting.map((each) => meetersOf(each, named));
+	const common = (first ?? []).filter((who) => rest.every((each) => each.includes(who)));
+	const still = waiting.length === 1 ? "1 still waits" : `${waiting.length} still wait`;
+	if (common.length === 0) return `; ${still}`;
+	return `; ${still}, and one yes from ${[...new Set(common)].join(" or ")} meets ${waiting.length === 1 ? "it" : "them all"}`;
+};
+/**
+* In an organization, what one yes gives, under the needs, while one waits on a yes: every
+* approval and override its giver may give, so an admin's meets every need an admin may meet.
+*/
+const oneYesLines = (view, named) => {
+	return (standingsOf(view.needs) ?? []).some((each) => each.state === "waiting" && "on" in each && each.on.some(({ decider, overrides }) => decider.kind !== "check" || overrides !== void 0)) && !isPerson(view.owner) ? [`  one yes to this gate gives every approval and override above its giver may give, as themselves and as ${adminsOf(view.owner, named)}`] : [];
+};
+const stateWords = (view, named) => {
 	switch (view.state) {
-		case "pending": return "its gate hasn’t answered yet";
-		case "answered": return "answered";
-		case "failed": return `its gate failed: ${view.why ?? "ref0 couldn’t run it"}`;
+		case "pending": return "its gate hasn’t returned its needs yet";
+		case "answered": return `its gate returned its needs${standsWords(view.needs, named)}`;
+		case "failed": return `its gate failed: ${view.why ?? "ref0 couldn’t run it"}${standsWords(view.needs, named)}`;
 	}
 };
 /** The project gate's line, under the head: its revision, and why it failed. */
@@ -25861,7 +26289,7 @@ const projectWords$1 = (view) => {
 	const project = view.projectGate;
 	if (project === void 0) return [];
 	const at = `  project gate, revision ${project.revision}`;
-	return [project.state === "failed" ? `${at}: failed: ${project.why ?? "ref0 couldn’t run it"}, so an admin answers it` : `${at}: ${project.state}`];
+	return [project.state === "failed" ? `${at}: failed: ${project.why ?? "ref0 couldn’t run it"}, so an admin answers it` : `${at}: ${project.state === "pending" ? "hasn’t returned its needs yet" : "returned its needs"}`];
 };
 /**
 * What a gate read of the change, under `head`: each read's tree, its path and the object it
@@ -25876,6 +26304,23 @@ const needLines = (needs, view) => columns(needs.map(({ need, from }) => ({
 	need: spellNeed(need),
 	from: `${from.map(fromWords).join("; ")}${noteOf(need, view)}`
 })));
+/**
+* The version's needs, each with how it stands on the line under it, once its gate is open: a
+* need met by, or waiting on, the same yes as one above says so.
+*/
+const standingLines = (view, named) => {
+	const lines = needLines(view.needs, view);
+	const seen = /* @__PURE__ */ new Map();
+	return view.needs.flatMap(({ need, standing }, i) => {
+		const line = lines[i] ?? "";
+		if (standing === void 0) return [line];
+		const key = yesKey(standing);
+		const same = key === void 0 ? void 0 : seen.get(key);
+		if (key !== void 0 && same === void 0) seen.set(key, need);
+		const also = same === void 0 ? "" : `, the same yes as ${spellNeed(same)}`;
+		return [line, `    ${standingWords(standing, need, named)}${also}`];
+	});
+};
 const grewWords = (grew) => {
 	const why = grew.why ?? "ref0 couldn’t say why";
 	switch (grew.kind) {
@@ -25887,7 +26332,7 @@ const grewWords = (grew) => {
 };
 const inPlaceLines = (inPlace, view) => {
 	const head = `under main’s .ref0/, at ${inPlace.main.slice(0, 7)}:`;
-	if (inPlace.state === "pending") return [`${head} its gate there hasn’t answered yet`];
+	if (inPlace.state === "pending") return [`${head} its gate there hasn’t returned its needs yet`];
 	const reads = readLines("its gate there read:", inPlace.reads ?? []);
 	if (inPlace.state === "held" || inPlace.grew === void 0) return [
 		`${head} ${inPlace.state}`,
@@ -25961,7 +26406,11 @@ const wrappedPartLines = (parts) => parts.length === 0 ? [] : ["parts that take
 const revokedSignerLines = (one) => one.kind === "attachment" ? [`  ${one.check}  attachment ${one.attachment.id} of ${one.attachment.person}, since ${DateTime.formatIso(one.at)}: ref0 failed local run ${one.signed}'s identity twice, the second in run ${one.failed}`, `    an admin restores it: ref0 checks signers restore ${one.check} --attachment ${one.attachment.id}`] : [`  ${one.check}  ${one.person}, since ${DateTime.formatIso(one.at)}: ref0 failed the identity of run ${one.signed}, which they said yes over, twice, the second in run ${one.failed}`, `    an admin restores them: ref0 checks signers restore ${one.check} --person ${one.person}`];
 const revokedLines = (revoked) => revoked.length === 0 ? [] : ["signers revoked:", ...revoked.flatMap(revokedSignerLines)];
 const gateLines = (view, repo) => {
-	const head = `${repo}#${view.pullRequest}, version ${view.version}: ${stateWords(view)}`;
+	const named = {
+		names: new Map((view.names ?? []).map(({ owner, name }) => [owner, name])),
+		owner: view.owner
+	};
+	const head = `${repo}#${view.pullRequest}, version ${view.version}: ${stateWords(view, named)}`;
 	const inPlace = view.inPlace === void 0 ? [] : inPlaceLines(view.inPlace, view);
 	const added = view.added.map(({ need, from }) => ({
 		need: spellNeed(need),
@@ -25973,7 +26422,8 @@ const gateLines = (view, repo) => {
 	return [
 		head,
 		...projectWords$1(view),
-		...needLines(view.needs, view),
+		...standingLines(view, named),
+		...oneYesLines(view, named),
 		...readLines("its gate read:", view.reads),
 		...readLines("its project gate read:", view.projectGate?.reads ?? []),
 		...inPlace,
@@ -26028,7 +26478,7 @@ const gateCommands = [Command.make("gate", {
 		}
 	});
 	yield* printAnswer(answer.json, asJson, gateLines(answer.value, repo));
-}).pipe(Effect.catchTag("CallFailed", failedWith$11))).pipe(Command.withDescription("A pull request’s needs, each with where it came from: ref0’s floor, or a line of .ref0/gate.ts; with --project, the project gate"), Command.withShortDescription("Show a pull request’s or project’s gate"))];
+}).pipe(Effect.catchTag("CallFailed", failedWith$11))).pipe(Command.withDescription("A pull request’s needs, each with where it came from, ref0’s floor or a line of .ref0/gate.ts, and whether it’s met or on whom it waits; with --project, the project gate"), Command.withShortDescription("Show a pull request’s or project’s gate"))];
 //#endregion
 //#region src/clone.ts
 /** The remote a clone pushes to: its thread's fork path, named as the thread is. */
@@ -26143,6 +26593,44 @@ const answerGit = Effect.fnUntraced(function* (operation, input) {
 	return Option.map(token, credentialLines);
 });
 //#endregion
+//#region src/own-session.ts
+/**
+* A command only an agent's session runs, on a repo of the session's project. Its endpoints take
+* the repo's name alone and find it in that project, so the command takes the name alone too: an
+* owner it couldn't check could name another project's repo, and the session's of that name
+* would be changed in its place.
+*/
+const decodeRepoName$1 = Schema.decodeUnknownOption(RepoName);
+/**
+* The token of the agent's session a command runs in. Outside one it says `outside`, what the
+* command is for; in a harness session whose ref0 session never started, why and what to do.
+* Either way it fails before anything's sent.
+*/
+const ownSession = Effect.fnUntraced(function* (outside) {
+	const token = yield* (yield* SessionToken).current.pipe(Effect.catchTag("NoSession", (none) => sayFailed(none.nextStep)));
+	if (Option.isNone(token)) return yield* sayFailed(outside);
+	return token.value;
+});
+/** The repo of a session's command, by its name alone. */
+const sessionRepoFlag = Flag.String("repo").pipe(Flag.withDescription("A repo of your session’s project, by its name alone, as shop; if not named, the one this checkout is of"), Flag.optional);
+/**
+* The session a command runs as, and the name of the repo it acts on: the one named, or this
+* checkout's. Outside a session it says `outside`, what the command is for, and fails before
+* anything's sent.
+*/
+const sessionRepo = Effect.fnUntraced(function* (named, outside) {
+	yield* ownSession(outside);
+	const checkout = yield* Checkout;
+	const repo = Option.isSome(named) ? decodeRepoName$1(named.value) : yield* checkout.repoAt(".");
+	if (Option.isNone(repo)) return yield* sayFailed(Option.isSome(named) ? "Name a repo of your session’s project by its name alone, as --repo shop." : "Name the repo with --repo and its name, as --repo shop, or run this in its checkout.");
+	const session = (yield* callEndpoint({ endpoint: "me.get" })).value.session?.session;
+	if (session === void 0) return yield* sayFailed("This token isn’t a session’s.");
+	return {
+		session,
+		repo: repo.value
+	};
+});
+//#endregion
 //#region src/sync-history.ts
 const decodePlace = Schema.decodeUnknownEffect(Schema.Struct({
 	owner: OwnerRef,
@@ -26198,7 +26686,7 @@ const trimShallow = Effect.fnUntraced(function* (gitDir) {
 */
 const loadSyncHistory = Effect.fnUntraced(function* (gitDir, repo) {
 	const config = yield* Ref0Config;
-	const token = yield* (yield* SessionToken).current;
+	const token = yield* (yield* SessionToken).current.pipe(Effect.catchTag("NoSession", () => Effect.succeedNone));
 	if (Option.isNone(token)) return yield* new HistoryNotLoaded({ why: "this terminal has no session to load it as" });
 	const fs = yield* FileSystem.FileSystem;
 	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
@@ -26371,9 +26859,8 @@ const gitCommands = [
 		json
 	}, ({ repo: written, directory, json: asJson }) => Effect.gen(function* () {
 		const { owner, repo: name } = repoParts(written);
-		const session = yield* SessionToken;
 		const config = yield* Ref0Config;
-		if (Option.isNone(yield* session.current)) return yield* sayFailed("ref0 clone runs in an agent’s session, which pushes to a fork of its own. A person’s clone, by approval, isn’t built yet.");
+		yield* ownSession("ref0 clone runs only in an agent’s ref0 session, which pushes to a fork of its own, and none runs here. In Claude Code or Codex, one starts at each prompt once ref0 connect has connected its config folder.");
 		const ours = (yield* callEndpoint({ endpoint: "me.get" })).value.session?.session;
 		if (ours === void 0) return yield* sayFailed("This token isn’t a session’s.");
 		const fork = yield* callEndpoint({
@@ -26405,8 +26892,7 @@ const gitCommands = [
 		yield* printAnswer(fork.json, asJson, `Cloned ${owner}/${name} into ${into}. origin is read-only to agents: git push goes to ${forkRemote(fork.value)}, the fork of whichever session on the thread pushes.`);
 	}).pipe(Effect.catchTag("CallFailed", failedWith$10))).pipe(Command.withDescription("Clone a repo of the session’s project, to push to its fork"), Command.withShortDescription("Clone a repo to work in your session’s fork")),
 	Command.make("sync", { json }, ({ json: asJson }) => Effect.gen(function* () {
-		const session = yield* SessionToken;
-		if (Option.isNone(yield* session.current)) return yield* sayFailed("ref0 sync runs in an agent’s session, in a clone ref0 clone made.");
+		yield* ownSession("ref0 sync runs in an agent’s session, in a clone ref0 clone made.");
 		const synced = yield* syncBase(".");
 		if (synced.kind === "refused") return yield* sayFailed(synced.why);
 		const { on, commit } = synced.base;
@@ -27442,18 +27928,28 @@ const repoCommands = [Command.make("repos", {
 //#endregion
 //#region src/decision-lines.ts
 /** A decision in words, as `ref0 waiting`, `ref0 decision` and `ref0 answer` print it. */
-/** What a decision is about, in words. */
-const subjectWords = (subject) => {
-	switch (subject.kind) {
-		case "thread": return subject.thread;
-		case "version": return `version ${subject.version} of pull request ${subject.pullRequest} in ${subject.repo}, from ${subject.thread}`;
-	}
-};
+/** What a decision is about, in words: its thread, and a gate's version of its pull request. */
+const subjectWords = ({ subject, names }) => subject.kind === "version" && names.pullRequest !== void 0 ? `version ${subject.version} of ${names.pullRequest}, from ${names.thread}` : names.thread;
 /** A decision in a line. */
-const decisionLines = (view) => {
-	const on = subjectWords(view.subject);
-	const answers = view.options.map((option) => option.key).join(" or ");
-	return view.state === "open" ? `${view.decision}  on ${on}: ${answers}` : `${view.decision}  on ${on}: ${view.result ?? "no answer"}, ${view.closedWhy ?? "closed"}`;
+const decisionLines = (decision) => {
+	const on = subjectWords(decision);
+	const answers = decision.options.map((option) => option.key).join(" or ");
+	return decision.state === "open" ? `${decision.decision}  on ${on}: ${answers}` : `${decision.decision}  on ${on}: ${decision.result ?? "no answer"}, ${decision.closedWhy ?? "closed"}`;
+};
+const nothing = "Nothing waits on you here.";
+/**
+* What waits, as `ref0 waiting` prints it: what waits on the caller, then, for an agent, what
+* waits on its person, which they answer on their own page.
+*/
+const waitingLines = (decisions) => {
+	const yours = decisions.flatMap((decision) => decision.waitsOn === "you" ? [decisionLines(decision)] : []);
+	const theirs = decisions.flatMap((decision) => decision.waitsOn === "your person" ? [`  ${decisionLines(decision)}`] : []);
+	if (theirs.length === 0) return yours.length === 0 ? nothing : yours.join("\n");
+	return [
+		...yours,
+		"Waits on your person, under Waiting on you on their page:",
+		...theirs
+	].join("\n");
 };
 //#endregion
 //#region src/commands/plans.ts
@@ -27647,9 +28143,7 @@ const planCommands = [
 			endpoint: "decisions.waiting",
 			params: scopeParams(address)
 		}));
-		const { decisions } = answer.value;
-		const words = decisions.length === 0 ? "Nothing waits on you here." : decisions.map((each) => decisionLines(each)).join("\n");
-		yield* printAnswer(answer.json, asJson, words);
+		yield* printAnswer(answer.json, asJson, waitingLines(answer.value.decisions));
 	}).pipe(Effect.catchTag("CallFailed", (failed) => sayFailed(failed.nextStep)))).pipe(Command.withDescription("What in a project, or in an organization’s org threads, waits on you"), Command.withShortDescription("Show what waits on you")),
 	Command.make("decision", {
 		project: project$2,
@@ -27690,35 +28184,6 @@ const planCommands = [
 	}).pipe(Effect.catchTag("CallFailed", (failed) => sayFailed(failed.nextStep)))).pipe(Command.withDescription("Answer a decision that waits on you"))
 ];
 //#endregion
-//#region src/own-session.ts
-/**
-* A command only an agent's session runs, on a repo of the session's project. Its endpoints take
-* the repo's name alone and find it in that project, so the command takes the name alone too: an
-* owner it couldn't check could name another project's repo, and the session's of that name
-* would be changed in its place.
-*/
-const decodeRepoName$1 = Schema.decodeUnknownOption(RepoName);
-/** The repo of a session's command, by its name alone. */
-const sessionRepoFlag = Flag.String("repo").pipe(Flag.withDescription("A repo of your session’s project, by its name alone, as shop; if not named, the one this checkout is of"), Flag.optional);
-/**
-* The session a command runs as, and the name of the repo it acts on: the one named, or this
-* checkout's. Outside a session it says `outside`, what the command is for, and fails before
-* anything's sent.
-*/
-const sessionRepo = Effect.fnUntraced(function* (named, outside) {
-	const token = yield* SessionToken;
-	if (Option.isNone(yield* token.current)) return yield* sayFailed(outside);
-	const checkout = yield* Checkout;
-	const repo = Option.isSome(named) ? decodeRepoName$1(named.value) : yield* checkout.repoAt(".");
-	if (Option.isNone(repo)) return yield* sayFailed(Option.isSome(named) ? "Name a repo of your session’s project by its name alone, as --repo shop." : "Name the repo with --repo and its name, as --repo shop, or run this in its checkout.");
-	const session = (yield* callEndpoint({ endpoint: "me.get" })).value.session?.session;
-	if (session === void 0) return yield* sayFailed("This token isn’t a session’s.");
-	return {
-		session,
-		repo: repo.value
-	};
-});
-//#endregion
 //#region src/pull-request-lines.ts
 /**
 * Pull requests as `ref0 pr` says them: each one's number, thread, state and current version,
@@ -28179,8 +28644,7 @@ const taskCommands = [Command.make("tasks", {
 	file: Flag.FileText("file").pipe(Flag.withDescription("The whole list, as JSON: each task’s text, up to 200 characters, and its state, \"to do\", \"in progress\" or \"done\"; at most 50")),
 	json
 }, ({ file, json: asJson }) => Effect.gen(function* () {
-	const session = yield* SessionToken;
-	if (Option.isNone(yield* session.current)) return yield* sayFailed("ref0 tasks runs in an agent’s session, which sets its own list.");
+	yield* ownSession("ref0 tasks runs in an agent’s session, which sets its own list.");
 	const parsed = yield* Effect.result(decodeJsonText(file));
 	if (Result.isFailure(parsed)) return yield* sayFailed("That list isn’t JSON.");
 	const checked = yield* Effect.result(checkTasks(parsed.success));
@@ -28783,9 +29247,8 @@ const waitCommands = [Command.make("wait", {
 	blockers: Flag.Boolean("blockers").pipe(Flag.withDescription("Wait until nothing blocks your session’s thread from merging"), Flag.withDefault(false)),
 	json
 }, ({ blockers, json: asJson }) => Effect.gen(function* () {
-	const session = yield* SessionToken;
 	if (!blockers) return yield* sayFailed("Say what to wait for: ref0 wait --blockers waits until nothing blocks your thread.");
-	if (Option.isNone(yield* session.current)) return yield* sayFailed("ref0 wait --blockers runs in an agent’s session: it waits on its own thread.");
+	yield* ownSession("ref0 wait --blockers runs in an agent’s session: it waits on its own thread.");
 	yield* waitOnBlockers(asJson);
 }).pipe(Effect.catchTag("CallFailed", (failed) => sayFailed(failed.nextStep)))).pipe(Command.withDescription(`Wait until nothing blocks your session’s thread from merging, for 9 minutes at most`), Command.withShortDescription("Wait for your session’s thread to be ready to merge"))];
 //#endregion
@@ -32545,6 +33008,8 @@ function readHook(args) {
 */
 /** The keychain account a binding's thread is kept under, beside its session token's. */
 const threadAccount = (binding) => `${sessionAccount(binding)}/thread`;
+/** The keychain account a start not yet landed is kept under, beside its session token's. */
+const pendingAccount = (binding) => `${sessionAccount(binding)}/pending`;
 const decodeRequest = Schema.decodeUnknownEffect(StartSessionRequest);
 const decodeRequestId = Schema.decodeUnknownOption(RequestId);
 /**
@@ -32584,14 +33049,14 @@ const startHarnessSession = Effect.fnUntraced(function* (input) {
 	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 pendingAccount = `${sessionAccount(input.binding)}/pending`;
+	const pending = pendingAccount(input.binding);
 	const held = Option.flatMap(yield* keychain.get(sessionAccount(input.binding)), (kept) => parseToken(Redacted.value(kept)));
-	const pending = Option.filter(Option.flatMap(yield* keychain.get(pendingAccount), (kept) => decodePending(Redacted.value(kept))), (one) => !Option.exists(held, (parts) => parts.secret === one.secret));
-	const { requestId, secret } = Option.isSome(pending) ? pending.value : {
+	const resent = Option.filter(Option.flatMap(yield* keychain.get(pending), (kept) => decodePending(Redacted.value(kept))), (one) => !Option.exists(held, (parts) => parts.secret === one.secret));
+	const { requestId, secret } = Option.isSome(resent) ? resent.value : {
 		requestId: yield* newRequestId,
 		secret: encodeSecret(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)))
 	};
-	if (Option.isNone(pending)) yield* keychain.set(pendingAccount, Redacted.make(`${requestId} ${secret}`));
+	if (Option.isNone(resent)) yield* keychain.set(pending, Redacted.make(`${requestId} ${secret}`));
 	const hash = yield* hashOf(secret);
 	const where = input.on.kind === "thread" ? threadParts(input.on.written) : {
 		owner: grant.value.owner,
@@ -32621,7 +33086,7 @@ const startHarnessSession = Effect.fnUntraced(function* (input) {
 	const started = yield* (yield* ref0Client(config.api).pipe(Effect.provide(bearerCredential(grant.value.token)))).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(pendingAccount)), Match.orElse(() => Effect.void))));
+	}).pipe(Effect.tapError((error) => Match.value(error).pipe(Match.tag("ProjectNotFound", "ProjectNotReady", "ThreadNotFound", "ThreadIsClosed", "TextRefused", "NotPermitted", "DeliveryOutsideWindow", () => keychain.remove(pending)), Match.orElse(() => Effect.void))));
 	const thread = input.on.kind === "thread" ? input.on.written : writtenThread(grant.value.owner, {
 		kind: "project",
 		name: newThreadProject
@@ -32629,7 +33094,7 @@ const startHarnessSession = Effect.fnUntraced(function* (input) {
 	yield* keychain.remove(gitTokenAccount(input.binding)).pipe(Effect.ignore);
 	yield* keychain.set(sessionAccount(input.binding), Redacted.make(formatToken(started.credential.person, started.credential.id, secret)));
 	yield* keychain.set(threadAccount(input.binding), Redacted.make(thread)).pipe(Effect.ignore);
-	yield* keychain.remove(pendingAccount).pipe(Effect.ignore);
+	yield* keychain.remove(pending).pipe(Effect.ignore);
 	return Option.some(started);
 });
 //#endregion
@@ -32691,6 +33156,11 @@ const ownerOf = (bound) => ({
 const decodeWrittenThread = Schema.decodeUnknownOption(WrittenThread);
 /** How long a harness session with no token is left before the keychain is asked again. */
 const unboundMillis = 3e4;
+/**
+* How long a prompt's start may run on past its hook's deadline before it's given up, and a later
+* prompt sends it again, as itself: well past the slowest start seen on staging, 4.5 seconds.
+*/
+const startBound = "20 seconds";
 /** How often `ref0 mcp` renews its session's 30-minute lease while its harness process lives. */
 const renewEvery = "10 minutes";
 /** How soon a renewal that failed is tried again, well inside the lease. */
@@ -32706,6 +33176,7 @@ const sessionBinding = Effect.fnUntraced(function* (edges) {
 	const hints = yield* LiveHints;
 	const context = yield* Effect.context();
 	const owned = yield* Ref.make(Option.none());
+	const onTheWay = yield* Ref.make(Option.none());
 	const listen = Effect.fnUntraced(function* (bound) {
 		const client = yield* clientOf(bound.token);
 		let pause = 1;
@@ -32801,17 +33272,31 @@ const sessionBinding = Effect.fnUntraced(function* (edges) {
 		if (Option.isNone(started)) return Option.none();
 		return yield* keychain.get(sessionAccount(binding)).pipe(Effect.orElseSucceed(() => Option.none()));
 	});
+	const startedFor = Effect.fnUntraced(function* (binding, hook, starting) {
+		const sent = yield* Ref.get(onTheWay);
+		if (Option.isSome(sent) && sent.value.harnessSession === binding.harnessSession) return yield* Deferred.await(sent.value.done);
+		if (!starting) return Option.none();
+		const done = yield* Deferred.make();
+		const mine = Option.some({
+			harnessSession: binding.harnessSession,
+			done
+		});
+		yield* Ref.set(onTheWay, mine);
+		yield* Effect.forkIn(startAtPrompt(binding, hook).pipe(Effect.timeoutOption(startBound), Effect.map(Option.flatten), Effect.orElseSucceed(() => Option.none()), Effect.ensuring(Ref.update(onTheWay, (now) => now === mine ? Option.none() : now)), Effect.onExit((exit) => Deferred.done(done, exit))), scope);
+		return yield* Deferred.await(done);
+	});
 	const bind = Effect.fnUntraced(function* (hook) {
 		const now = yield* Clock.currentTimeMillis;
 		const current = yield* Ref.get(state);
 		if (current.kind === "bound" && current.bound.binding.harnessSession === hook.harnessSession) return Option.some(current.bound);
 		const starting = hook.event === "UserPromptSubmit" && Option.isSome(agent);
+		const sent = Option.exists(yield* Ref.get(onTheWay), (one) => one.harnessSession === hook.harnessSession);
 		const over = current.kind === "ended" && current.harnessSession === hook.harnessSession;
 		const waiting = current.kind === "unbound" && now < current.until && !starting;
-		if (over && !starting || waiting) return Option.none();
+		if ((over && !starting || waiting) && !sent) return Option.none();
 		const binding = yield* bindingForServer(hook.harnessSession);
 		const held = Option.isNone(binding) ? Option.none() : yield* heldFor(binding.value, over);
-		const token = Option.isSome(held) || Option.isNone(binding) || !starting ? held : yield* startAtPrompt(binding.value, hook);
+		const token = Option.isSome(held) || Option.isNone(binding) ? held : yield* startedFor(binding.value, hook, starting);
 		if (Option.isNone(binding) || Option.isNone(token)) {
 			if (!over) yield* Ref.set(state, {
 				kind: "unbound",
@@ -33101,7 +33586,7 @@ const toRead = (hook, ownHook) => {
 const sessionTurns = Effect.fnUntraced(function* (edges) {
 	const transcripts = yield* Transcripts;
 	const turn = yield* Ref.make(Option.none());
-	const trackTurn = Effect.fnUntraced(function* (client, bound, hook, deadline) {
+	const trackTurn = Effect.fnUntraced(function* (client, bound, hook, deadline, late = false) {
 		const checkout = yield* Checkout;
 		const session = bound.session;
 		const owner = ownerOf(bound);
@@ -33115,6 +33600,10 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 		const prompted = isNew ? hook.transcript : void 0;
 		if (prompted !== void 0) yield* transcripts.begin(owner, harness, prompted, harnessTurn);
 		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)
+		} : nothingSeen;
 		const tracked = isNew ? Option.some({
 			kind: "starting",
 			harnessTurn,
@@ -33125,7 +33614,7 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 					tokens: addRead(now.seen.tokens, ending, true)
 				}
 			}) : now.previous),
-			seen: nothingSeen
+			seen: fresh
 		}) : before;
 		if (Option.isNone(tracked)) return;
 		const ownHook = hook.harnessTurn === tracked.value.harnessTurn;
@@ -33201,6 +33690,7 @@ const sessionTurns = Effect.fnUntraced(function* (edges) {
 	return {
 		now: Ref.get(turn),
 		track: trackTurn,
+		trackLate: (client, bound, prompt, deadline) => trackTurn(client, bound, prompt, deadline, true),
 		fresh: Ref.set(turn, Option.none())
 	};
 });
@@ -33337,6 +33827,7 @@ var HarnessSession = class HarnessSession extends Context.Service()("ref0/cli/Ha
 			const scope = yield* Scope.Scope;
 			const tasks = yield* sessionTasks;
 			const turns = yield* sessionTurns({ tasksLanded: tasks.landed });
+			const prompted = yield* Ref.make(Option.none());
 			const edits = yield* sessionEdits({ turn: turns.now });
 			const delivery = yield* sessionDelivery;
 			const wake = yield* sessionWake({
@@ -33394,9 +33885,13 @@ var HarnessSession = class HarnessSession extends Context.Service()("ref0/cli/Ha
 				lastLook
 			});
 			const deliver = Effect.fnUntraced(function* (hook, deadline) {
+				if (hook.event === "UserPromptSubmit") yield* Ref.set(prompted, Option.some(hook));
 				const bound = yield* binding.bind(hook);
 				if (Option.isNone(bound)) return Option.none();
 				const client = yield* clientOf(bound.value.token);
+				const prompt = Option.filter(yield* Ref.get(prompted), (one) => one.harnessSession === hook.harnessSession && one.harnessTurn === hook.harnessTurn);
+				if (Option.isSome(prompt)) yield* Ref.set(prompted, Option.none());
+				if (Option.isSome(prompt) && prompt.value !== hook) yield* turns.trackLate(client, bound.value, prompt.value, deadline);
 				const unattributed = yield* edits.noteEdits(bound.value, hook);
 				const within = yield* binding.within;
 				if (yield* tasks.note(bound.value, hook)) yield* Effect.forkIn(tasks.send(client, bound.value).pipe(Effect.ignore), within);
@@ -33512,6 +34007,18 @@ const mcpServer = (version, started) => McpServer.toolkit(HarnessTools).pipe(Lay
 	protocols
 })));
 /**
+* `ref0 mcp` in a checkout of another origin, which the launcher names: the plugin's server all
+* the same, answering every hook with nothing, since that origin's own plugin serves the
+* checkout. A harness takes a server that closes before `initialize` as broken, and Claude Code
+* then skips it for 15 minutes, in every folder. It reads nothing of this machine's, so it
+* answers at once.
+*/
+const otherOriginServer = (version) => McpServer.toolkit(HarnessTools).pipe(Layer.provide(HarnessTools.toLayer({ hook: () => Effect.succeed({}) })), Layer.provide(McpServer.layerStdio({
+	name: "ref0",
+	version,
+	protocols
+})));
+/**
 * The `codex` that started this server, by absolute path: its executable, which Linux names, or
 * its command's first word when that's a path. Codex isn't sure to be on `PATH` (M0).
 */
@@ -33542,11 +34049,18 @@ const codexSetupHere = Effect.fnUntraced(function* (process) {
 	});
 });
 const mcp = Command.make(harnessCommandNames.mcp, {}, () => Effect.gen(function* () {
+	const checked = yield* Config.schema(ConnectHarness, serverCheckVariable).pipe(Config.option);
+	const other = yield* Config.option(Config.String(otherOriginVariable));
+	if (Option.isSome(other) && Option.isNone(checked)) {
+		yield* printBlocks([[`ref0: this folder is for ${other.value}, so ref0’s plugin for ${(yield* Ref0Config).api} does nothing in it.`]]);
+		return yield* Layer.launch(otherOriginServer(cliVersion));
+	}
 	const agents = yield* ConfigFolders;
-	const found = yield* (yield* HarnessProcess).innermost;
-	const agent = Option.isSome(found) ? yield* (yield* HostGrant).get(yield* agents.folder(found.value.harness)).pipe(Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeedNone)) : Option.none();
+	const found = Option.isSome(checked) ? Option.none() : yield* (yield* HarnessProcess).innermost;
+	const harness = Option.orElse(checked, () => Option.map(found, (each) => each.harness));
+	const agent = Option.isSome(harness) ? yield* (yield* HostGrant).get(yield* agents.folder(harness.value)).pipe(Effect.catchTag("KeychainError", (failed) => failed.unreadable === true ? Effect.succeedNone : sayFailed(failed.nextStep))) : Option.none();
 	const codex = Option.isSome(found) && found.value.harness === "codex" ? yield* codexSetupHere(found.value.process) : Option.none();
-	const reinstall = Option.isSome(found) && Option.isSome(agent) ? installLine(yield* agents.folder(found.value.harness)) : "ref0 connect";
+	const reinstall = Option.isSome(harness) && Option.isSome(agent) ? installLine(yield* agents.folder(harness.value)) : "ref0 connect";
 	return yield* Layer.launch(mcpServer(cliVersion, {
 		plugin: {
 			version: yield* pluginVersion,
@@ -33750,21 +34264,44 @@ const checkoutAt = Effect.fnUntraced(function* (cwd) {
 	};
 });
 /**
-* Adds the agent's commit environment to the file Claude Code names, for the session its
-* `SessionStart` opens: only in Claude Code, and only for a setup with an agent. ref0's hooks
-* folder is written first, so the file never names a folder that isn't there. Whether it set
-* ref0's hooks path.
+* The harness whose `SessionStart` runs this: Claude Code, which alone gives its hook the file it
+* runs ahead of the agent's commands, and never its agent's commands; else Codex, when the
+* innermost harness process above it is Codex's, as the session's binding reads it. Codex's hook
+* input says nothing Claude Code's doesn't, and Codex sets no `CODEX_HOME` for the default
+* `~/.codex`. Neither otherwise.
+*/
+const startingHarness = Effect.gen(function* () {
+	const file = yield* Config.String("CLAUDE_ENV_FILE").pipe(Config.withDefault(""));
+	if (file !== "") return Option.some({
+		harness: "claude-code",
+		file
+	});
+	const found = yield* (yield* HarnessProcess).innermost;
+	return Option.isSome(found) && found.value.harness === "codex" ? Option.some({ harness: "codex" }) : Option.none();
+});
+/**
+* What the agent reads when its commits couldn't be set up at its session's start, in one line,
+* whatever failed: the session still starts. Its commits may then name the person, skip ref0's
+* hooks, or meet a sign-off's refusal once.
+*/
+const commitSetupFailedWords = (error) => {
+	return `ref0: ref0 couldn't set up Git for your commands, so your commits may not name you as their author or run ref0's hooks: ${("nextStep" in error ? error.nextStep : "detail" in error ? error.detail : error.message).replaceAll(/\s+/g, " ").trim()}`;
+};
+/**
+* Adds the agent's commit environment for the session a `SessionStart` opens, in Claude Code to
+* the file it names and in Codex to its checkout's section, only for a setup with an agent. ref0's
+* hooks folder is written first, so nothing names a folder that isn't there. The harness whose
+* hooks path it set, if it set one.
 */
 const setCommitEnvironment = Effect.fnUntraced(function* (session) {
 	const fs = yield* FileSystem.FileSystem;
 	const folders = yield* ConfigFolders;
-	const file = yield* Config.String("CLAUDE_ENV_FILE").pipe(Config.withDefault(""));
-	if (file === "") {
-		if ((yield* Config.String("CODEX_HOME").pipe(Config.withDefault(""))) === "") return false;
-		return yield* setCodexCommitEnvironment(session.cwd ?? ".", yield* checkoutAt(session.cwd ?? "."));
-	}
+	const starting = yield* startingHarness;
+	if (Option.isNone(starting)) return Option.none();
+	const hook = starting.value;
+	if (hook.harness === "codex") return (yield* setCodexCommitEnvironment(session.cwd ?? ".", yield* checkoutAt(session.cwd ?? "."))) ? Option.some("codex") : Option.none();
 	const connected = yield* (yield* HostGrant).get(yield* folders.folder("claude-code")).pipe(Effect.map(Option.map(Option.some)), Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeedSome(Option.none())));
-	if (Option.isNone(connected)) return false;
+	if (Option.isNone(connected)) return Option.none();
 	const checkout = yield* checkoutAt(session.cwd ?? ".");
 	const folder = yield* hooksFolder(yield* gitHooksHome(yield* Config.String("HOME"), (yield* Ref0Config).api), checkout.folder);
 	const author = checkout.signsOff ? Option.none() : Option.map(connected.value, (grant) => ({
@@ -33778,8 +34315,8 @@ const setCommitEnvironment = Effect.fnUntraced(function* (session) {
 		transcript: Option.filter(Option.fromNullishOr(session.transcript_path), (path) => path !== ""),
 		model: startingModel(session.model)
 	});
-	yield* fs.writeFileString(file, script, { flag: "a" });
-	return true;
+	yield* fs.writeFileString(hook.file, script, { flag: "a" });
+	return Option.some("claude-code");
 });
 //#endregion
 //#region src/harness/session-start.ts
@@ -33831,10 +34368,8 @@ const startOnHook = (protocol) => Effect.gen(function* () {
 	const input = yield* stdio.stdin.pipe(Stream.decodeText(), Stream.mkString);
 	const hook = decodeHook(input);
 	if (Option.isNone(hook)) return;
-	if (yield* setCommitEnvironment(hook.value).pipe(Effect.orElseSucceed(() => false))) {
-		const claude = yield* Config.String("CLAUDE_ENV_FILE").pipe(Config.withDefault(""));
-		yield* Console.log(claude === "" ? codexHookInstallerWords : hookInstallerWords);
-	}
+	const hooksSet = yield* setCommitEnvironment(hook.value).pipe(Effect.catch((error) => Console.log(commitSetupFailedWords(error)).pipe(Effect.as(Option.none()))));
+	if (Option.isSome(hooksSet)) yield* Console.log(hooksSet.value === "codex" ? codexHookInstallerWords : hookInstallerWords);
 	const binding = yield* bindingHere(hook.value.session_id);
 	if (Option.isNone(binding)) return;
 	const harnessName = binding.value.harness === "codex" ? "codex" : "claude-code";
@@ -33888,6 +34423,205 @@ const sessionStart = Command.make(harnessCommandNames.sessionStart, { protocol:
 /** The commands a harness runs: `ref0 mcp`, and its command hooks. */
 const harnessCommands = [mcp, Command.make(harnessCommandNames.hook).pipe(Command.withDescription("The harness's hooks that run as commands"), Command.withShortDescription("Run the harness’s session hooks"), Command.withSubcommands([sessionStart, sessionEnd]))];
 //#endregion
+//#region src/harness/command-token.ts
+/**
+* The session an agent's command acts as: its harness session's, by the token kept under its
+* binding. Outside a harness there's none, and a command is its person's, asked by approval; so
+* too in a harness whose config folder has no agent connected. Where one is connected, a harness
+* session with no token has lost its start, and the command says why, as far as ref0 can tell,
+* and what to do, rather than run as its person.
+*/
+/**
+* Whether ref0's server, `ref0 mcp`, runs right under a harness process, as the harness starts
+* it: none when the process table can't be read.
+*/
+var HarnessServers = class HarnessServers extends Context.Service()("ref0/cli/HarnessServers") {
+	static layer = Layer.effect(HarnessServers, Effect.gen(function* () {
+		const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+		const runsUnder = (process) => spawner.string(ChildProcess.make("ps", [
+			"-A",
+			"-o",
+			"ppid=,args="
+		])).pipe(Effect.map((table) => table.trim() === "" ? Option.none() : Option.some(table.split("\n").some((line) => {
+			const [parent = "", ...words] = line.trim().split(/\s+/);
+			return Number(parent) === process && words.at(-1) === harnessCommandNames.mcp && words.some((word) => word.includes("ref0"));
+		}))), Effect.orElseSucceed(() => Option.none()));
+		return HarnessServers.of({ runsUnder });
+	}));
+};
+/**
+* What an agent's command in a harness session with no ref0 session says to do: run again, while
+* the prompt's start is on its way; reconnect or restart, when the server isn't running; else
+* send the prompt again, which starts one.
+*/
+const noSessionStep = (harness, server, seen) => {
+	const name = configFolders[harness].name;
+	const restart = harness === "codex" ? "restart Codex" : `run /mcp, choose ${server} and Reconnect, or restart Claude Code`;
+	if (Option.contains(seen.serverRuns, false)) return `This ${name} session has no ref0 session: ref0’s server isn’t running in it, so none started at the last prompt. Tell your person to ${restart}, then send the prompt again.`;
+	if (seen.pending) return `This ${name} session has no ref0 session yet: its start at the last prompt hasn’t landed. Run this again in a few seconds. If it says this again, tell your person to send the prompt again.`;
+	return `This ${name} session has no ref0 session: none started at the last prompt. Tell your person to send the prompt again. If it says this again, tell them to ${restart}.`;
+};
+/** `SessionToken` from the keychain, by the binding of the harness session this runs in. */
+const harnessSessionToken = Layer.effect(SessionToken, Effect.gen(function* () {
+	const keychain = yield* Keychain;
+	const harness = yield* HarnessProcess;
+	const servers = yield* HarnessServers;
+	const hostGrant = yield* HostGrant;
+	const folders = yield* ConfigFolders;
+	const config = yield* Ref0Config;
+	const plugin = yield* originPluginName(config.api);
+	const current = Effect.gen(function* () {
+		const binding = yield* bindingHere().pipe(Effect.provideService(HarnessProcess, harness), Effect.orElseSucceed(() => Option.none()));
+		if (Option.isNone(binding)) return Option.none();
+		const kept = yield* keychain.get(sessionAccount(binding.value));
+		if (Option.isSome(kept)) return kept;
+		const name = binding.value.harness === "codex" ? "codex" : "claude-code";
+		const grant = yield* hostGrant.get(yield* folders.folder(name)).pipe(Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeedNone));
+		if (Option.isNone(grant) || grant.value.harness !== name) return Option.none();
+		const pending = yield* keychain.get(pendingAccount(binding.value));
+		const serverRuns = yield* servers.runsUnder(binding.value.process);
+		return yield* new NoSession({ nextStep: noSessionStep(name, `plugin:${plugin}:${plugin}`, {
+			serverRuns,
+			pending: Option.isSome(pending)
+		}) });
+	});
+	return SessionToken.of({ current });
+}));
+//#endregion
+//#region src/harness/server-check.ts
+/**
+* Whether a config folder's ref0 server starts, asked as its harness asks: the command its
+* installed plugin's `.mcp.json` names, started from an empty folder of ref0's own with the
+* environment that harness would give it from this terminal's, and sent `initialize`. Told by
+* `serverCheckVariable` which harness it's started as, the server reads that folder's grant from
+* the keychain as it does at a session's start, and starts no session. Its whole process group is
+* stopped once it answers, stops, or the limit passes, so nothing it started outlasts the check.
+*/
+/**
+* The variables Codex 0.164.0 passes a stdio server of its own, beside those its entry's
+* `env_vars` names that are set. Nothing else reaches the server (measured on Linux, 24 Oct 2026).
+*/
+const codexPasses = [
+	"HOME",
+	"LOGNAME",
+	"PATH",
+	"SHELL",
+	"USER",
+	"LANG",
+	"LC_ALL",
+	"TERM",
+	"TMPDIR",
+	"TZ",
+	"__CF_USER_TEXT_ENCODING",
+	"SSL_CERT_FILE",
+	"NODE_EXTRA_CA_CERTS"
+];
+/**
+* How long a server has to answer `initialize`: ten times its slowest start measured on Linux,
+* 0.5 s (24 Oct 2026), so status stays quick. A harness may wait longer (Codex 0.164.0 waited 14 s
+* for a slow one), so a server that doesn't answer in it is unknown, not one that can't start.
+*/
+const serverLimit = Duration.seconds(5);
+const checkId = "ref0-status";
+/**
+* `initialize` and its answer, as JSON-RPC carries them, in MCP's own schemas: those `ref0 mcp`
+* serves through Effect's MCP server.
+*/
+const InitializeRequest = Schema.Struct({
+	jsonrpc: Schema.Literal("2.0"),
+	id: Schema.Literal(checkId),
+	method: Schema.Literal(McpSchema.Initialize._tag),
+	params: McpSchema.Initialize.payloadSchema
+});
+const InitializeAnswer = Schema.Struct({
+	id: Schema.Literal(checkId),
+	result: McpSchema.InitializeResult
+});
+/** `initialize`, at a version every ref0 server speaks, as a harness's first line. */
+const initialize = `${Schema.encodeSync(Schema.fromJsonString(InitializeRequest))({
+	jsonrpc: "2.0",
+	id: checkId,
+	method: McpSchema.Initialize._tag,
+	params: {
+		protocolVersion: "2025-06-18",
+		capabilities: new McpSchema.ClientCapabilities({}),
+		clientInfo: {
+			name: "ref0 status",
+			version: cliVersion
+		}
+	}
+})}\n`;
+const decodeServers = Schema.decodeUnknownEffect(Schema.fromJsonString(McpServersFile));
+const decodeAnswer = Schema.decodeUnknownOption(Schema.fromJsonString(InitializeAnswer));
+/**
+* `names` as this terminal sets them, which a harness started here would pass on. A relative
+* `PATH` folder is read from here, as `onPath` reads it, since the server starts elsewhere.
+*/
+const fromHere = Effect.fnUntraced(function* (names) {
+	const paths = yield* Path.Path;
+	const set = [];
+	for (const name of new Set(names)) {
+		const value = yield* Config.String(name).pipe(Config.option);
+		if (Option.isNone(value)) continue;
+		set.push([name, name === "PATH" ? value.value.split(":").map((folder) => folder === "" || paths.isAbsolute(folder) ? folder : `${process.cwd()}/${folder}`).join(":") : value.value]);
+	}
+	return Object.fromEntries(set);
+});
+/** The first line a stopped server said, made printable. */
+const firstLine = (said) => printable(said.split("\n").map((line) => line.trim()).find((line) => line !== "") ?? "");
+/**
+* Starts the server named `name` in the plugin installed at `plugin`, as `harness` would for
+* `configFolder`, and answers how its start went.
+*/
+const startServer = Effect.fnUntraced(function* (harness, configFolder, plugin, name) {
+	const fs = yield* FileSystem.FileSystem;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const server = yield* fs.readFileString(`${plugin}/.mcp.json`).pipe(Effect.flatMap(decodeServers), Effect.map((file) => Option.fromNullishOr(file.mcpServers[name])), Effect.orElseSucceed(Option.none));
+	if (Option.isNone(server)) return { kind: "unnamed" };
+	const asked = server.value.env_vars ?? [];
+	const checked = {
+		REF0_API: (yield* Ref0Config).api,
+		[serverCheckVariable]: harness
+	};
+	const env = harness === "codex" ? {
+		...yield* fromHere([...codexPasses, ...asked]),
+		CODEX_HOME: configFolder,
+		...checked
+	} : {
+		...yield* fromHere([
+			...codexPasses,
+			...keychainVariables,
+			...asked
+		]),
+		CLAUDE_CONFIG_DIR: configFolder,
+		...checked
+	};
+	const withheld = Object.keys(yield* fromHere(keychainVariables)).some((variable) => env[variable] === void 0);
+	return yield* Effect.scoped(Effect.gen(function* () {
+		const handle = yield* spawner.spawn(ChildProcess.make(server.value.command, server.value.args, {
+			cwd: yield* emptyFolder(fs),
+			env,
+			extendEnv: harness === "claude-code",
+			forceKillAfter: "1 second",
+			stdin: {
+				stream: Stream.make(initialize).pipe(Stream.encodeText),
+				endOnDone: false
+			}
+		}));
+		const said = yield* handle.stderr.pipe(Stream.decodeText(), Stream.mkString, Effect.forkScoped);
+		const lines = yield* handle.stdout.pipe(Stream.decodeText(), Stream.splitLines, Stream.takeUntil((line) => Option.isSome(decodeAnswer(line))), Stream.runCollect);
+		if (lines.some((line) => Option.isSome(decodeAnswer(line)))) return { kind: "answered" };
+		if (withheld) return { kind: "withoutKeychain" };
+		return {
+			kind: "stopped",
+			said: firstLine(yield* Fiber.join(said)) || firstLine(lines.join("\n"))
+		};
+	})).pipe(Effect.catchTag("PlatformError", (error) => Effect.succeed({
+		kind: "stopped",
+		said: firstLine(error.message)
+	})), Effect.timeoutOption(serverLimit), Effect.map(Option.getOrElse(() => ({ kind: "unanswered" }))));
+});
+//#endregion
 //#region src/harness/status.ts
 /** Each connected or initialized folder has its own report; secrets are used only to ask ref0. */
 const encodeReports = Schema.encodeEffect(Schema.Array(StatusReport));
@@ -33943,6 +34677,16 @@ const speaksCheck = (protocols, version, reinstall) => {
 	if (Option.isSome(mismatch)) return checkOf("plugin", "no", mismatch.value.says, mismatch.value.run);
 	return checkOf("plugin", "yes", "installed and speaks this ref0");
 };
+/** A server's start, as its line says it, with this folder's reinstall for one that can't start. */
+const serverCheckOf = (started, configFolder) => {
+	switch (started.kind) {
+		case "answered": return checkOf("server", "yes", "starts");
+		case "stopped": return checkOf("server", "no", started.said === "" ? "can’t start, and said nothing" : `can’t start: ${started.said}`, installLine(configFolder));
+		case "withoutKeychain": return checkOf("server", "no", "can’t reach the keychain, since an older ref0 installed it", installLine(configFolder));
+		case "unnamed": return checkOf("server", "no", "the plugin names no ref0 server", installLine(configFolder));
+		case "unanswered": return checkOf("server", "unknown", `didn’t answer in ${Duration.toSeconds(serverLimit)} s`, "ref0 status");
+	}
+};
 const decodePlugins = Schema.decodeUnknownEffect(Schema.fromJsonString(ClaudePluginsListed));
 const decodeHooks = Schema.decodeUnknownEffect(Schema.fromJsonString(HooksFile));
 /** Ask Claude Code about this folder, even when another folder is current in the terminal. */
@@ -33976,7 +34720,7 @@ const claudeCodeChecks = Effect.fnUntraced(function* (configFolder) {
 	return [speaksCheck(Option.match(hooks, {
 		onNone: () => [],
 		onSome: protocolsOf
-	}), Option.fromUndefinedOr(plugin.version), reinstall)];
+	}), Option.fromUndefinedOr(plugin.version), reinstall), folder === void 0 ? checkOf("server", "unknown", "Claude Code didn’t say where ref0’s plugin is", reinstall) : serverCheckOf(yield* startServer("claude-code", configFolder, folder, name), configFolder)];
 });
 /** Trust only ref0's hooks; removal of an unexpected plugin targets this folder too. */
 const trustCheck = (hooks, configFolder, name) => {
@@ -33996,7 +34740,13 @@ const codexChecks = Effect.fnUntraced(function* (configFolder) {
 	const hooks = listed.value.data.flatMap((entry) => entry.hooks).filter((hook) => pluginHook(hook, `${name}@${name}`));
 	if (hooks.length === 0) return [checkOf("plugin", "no", "not installed or turned off in this folder", reinstall)];
 	const protocols = hooks.map((hook) => protocolFlagged(hook.command ?? "")).filter(Predicate.isString);
-	return [speaksCheck(protocols, Option.none(), reinstall), trustCheck(hooks, configFolder, name)];
+	const path = yield* Path.Path;
+	const source = hooks.find((hook) => Predicate.isString(hook.sourcePath))?.sourcePath;
+	return [
+		speaksCheck(protocols, Option.none(), reinstall),
+		trustCheck(hooks, configFolder, name),
+		Predicate.isString(source) ? serverCheckOf(yield* startServer("codex", configFolder, path.dirname(path.dirname(source)), name), configFolder) : checkOf("server", "unknown", "Codex didn’t say where ref0’s plugin is", reinstall)
+	];
 });
 /** A session belongs only to the current folder, even when several folders share its agent. */
 const sessionCheck = Effect.fnUntraced(function* (harness, configFolder) {
@@ -34025,8 +34775,7 @@ const statusCommands = [Command.make(harnessCommandNames.status, { json }, ({ js
 	}
 	for (const { configFolder, harness } of found) candidates.set(configFolder, harness);
 	const paths = [...candidates.keys()].sort((a, b) => a === current ? -1 : b === current ? 1 : 0);
-	const reports = [];
-	for (const configFolder of paths) {
+	const reportOf = Effect.fnUntraced(function* (configFolder) {
 		const kept = yield* Effect.result(grants.get(configFolder));
 		const unreadable = Result.isFailure(kept) && kept.failure.unreadable === true;
 		const grant = Result.isSuccess(kept) ? kept.success : Option.none();
@@ -34036,15 +34785,19 @@ const statusCommands = [Command.make(harnessCommandNames.status, { json }, ({ js
 				configFolder,
 				checks: [Result.isFailure(kept) && !unreadable ? checkOf("connected", "unknown", "The keychain didn’t say whether this config folder holds a host grant.", kept.failure.nextStep) : checkOf("connected", "no", unreadable ? "its host grant can’t be read" : "not connected", harness === void 0 ? "ref0 connect" : yield* connectLineFor(harness, configFolder))]
 			};
-			reports.push(harness === void 0 ? report : {
+			return harness === void 0 ? report : {
 				...report,
 				harness
-			});
-			continue;
+			};
 		}
-		const checks = [...yield* grantChecks(grant.value, configFolder), ...yield* grant.value.harness === "codex" ? codexChecks(configFolder) : claudeCodeChecks(configFolder)];
-		if (configFolder === current) checks.push(yield* sessionCheck(grant.value.harness, configFolder));
-		reports.push({
+		const [granted, installed] = yield* Effect.all([grantChecks(grant.value, configFolder), grant.value.harness === "codex" ? codexChecks(configFolder) : claudeCodeChecks(configFolder)], { concurrency: "unbounded" });
+		const checks = [...granted, ...installed];
+		if (configFolder === current) {
+			const session = yield* sessionCheck(grant.value.harness, configFolder);
+			const server = checks.find((check) => check.check === "server");
+			checks.push(server !== void 0 && server.answer !== "yes" && session.answer === "no" ? checkOf("session", "no", `none, since ref0’s server ${server.answer === "no" ? "can’t start" : "didn’t answer"}`, server.next) : session);
+		}
+		return {
 			harness: grant.value.harness,
 			configFolder,
 			agent: {
@@ -34052,8 +34805,9 @@ const statusCommands = [Command.make(harnessCommandNames.status, { json }, ({ js
 				agent: grant.value.agent
 			},
 			checks
-		});
-	}
+		};
+	});
+	const reports = yield* Effect.forEach(paths, reportOf, { concurrency: "unbounded" });
 	const home = yield* Config.String("HOME").pipe(Config.withDefault("."));
 	yield* printAnswer(yield* Effect.orDie(encodeReports(reports)), asJson, reports.length === 0 ? [["No initialized harness folders found.", { command: "ref0 connect" }]] : reports.map((report) => wordsOf(report, home)));
 	if (reports.some((report) => report.checks.some((check) => check.answer === "no"))) return yield* new Said();
@@ -34098,7 +34852,12 @@ const ref0 = Command.make("ref0").pipe(Command.withDescription("ref0 from the te
 ]));
 const keychain = Keychain.layer.pipe(Layer.provide([NodeServices.layer, Ref0Config.layer]));
 const harnessProcess = HarnessProcess.layer.pipe(Layer.provide(NodeServices.layer));
-const sessionToken = harnessSessionToken.pipe(Layer.provide([keychain, harnessProcess]));
+const sessionToken = harnessSessionToken.pipe(Layer.provide([
+	keychain,
+	harnessProcess,
+	HarnessServers.layer.pipe(Layer.provide(NodeServices.layer)),
+	HostGrant.layer.pipe(Layer.provide(keychain))
+]));
 /** Every service `ref0`'s commands use, on this machine. */
 const services = Layer.mergeAll(cliOutput, Ref0.layer.pipe(Layer.provide([
 	Ref0Config.layer,