@ref0/cli 0.9.0 → 0.10.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,
@@ -18464,7 +18464,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 +18669,7 @@ const StatusCheck = Schema.Struct({
 		"accepted",
 		"plugin",
 		"trusted",
+		"server",
 		"session"
 	]),
 	answer: StatusAnswer,
@@ -18823,6 +18824,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.
@@ -20454,6 +20461,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 +20580,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 +20607,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 +20652,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 +20661,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 +20735,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 +20847,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 +20982,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 +21002,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 +21030,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.10.0";
 //#endregion
 //#region src/harness/hook-protocol.ts
 /**
@@ -21332,12 +21354,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) {
@@ -22710,7 +22732,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 +22766,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 +23110,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 +23892,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 +23902,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)}`,
@@ -24158,7 +24188,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;
@@ -25026,7 +25056,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 +25197,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 +25394,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) } : {};
@@ -26143,6 +26173,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 +26266,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 +26439,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 +26472,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;
@@ -27690,35 +27756,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 +28216,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 +28819,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 +32580,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 +32621,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 +32658,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 +32666,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 +32728,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 +32748,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 +32844,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 +33158,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 +33172,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 +33186,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 +33262,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 +33399,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 +33457,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 +33579,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 +33621,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 +33836,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 +33887,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 +33940,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 +33995,203 @@ 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
+	};
+	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" };
+		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 +34247,15 @@ 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 "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 +34289,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 +34309,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 +34344,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 +34354,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 [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);
 		}
-		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({
+		return {
 			harness: grant.value.harness,
 			configFolder,
 			agent: {
@@ -34052,8 +34374,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 +34421,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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ref0/cli",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "ref0's command line, which connects an agent's machine to ref0",
   "license": "Apache-2.0",
   "repository": {
@@ -29,7 +29,7 @@
     "@effect/vitest": "4.0.0",
     "@ref0/contracts": "0.0.0",
     "@ref0/model": "0.0.0",
-    "@ref0/sdk": "0.9.0",
+    "@ref0/sdk": "0.10.0",
     "@types/node": "24.19.2",
     "smol-toml": "1.9.1",
     "typescript": "7.0.2",