@ref0/cli 0.7.0 → 0.8.0

package/dist/main.mjs

@@ -6510,8 +6510,17 @@ var PasskeyRefused = class extends Schema.TaggedError()("PasskeyRefused", { next
 //#endregion
 //#region ../contracts/src/attachments.ts
 /** A machine asks, a signed-in person claims and approves, and the answer returns to its terminal. */
+/**
+* What could reorder or hide the text around it, such as U+202E: a control, format, surrogate,
+* private-use or unassigned character, or a line or paragraph separator.
+*/
+const hiddenCharacters = String.raw`\p{C}\p{Zl}\p{Zp}`;
+/** Text with none of them, which reads as it's written wherever it's shown. */
+const shownAsWritten = Schema.isPattern(new RegExp(`^[^${hiddenCharacters}]+$`, "u"));
+/** Text with each character that could reorder or hide what's around it taken out. */
+const withoutHiddenCharacters = (text) => text.replaceAll(new RegExp(`[${hiddenCharacters}]`, "gu"), "");
 /** A machine's own word for itself: shown to the person as what it says, never as fact. */
-const MachineName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(64));
+const MachineName = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(64), shownAsWritten);
 /** The harness a machine says it connects for, never proof of what it runs. */
 const ConnectHarness = Schema.Literals(["claude-code", "codex"]);
 /** The machine's loopback listener; no caller may choose its host. */
@@ -6523,7 +6532,7 @@ const AttachmentCallback = Schema.Struct({
 	state: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{22}$/))
 });
 /** A config folder's path, as the machine shows it, never proof of its location. */
-const ConfigFolderPath = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(200), Schema.isPattern(/^[^\p{C}\p{Zl}\p{Zp}]+$/u));
+const ConfigFolderPath = Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(200), shownAsWritten);
 const uniqueFolderPaths = Schema.makeFilter((folders) => new Set(folders.map((folder) => folder.path)).size === folders.length, { expected: "unique config folder paths" });
 const RequestFolder = Schema.Struct({
 	path: ConfigFolderPath,
@@ -11766,10 +11775,12 @@ Schema.Union([
 	NotPermitted
 ]);
 /**
-* A session's fork's path on ref0's host. Its thread's, `/{owner}/{project}/threads/{n}/{repo}.git`
-* on a project's thread and `/{owner}/threads/{n}/{repo}.git` on an org thread, reaches the fork
-* of the session whose token asks, and takes its pushes. A session's,
-* `…/threads/{n}/sessions/{m}/{repo}.git`, reads that session's fork, and takes no push.
+* A fork's path on ref0's host. Its thread's, `/{owner}/{project}/threads/{n}/{repo}.git` on a
+* project's thread and `/{owner}/threads/{n}/{repo}.git` on an org thread, reaches the fork of the
+* session whose token asks, and takes its pushes. A session's,
+* `…/threads/{n}/sessions/{m}/{repo}.git`, reads that session's current fork, and a fork's,
+* `…/threads/{n}/forks/{fork}/{repo}.git`, reads that fork when it holds thread `n`'s work, a
+* session's on it or a run's whose pull request is on it. Neither takes a push.
 */
 const ForkPath = Schema.String.check(Schema.isPattern(/^\/[^\s]+\.git$/), Schema.isMaxLength(512)).pipe(Schema.brand("ForkPath"));
 /** A session's fork's URL on the app's one origin: the one a notice names, and a clone pushes to. */
@@ -11793,17 +11804,21 @@ const ForkView = Schema.Struct({
 	/** On the app's one origin, whichever host was asked. */
 	url: ForkUrl
 });
-Schema.Struct({
+/**
+* For a reader that sees only threads it holds a grant on, those threads: a fork of a thread
+* stacked, at any depth, on any other is refused, since it holds that thread's work. Unset for one
+* that reads the project as a whole.
+*/
+const readerSees = { only: Schema.optionalKey(Schema.Array(ThreadId)) };
+Schema.Union([Schema.Struct({
 	session: SessionId,
-	fork: Schema.optionalKey(ForkId),
-	/**
-	* For a reader that sees only threads it holds a grant on, those threads: a fork of a thread
-	* stacked, at any depth, on any other is refused, since it holds that thread's work. Unset for
-	* one that reads the project as a whole.
-	*/
-	only: Schema.optionalKey(Schema.Array(ThreadId))
-});
-/** A session's fork in Artifacts, as Git reaches it: where it is, and which Git repository. */
+	...readerSees
+}), Schema.Struct({
+	fork: ForkId,
+	thread: ThreadId,
+	...readerSees
+})]);
+/** A fork in Artifacts, as Git reaches it: where it is, and which Git repository. */
 const ForkPlace = Schema.Struct({
 	...CurrentBaseline.fields,
 	gitRepository: GitRepositoryId
@@ -11834,19 +11849,16 @@ const SessionBase = Schema.Struct({
 	commit: CommitOid,
 	/**
 	* Where to fetch it from, on ref0's origin: the repo's own path, as `ref0 clone` cloned it, for
-	* `main`; for a stack, the path of the fork that holds the pin.
+	* `main`; for a stack, the path of the fork that holds the pin, by its ID under the thread below.
 	*/
 	path: Schema.String.check(Schema.isPattern(/^\/[^\s]+\.git$/), Schema.isMaxLength(512)),
 	/** `path` on the app's one origin. A client checks it's a fork of its own repo there. */
 	url: Schema.String,
 	ref: Schema.Literal("refs/heads/main")
 });
-/**
-* No base to fetch: `main` has no commit yet, or the pin of the thread below is in a workflow
-* run's fork, which has no session's path to fetch from.
-*/
+/** No base to fetch: `main` has no commit yet. */
 var NoBase = class extends Schema.TaggedError()("NoBase", {
-	why: Schema.Literals(["main empty", "held by a run"]),
+	why: Schema.Literal("main empty"),
 	nextStep: Schema.String
 }, { httpApiStatus: 404 }) {};
 Schema.Struct({
@@ -11864,15 +11876,14 @@ const BaseOnMain = Schema.Struct({
 	commit: CommitOid
 });
 /**
-* The base on the thread below, `lower`: its pin's commit, the fork that holds it, and that
-* fork's session, or none for a workflow run's fork.
+* The base on the thread below, `lower`: its pin's commit, and the fork that holds it, a session's
+* on that thread or a run's whose pull request is on it.
 */
 const BaseOnStack = Schema.Struct({
 	on: Schema.Literal("stack"),
 	lower: ThreadId,
 	commit: CommitOid,
-	fork: ForkId,
-	session: Schema.NullOr(SessionId)
+	fork: ForkId
 });
 Schema.Union([
 	BaseOnMain,
@@ -14978,6 +14989,11 @@ var ApprovalSecret = class extends HttpApiMiddleware.Service()("ref0/contracts/A
 	security: { bearer: HttpApiSecurity.bearer },
 	error: [Unauthenticated]
 }) {};
+/**
+* A machine's request whose name its contract refuses, answered as `CommandRefused`, which says
+* 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 }) {};
 const idempotency = { "idempotency-key": RequestId };
 const inProject$1 = {
 	owner: OwnerRef,
@@ -15101,7 +15117,7 @@ var MachineAttachmentsGroup = class extends HttpApiGroup.make("machineAttachment
 		SlowDown,
 		AuthorityUnavailable
 	]
-}), HttpApiEndpoint.post("collect", "/v1/attachments/requests/:approval/result", {
+}).middleware(MachineNameRefusal), HttpApiEndpoint.post("collect", "/v1/attachments/requests/:approval/result", {
 	params: { approval: ApprovalId },
 	payload: Schema.Struct({ answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64))) }),
 	success: RequestState,
@@ -19074,6 +19090,14 @@ const renderBlocks = (blocks, stream) => {
 };
 /** Words go to stderr by default; a command's answer goes to stdout. */
 const printBlocks = (blocks, stream = "stderr") => Effect.sync(() => renderBlocks(blocks, stream)).pipe(Effect.flatMap((text) => stream === "stdout" ? Console.log(text) : Console.error(text)));
+/**
+* A yes-or-no question as the terminal shows it, bold, then `(y/N)`: no unless the person says
+* yes. The cursor stays after it, for their answer.
+*/
+const questionLine = (question) => `${renderBlocks([[{
+	label: question,
+	text: "(y/N)"
+}]], "stdout")} `;
 /** Keep explicit line breaks and wrap between words within the available columns. */
 const wrapWords = (text, width) => text.split("\n").flatMap((line) => {
 	const wrapped = [];
@@ -19142,6 +19166,23 @@ const accountCommands = [Command.make("whoami", { json }, ({ json: asJson }) =>
 	yield* printAnswer(answer.json, asJson, me.agent === void 0 ? `You, as ${me.actor.id}.` : `Agent ${me.agent.id}, in session ${me.session?.session ?? "none"}.`);
 }).pipe(Effect.catchTag("CallFailed", (failed) => sayFailed(failed.nextStep)))).pipe(Command.withDescription("Who’s acting, and what they hold"), Command.withShortDescription("Show who’s acting and what they hold"))];
 //#endregion
+//#region ../model/src/agent-commits.ts
+/**
+* How an agent's commits name it as their author: `pip/claude <agent_…@ref0.work>`. The person
+* stays the committer, with their own signature. Git keeps every commit for good, and anyone
+* who reads the repo reads its author, so these name the agent and nothing about its sessions.
+*/
+/**
+* An agent's commit email: built from its agent ID alone, so it never changes, and never passes
+* to another agent. Nobody reads mail there.
+*/
+const agentCommitEmail = (agent) => `${agent}@ref0.work`;
+/**
+* An agent's name as its commits' author: its owner, then its handle, as commands write it. A
+* handle renamed later stays as it was in the commits made before.
+*/
+const agentCommitName = (owner, handle) => `${owner}/${handle}`;
+//#endregion
 //#region ../model/src/cut-text.ts
 /**
 * `text` within `max` as a `Schema`'s length counts it, in UTF-16 code units: whole code points
@@ -19422,13 +19463,13 @@ function freeTextProblem(text, maxCharacters) {
 //#endregion
 //#region ../model/src/git-paths.ts
 /**
-* A session's fork's path: an owner, a project for a project's thread and none for an org
-* thread's, a thread, a session when it names one and the source fork when that names one too, a
-* repo, and what Git asks for. The two thread forms never read alike: after `threads` comes a
-* number on an org thread's, and the word `threads` on a project's, so a project named `threads`
-* keeps its forks. Nor do the two fork forms: a repo's name holds no `/`.
+* A fork's path: an owner, a project for a project's thread and none for an org thread's, a
+* thread, then a session or a fork by its ID when it names one, a repo, and what Git asks for.
+* The two thread forms never read alike: after `threads` comes a number on an org thread's, and
+* the word `threads` on a project's, so a project named `threads` keeps its forks. Nor do the three
+* fork forms: a repo's name holds no `/`.
 */
-const forkPath = /^\/([^/]+)(?:\/([^/]+))?\/threads\/([1-9]\d{0,9})(?:\/sessions\/([1-9]\d{0,9})(?:\/forks\/(fork_[a-z0-9]+))?)?\/([^/]+)\.git\/(info\/refs|git-upload-pack|git-receive-pack)$/;
+const forkPath = /^\/([^/]+)(?:\/([^/]+))?\/threads\/([1-9]\d{0,9})(?:\/sessions\/([1-9]\d{0,9})|\/forks\/(fork_[a-z0-9]+))?\/([^/]+)\.git\/(info\/refs|git-upload-pack|git-receive-pack)$/;
 //#endregion
 //#region ../model/src/thread-workflows.ts
 const minuteMillis = 6e4;
@@ -20340,6 +20381,15 @@ const watchVariables = {
 	event: "REF0_EVENT",
 	title: "REF0_TITLE"
 };
+/**
+* What ref0 puts in the environment of an agent's commands for its commits, beside Git's own
+* author variables: the harness, for the trailer, and what a forwarder in ref0's hooks folder
+* sets for the repo's own hook it runs, so a forwarder that hook reaches runs nothing.
+*/
+const gitHookVariables = {
+	harness: "REF0_HARNESS",
+	forwarded: "REF0_GIT_HOOK"
+};
 //#endregion
 //#region src/harness/plugin-files.ts
 /**
@@ -20814,11 +20864,16 @@ const connectLineFor = Effect.fnUntraced(function* (harness, configFolder) {
 });
 //#endregion
 //#region src/host-grant.ts
-/** All lasting authority for one config folder, stored as one keychain value. */
+/**
+* All lasting authority for one config folder, stored as one keychain value: the agent the folder
+* acts as, by its owner, handle and agent ID, and its token. The ID is kept in the same write as
+* the token, so a folder with a grant always knows which agent its commits name.
+*/
 const KeptHostGrant = Schema.Struct({
 	harness: ConnectHarness,
 	owner: OwnerName,
 	agent: AgentHandle,
+	agentId: AgentId,
 	token: Schema.RedactedFromValue(Schema.String)
 });
 const decodeGrant = Schema.decodeUnknownOption(Schema.fromJsonString(KeptHostGrant));
@@ -20865,7 +20920,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.7.0";
+const cliVersion = "0.8.0";
 //#endregion
 //#region src/harness/hook-protocol.ts
 /**
@@ -20909,8 +20964,9 @@ const updateLine = (plugin, reinstall) => Option.map(protocolMismatch(plugin, re
 //#region src/machine.ts
 /**
 * This machine, as ref0 knows it: an ID made once and kept in ref0's config, `machine` under
-* `$XDG_CONFIG_HOME/ref0` or `~/.config/ref0`, and its own name for itself, which ref0 shows
-* the person as what it says. Neither is a secret, and neither is proof of anything.
+* `$XDG_CONFIG_HOME/ref0` or `~/.config/ref0`, and its host name, from which `ref0 connect` makes
+* the name ref0 shows the person as what it says. Neither is a secret, and neither is proof of
+* anything.
 */
 var MachineError = class extends Schema.TaggedError()("MachineError", { nextStep: Schema.String }) {};
 const decodeMachineId = Schema.decodeUnknownOption(MachineId);
@@ -20938,10 +20994,10 @@ var Machine = class Machine extends Context.Service()("ref0/cli/Machine") {
 				onSome: Effect.succeed
 			}));
 		});
-		const name = (yield* Effect.sync(() => hostname())).slice(0, 64) || "this machine";
+		const hostName = yield* Effect.sync(() => hostname());
 		return Machine.of({
 			id,
-			name
+			hostName
 		});
 	}));
 };
@@ -21052,18 +21108,31 @@ const keepBudget = Duration.minutes(5);
 /** A request that couldn't finish: no answer in time, no connection, or ref0 briefly unable. */
 var Unanswered = class extends Schema.TaggedError()("Unanswered", {}) {};
 const unanswered = () => Effect.fail(new Unanswered());
+/**
+* The name the machine sends for itself: its host name without any character that could reorder
+* or hide what's around it, cut to 64 characters without splitting one in two, or `this machine`
+* when that leaves none.
+*/
+const machineNameOf = (hostName) => {
+	let name = "";
+	for (const character of withoutHiddenCharacters(hostName).trim()) {
+		if (name.length + character.length > 64) break;
+		name += character;
+	}
+	return name || "this machine";
+};
 /** A refusal ref0 gave, said as it gave it. */
 const said = (refusal) => sayFailed(refusal.nextStep);
 const isEnded = (state) => state.state !== "waiting";
 /** The line that asks again. */
-const again$1 = "ref0 connect";
+const again$2 = "ref0 connect";
 /** What each way a request can end without connecting says, with the line that asks again. */
 const endedWords$1 = (state) => {
 	switch (state.state) {
-		case "refused": return `It was refused, and nothing was connected. To ask again, run: ${again$1}`;
-		case "aborted": return `It was aborted, and nothing was connected. To ask again, run: ${again$1}`;
-		case "expired": return `Nobody approved it in time, and nothing was connected. For a new code, run: ${again$1}`;
-		case "failed": return `${state.nextStep} To connect this machine, run: ${again$1}`;
+		case "refused": return `It was refused, and nothing was connected. To ask again, run: ${again$2}`;
+		case "aborted": return `It was aborted, and nothing was connected. To ask again, run: ${again$2}`;
+		case "expired": return `Nobody approved it in time, and nothing was connected. For a new code, run: ${again$2}`;
+		case "failed": return `${state.nextStep} To connect this machine, run: ${again$2}`;
 	}
 };
 /** The grant a kept record holds, by its ID. */
@@ -21111,7 +21180,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 	}));
 	const payload = {
 		machine: machineId,
-		machineName: machine.name,
+		machineName: machineNameOf(machine.hostName),
 		folders,
 		collectHash: yield* Effect.orDie(decodeSecretHash$1(collecting.hash)),
 		linkHash: yield* Effect.orDie(decodeSecretHash$1(link.hash))
@@ -21162,7 +21231,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 		while (true) {
 			const state = yield* collect;
 			if (Option.isSome(state) && isEnded(state.value)) return state.value;
-			if ((yield* Clock.currentTimeMillis) > giveUpAt) return yield* sayFailed(`ref0 hasn’t said how it ended, so this machine kept nothing. If it was approved, ref0 revokes its grants 10 minutes after it connected. To connect this machine, run: ${again$1}`);
+			if ((yield* Clock.currentTimeMillis) > giveUpAt) return yield* sayFailed(`ref0 hasn’t said how it ended, so this machine kept nothing. If it was approved, ref0 revokes its grants 10 minutes after it connected. To connect this machine, run: ${again$2}`);
 			yield* Effect.sleep(pollMillis);
 		}
 	});
@@ -21174,6 +21243,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 			harness: folder.harness,
 			owner: connection.owner,
 			agent: connection.handle,
+			agentId: connection.agent.id,
 			token: Redacted.make(token)
 		}).pipe(Effect.timeoutOrElse({
 			duration: Duration.min(keepTimeout, Duration.millis(left)),
@@ -21225,12 +21295,12 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 			"It connected, but this machine couldn’t keep what it needs to act:",
 			...notKept.map((each) => `${shownConfigFolder(home, each.configFolder)}: ${each.nextStep}`),
 			"This machine never confirmed the grants, so ref0 revokes them 10 minutes after they connected, even if the keychain kept them after all. To connect this machine, run:",
-			{ command: again$1 }
+			{ command: again$2 }
 		]]);
-		const unconfirmed = () => sayFailed(`It connected, and this machine kept its grants, but ref0 didn’t answer when it said so. If ref0 never heard, it revokes them 10 minutes after they connected: then run ${again$1}`);
+		const unconfirmed = () => sayFailed(`It connected, and this machine kept its grants, but ref0 didn’t answer when it said so. If ref0 never heard, it revokes them 10 minutes after they connected: then run ${again$2}`);
 		const confirmId = yield* newRequestId;
 		const answerCode = yield* Ref.get(pasted);
-		if (answerCode === void 0) return yield* sayFailed(`The answer code is missing. Run ${again$1} again.`);
+		if (answerCode === void 0) return yield* sayFailed(`The answer code is missing. Run ${again$2} again.`);
 		if (!(yield* collector.machineAttachments.confirm({
 			params,
 			headers: { "idempotency-key": confirmId },
@@ -21253,7 +21323,7 @@ const requestAttachment = Effect.fnUntraced(function* (asked) {
 			schedule: Schedule.spaced("1 second")
 		}), Effect.catchTag("Unanswered", unconfirmed))).confirmed) {
 			for (const folder of kept) yield* hostGrant.remove(folder.configFolder).pipe(Effect.ignore);
-			return yield* sayFailed(`ref0 revoked the grants, since this machine didn’t confirm in time that it kept them. They’re deleted here, and nothing is connected. To connect this machine, run: ${again$1}`);
+			return yield* sayFailed(`ref0 revoked the grants, since this machine didn’t confirm in time that it kept them. They’re deleted here, and nothing is connected. To connect this machine, run: ${again$2}`);
 		}
 		return {
 			owner: state.owner,
@@ -21442,6 +21512,89 @@ var ConnectLock = class ConnectLock extends Context.Service()("ref0/cli/ConnectL
 	}));
 };
 //#endregion
+//#region src/yes-or-no.ts
+/**
+* How long what a terminal held while nobody read it takes to arrive once a question reads: one
+* read, well within this.
+*/
+const settle = Duration.millis(50);
+const again$1 = "Type y or yes, or n or no. Enter alone is no.";
+/** A line's answer, or none when it's neither yes nor no. */
+const answerOf$1 = (line) => {
+	const word = line.trim().toLowerCase();
+	if (word === "y" || word === "yes") return Option.some(true);
+	if (word === "" || word === "n" || word === "no") return Option.some(false);
+	return Option.none();
+};
+/** What Backspace takes back: one character as the person sees it, an emoji's parts included. */
+const characters = new Intl.Segmenter();
+/** Whether a key types text: none of its characters moves the cursor or controls the terminal. */
+const typesText = (text) => text !== "" && !/\p{Cc}/u.test(text);
+const quits = (key) => key.ctrl && (key.name === "c" || key.name === "d");
+/** The explanation goes to stderr, the question to stdout and its answer comes from stdin. */
+const allTerminals = () => process.stdin.isTTY === true && process.stdout.isTTY === true && process.stderr.isTTY === true;
+/**
+* Asks yes-or-no questions in this terminal, one after another: each shows `explained` on stderr,
+* then the question, and waits for a line. What was typed before a question showed doesn't answer
+* it, unless another question was asked when it arrived: a line typed after the one that answered
+* a question answers the next. The answer is no, unasked, unless stdin, stdout and stderr are each
+* a terminal, and on Ctrl-C or Ctrl-D.
+*/
+const yesOrNoQuestions = Effect.gen(function* () {
+	const terminal = yield* Terminal.Terminal;
+	const ahead = yield* Ref.make([]);
+	const ask = (explained, question) => Effect.gen(function* () {
+		if (!allTerminals()) return false;
+		const keys = yield* terminal.readInput;
+		yield* Effect.sleep(settle);
+		yield* Queue.clear(keys);
+		const pending = [...yield* Ref.getAndSet(ahead, [])];
+		const next = Effect.suspend(() => {
+			const key = pending.shift();
+			return key === void 0 ? Queue.take(keys) : Effect.succeed(key);
+		});
+		yield* printBlocks([explained]);
+		yield* terminal.display(questionLine(question));
+		let typed = "";
+		let previous = "";
+		while (true) {
+			const pressed = yield* Effect.option(next);
+			if (Option.isNone(pressed) || quits(pressed.value.key)) {
+				yield* terminal.display("\n");
+				return false;
+			}
+			const { input, key } = pressed.value;
+			const ended = key.name === "enter" && previous === "return";
+			previous = key.name;
+			if (ended) continue;
+			if (key.name === "backspace") {
+				if (typed === "") continue;
+				typed = typed.slice(0, [...characters.segment(typed)].at(-1)?.index);
+				yield* terminal.display("\b \b");
+				continue;
+			}
+			if (key.name !== "return" && key.name !== "enter") {
+				const text = Option.getOrElse(input, () => "");
+				if (!typesText(text)) continue;
+				typed += text;
+				yield* terminal.display(text);
+				continue;
+			}
+			yield* terminal.display("\n");
+			const answer = answerOf$1(typed);
+			if (Option.isSome(answer)) {
+				const rest = [...pending, ...yield* Queue.clear(keys)];
+				const ended = key.name === "return" && rest[0]?.key.name === "enter";
+				yield* Ref.set(ahead, ended ? rest.slice(1) : rest);
+				return answer.value;
+			}
+			typed = "";
+			yield* terminal.display(`${again$1}\n${questionLine(question)}`);
+		}
+	}).pipe(Effect.scoped, Effect.orElseSucceed(() => false));
+	return ask;
+});
+//#endregion
 //#region src/harness/install-claude-code.ts
 /** Install into one config folder, from the release Claude Code fetched and ref0 checked. */
 const installClaudeCode = Effect.fnUntraced(function* (release, configFolder) {
@@ -22020,41 +22173,24 @@ const onPath = Effect.fnUntraced(function* (name) {
 const runs$2 = (hook) => hook.handlerType === "command" ? printable(hook.command ?? "") : `the ${printable(hook.tool ?? "")} tool on MCP server ${printable(hook.server ?? "")}`;
 /**
 * Shows the person ref0's hooks for Codex, on stderr so a JSON answer stays alone on stdout,
-* and asks whether Codex may run them. Only in a terminal, and never for `--json`: anywhere
-* else the answer is no, and the hooks stay off until the person runs it again or trusts them in
-* Codex itself.
-*/
-const askToTrust = (hooks, shown, asked) => Effect.gen(function* () {
-	const terminal = process.stdin.isTTY === true && process.stdout.isTTY === true && process.stderr.isTTY === true;
-	if (!asked || !terminal) return false;
-	yield* Console.error([`Codex runs a plugin's hooks only once you trust them. ref0's, for ${printable(shown)}, are:`, ...hooks.map((hook) => `- ${hook.eventName}: ${runs$2(hook)}`)].join("\n"));
-	return yield* Prompt.run(Prompt.Confirm({
-		message: "Trust them, so Codex runs them?",
-		initial: false
-	}));
-}).pipe(Effect.orElseSucceed(() => false));
+* and asks whether Codex may run them. On a no, or with no terminal to ask in, the hooks stay
+* off until the person runs it again or trusts them in Codex itself.
+*/
+const askToTrust = (hooks, shown, yesOrNo) => yesOrNo([`Codex runs a plugin's hooks only once you trust them. ref0's, for ${printable(shown)}, are:`, ...hooks.map((hook) => `- ${hook.eventName}: ${runs$2(hook)}`)], "Trust them, so Codex runs them?");
 /**
 * Shows the person ref0's sandbox profile for Codex, on stderr, and asks whether it may be
-* Codex's default: only in a terminal, and never for `--json`, as with the hooks. A change to
-* their Codex's security, so it's shown in full and asked the first time (decided 9 Oct, 5).
-*/
-const askForProfile = (replacing, shown, asked) => Effect.gen(function* () {
-	const terminal = process.stdin.isTTY === true && process.stdout.isTTY === true && process.stderr.isTTY === true;
-	if (!asked || !terminal) return false;
-	yield* Console.error([
-		"Codex's sandbox keeps commands from writing .git or reaching the network, so a Codex agent can't commit or push to ref0.",
-		"ref0's profile, \"ref0\", is Codex's workspace profile with two changes:",
-		"- each workspace root's .git is writable, so an agent can commit",
-		"- the network is on, so an agent can push; any command can then reach the internet, services and sockets on this machine, and your login Keychain",
-		"In a linked worktree (git worktree add), Codex still needs full access there.",
-		...replacing.default === void 0 ? [] : [`It replaces your default now, ${printable(replacing.default)}.`],
-		...replacing.ownRef0 ? ["It replaces the profile you have named \"ref0\", and every rule in it."] : []
-	].join("\n"));
-	return yield* Prompt.run(Prompt.Confirm({
-		message: `Make "ref0" the default profile for ${printable(shown)}?`,
-		initial: false
-	}));
-}).pipe(Effect.orElseSucceed(() => false));
+* Codex's default. A change to their Codex's security, so it's shown in full and asked the first
+* time (decided 9 Oct, 5).
+*/
+const askForProfile = (replacing, shown, yesOrNo) => yesOrNo([
+	"Codex's sandbox keeps commands from writing .git or reaching the network, so a Codex agent can't commit or push to ref0.",
+	"ref0's profile, \"ref0\", is Codex's workspace profile with two changes:",
+	"- each workspace root's .git is writable, so an agent can commit",
+	"- the network is on, so an agent can push; any command can then reach the internet, services and sockets on this machine, and your login Keychain",
+	"In a linked worktree (git worktree add), Codex still needs full access there.",
+	...replacing.default === void 0 ? [] : [`It replaces your default now, ${printable(replacing.default)}.`],
+	...replacing.ownRef0 ? ["It replaces the profile you have named \"ref0\", and every rule in it."] : []
+], `Make "ref0" the default profile for ${printable(shown)}?`);
 /** What a Codex folder without ref0's profile, or full access, can't do. */
 const sandboxWords = "Codex’s sandbox is as it was, so its agents commit and push to ref0 only where it has full access; to change that, run it again in a terminal.";
 /**
@@ -22105,7 +22241,7 @@ const writeRef0Launcher = Effect.fnUntraced(function* (home, git) {
 const installInto = Effect.fnUntraced(function* (folders, options) {
 	const home = yield* Config.String("HOME");
 	const name = yield* originPluginName((yield* Ref0Config).api);
-	const terminal = yield* Effect.context();
+	const yesOrNo = options.asJson ? () => Effect.succeed(false) : yield* yesOrNoQuestions;
 	const answers = /* @__PURE__ */ new Map();
 	const failAll = (into, failed) => {
 		for (const folder of into) answers.set(folder, Result.fail(failed));
@@ -22136,8 +22272,7 @@ const installInto = Effect.fnUntraced(function* (folders, options) {
 					home,
 					configFolder: folder.configFolder,
 					name,
-					asked: !options.asJson,
-					terminal
+					yesOrNo
 				})).pipe(Effect.result);
 				answers.set(folder, installed);
 			}
@@ -22163,8 +22298,8 @@ const installedInCodex = Effect.fnUntraced(function* (release, options) {
 		codex: options.codex,
 		home: options.home,
 		configFolder: options.configFolder,
-		approve: (hooks) => askToTrust(hooks, shown, options.asked).pipe(Effect.provide(options.terminal)),
-		approveProfile: (replacing) => askForProfile(replacing, shown, options.asked).pipe(Effect.provide(options.terminal))
+		approve: (hooks) => askToTrust(hooks, shown, options.yesOrNo),
+		approveProfile: (replacing) => askForProfile(replacing, shown, options.yesOrNo)
 	});
 	const sandbox = done.profile ? "" : ` ${sandboxWords}`;
 	const trust = trustRef0Hooks(installLine(options.configFolder), `${options.name}@${options.name}`);
@@ -31731,7 +31866,7 @@ const codexSetupHere = Effect.fnUntraced(function* (process) {
 const mcp = Command.make(harnessCommandNames.mcp, {}, () => Effect.gen(function* () {
 	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)) : Option.none();
+	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 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";
 	return yield* Layer.launch(mcpServer(cliVersion, {
@@ -31827,6 +31962,245 @@ const endHarnessSession = Effect.gen(function* () {
 }).pipe(Effect.ignore);
 const sessionEnd = Command.make(harnessCommandNames.sessionEnd, { protocol: protocolFlag }, (flags) => flags.protocol === "1" ? endHarnessSession : Effect.void).pipe(Command.withDescription("Ends the ref0 session of a harness session that's closing"), Command.withShortDescription("End the harness’s ref0 session"));
 //#endregion
+//#region src/harness/git-hooks.ts
+/**
+* ref0's Git hooks: folders of forwarders in `~/.ref0/origins/<origin>/git-hooks`, which ref0 names as
+* `core.hooksPath` in its agents' commands alone, never in a repo, its config or its hooks.
+* `core.hooksPath` replaces a repo's whole hooks folder, so each forwarder runs the repo's own
+* hook of its name, with the same arguments, stdin and exit status, wherever the repo keeps it:
+* husky's `.husky/_`, `.git/hooks/` or another `core.hooksPath`. It finds and runs that hook
+* with ref0's entry left out of its environment, so a hook that looks up another, as
+* `pre-applypatch.sample` runs `pre-commit`, finds the repo's own. A forwarder runs nothing
+* when the repo's hooks path is one of ref0's folders, or when a forwarder started it, so none
+* calls itself: a first version that left ref0's entry in started about 1,000 processes.
+*
+* Git runs a hook that exists even where the repo has none, so the forwarders cost each hook one
+* `sh` and one `git rev-parse`, about 1.5 ms. Two hooks run on every index write and ref update,
+* hundreds of times in a long rebase, so only `all` forwards them, for a checkout that has its
+* own; `most` forwards every other (measured 23 Oct 2026, in the piece's pull request).
+*
+* The folders are the CLI's: a session's start writes them again when a forwarder differs, as
+* after an update. Each is read-only, so a tool that installs hooks wherever `core.hooksPath`
+* points, run in an agent's command, fails there rather than replacing a forwarder for every
+* repo.
+*/
+/** The hooks Git runs on every index write and ref update. */
+const frequentHooks = ["post-index-change", "reference-transaction"];
+/**
+* Every other hook Git looks for in its hooks path. Not `push-to-checkout`, which replaces Git's
+* own update of a checkout pushed to merely by existing, nor `fsmonitor-watchman`, which Git runs
+* from `core.fsmonitor`, never from the hooks path.
+*/
+const forwardedHooks = [
+	"applypatch-msg",
+	"pre-applypatch",
+	"post-applypatch",
+	"pre-commit",
+	"pre-merge-commit",
+	"prepare-commit-msg",
+	"commit-msg",
+	"post-commit",
+	"pre-rebase",
+	"post-checkout",
+	"post-merge",
+	"pre-push",
+	"pre-receive",
+	"update",
+	"proc-receive",
+	"post-receive",
+	"post-update",
+	"pre-auto-gc",
+	"post-rewrite",
+	"sendemail-validate",
+	"p4-changelist",
+	"p4-prepare-changelist",
+	"p4-post-changelist",
+	"p4-pre-submit"
+];
+/**
+* The forwarder for one hook. `hooks` is the folder holding ref0's folders: an entry naming one
+* of them is ref0's, and is left out. The rest keep their order, renumbered.
+*/
+const forwarder = (name, hooks) => [
+	"#!/bin/sh",
+	`# ref0 ${cliVersion}'s forwarder for Git's ${name} hook. ref0 sets core.hooksPath to this`,
+	"# folder only in its agents' commands. This runs the repo's own hook, found and run with",
+	"# ref0's entry left out, with the same arguments, stdin and exit status.",
+	`[ -n "\${${gitHookVariables.forwarded}-}" ] && exit 0`,
+	`ref0_hooks=${shellWord(hooks)}`,
+	"ref0_n=${GIT_CONFIG_COUNT:-0}",
+	"ref0_i=0",
+	"ref0_j=0",
+	"while [ \"$ref0_i\" -lt \"$ref0_n\" ]; do",
+	"  eval \"ref0_key=\\${GIT_CONFIG_KEY_$ref0_i-} ref0_value=\\${GIT_CONFIG_VALUE_$ref0_i-}\"",
+	"  unset \"GIT_CONFIG_KEY_$ref0_i\" \"GIT_CONFIG_VALUE_$ref0_i\"",
+	"  if [ \"$ref0_key\" != core.hooksPath ] || [ \"${ref0_value%/*}\" != \"$ref0_hooks\" ]; then",
+	"    export \"GIT_CONFIG_KEY_$ref0_j=$ref0_key\" \"GIT_CONFIG_VALUE_$ref0_j=$ref0_value\"",
+	"    ref0_j=$((ref0_j + 1))",
+	"  fi",
+	"  ref0_i=$((ref0_i + 1))",
+	"done",
+	"if [ \"$ref0_j\" -eq 0 ]; then unset GIT_CONFIG_COUNT; else export GIT_CONFIG_COUNT=\"$ref0_j\"; fi",
+	`ref0_hook=$(git rev-parse --git-path hooks/${name}) || exit`,
+	"[ -f \"$ref0_hook\" ] && [ -x \"$ref0_hook\" ] || exit 0",
+	"ref0_dir=$(cd -P \"${ref0_hook%/*}\" && pwd) || exit",
+	"[ \"${ref0_dir%/*}\" = \"$ref0_hooks\" ] && exit 0",
+	`export ${gitHookVariables.forwarded}=${name}`,
+	"exec \"$ref0_hook\" \"$@\"",
+	""
+].join("\n");
+/** The hooks each folder forwards. */
+const hooksIn = (folder) => folder === "all" ? [...forwardedHooks, ...frequentHooks] : forwardedHooks;
+/** The folder holding ref0's hooks folders, made if it isn't yet: its path, through any links. */
+const gitHooksHome = Effect.fnUntraced(function* (home, api) {
+	const fs = yield* FileSystem.FileSystem;
+	const given = (yield* Path.Path).join(home, ".ref0", "origins", originKey(api), "git-hooks");
+	yield* fs.makeDirectory(given, {
+		recursive: true,
+		mode: 448
+	});
+	return yield* fs.realPath(given);
+});
+/**
+* One of ref0's hooks folders, in `hooks`, written first unless every forwarder in it is already
+* as this CLI writes it: its path, as the agent's `core.hooksPath` names it.
+*/
+const hooksFolder = Effect.fnUntraced(function* (hooks, folder) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const crypto = yield* Crypto.Crypto;
+	const written = path.join(hooks, folder);
+	const names = hooksIn(folder);
+	const current = Effect.forEach(names, (name) => fs.readFileString(path.join(written, name)).pipe(Effect.map((text) => text === forwarder(name, hooks)), Effect.orElseSucceed(() => false))).pipe(Effect.map((each) => each.every(Boolean)));
+	if (yield* current) return written;
+	yield* Effect.gen(function* () {
+		yield* fs.makeDirectory(written, { recursive: true });
+		yield* fs.chmod(written, 493);
+		for (const name of names) {
+			const next = path.join(written, `${name}.${yield* crypto.randomUUIDv4}.next`);
+			yield* fs.writeFileString(next, forwarder(name, hooks), { mode: 365 });
+			yield* fs.rename(next, path.join(written, name));
+		}
+		yield* fs.chmod(written, 365);
+	}).pipe(Effect.catch((error) => Effect.flatMap(current, (done) => done ? Effect.void : Effect.fail(error))));
+	return written;
+});
+//#endregion
+//#region src/harness/commit-environment.ts
+/**
+* The agent as the author of its commits, set at a Claude Code session's start in the
+* environment of the agent's own commands, and nowhere else: the file `CLAUDE_ENV_FILE` names,
+* which Claude Code runs ahead of each of them. It sets Git's author to the agent, by its owner
+* and handle and its commit email; one `GIT_CONFIG_*` entry naming ref0's hooks folder as
+* `core.hooksPath`, after any the command already has; and the harness, for the trailer. Git
+* takes the committer from the person's own config, with their signature, and a commit the
+* person makes in their own terminal has none of it.
+*
+* The agent is the one the session's config folder acts as, from that folder's host grant, which
+* `ref0 connect` keeps with the agent's ID. It sets no author when the grant can't be read, or
+* when the session's checkout signs off its commits: any of the last 20 on its default branch
+* has a `Signed-off-by`, or it has `.github/dco.yml`. A DCO check wants each sign-off to match
+* its commit's author, and an agent never signs off. The hooks path is still set.
+*/
+/** How many commits on the default branch a session's start reads for a sign-off. */
+const signedOffWithin = 20;
+/**
+* What a session's start adds to the file Claude Code runs ahead of the agent's commands. The
+* hooks path goes after the entries a command already has, once however often the file runs.
+* Without an author, it drops one an outer agent's session set.
+*/
+const environmentScript = (set) => [
+	"",
+	"# ref0: the agent as the author of its commits, and ref0's Git hooks, in its commands",
+	...Option.match(set.author, {
+		onNone: () => ["case ${GIT_AUTHOR_EMAIL-} in *@ref0.work) unset GIT_AUTHOR_NAME GIT_AUTHOR_EMAIL ;; esac"],
+		onSome: (author) => [`export GIT_AUTHOR_NAME=${shellWord(author.name)}`, `export GIT_AUTHOR_EMAIL=${shellWord(author.email)}`]
+	}),
+	`export ${gitHookVariables.harness}=${set.harness}`,
+	"if [ -z \"${ref0_hooks_set-}\" ]; then",
+	"  ref0_n=${GIT_CONFIG_COUNT:-0}",
+	`  export "GIT_CONFIG_KEY_$ref0_n=core.hooksPath" "GIT_CONFIG_VALUE_$ref0_n="${shellWord(set.folder)} "GIT_CONFIG_COUNT=$((ref0_n + 1))"`,
+	"  ref0_hooks_set=1",
+	"  unset ref0_n",
+	"fi",
+	""
+].join("\n");
+/**
+* What the agent reads at its session's start once its commands name ref0's hooks folder: an
+* installer run there fails on that read-only folder, and without ref0's entry it installs into
+* the repo's own.
+*/
+const hookInstallerWords = `ref0: Git in your commands runs hooks through ref0's read-only folder, so run a hook installer, such as git lfs install, pre-commit install, lefthook install or simple-git-hooks, as env -u GIT_CONFIG_COUNT <command>, to install into the repo's own hooks folder.`;
+/**
+* What the session's checkout says: which of ref0's hooks folders it needs, `all` when it has
+* its own frequent hook, and whether it signs off its commits. Outside a checkout, neither.
+*/
+const checkoutAt = Effect.fnUntraced(function* (cwd) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const git = (folder, args) => spawner.string(ChildProcess.make("git", [
+		"-C",
+		folder,
+		...args
+	])).pipe(Effect.catchCause(() => Effect.succeed("")));
+	const executable = (file) => fs.stat(file).pipe(Effect.map((info) => info.type === "File" && (info.mode & 73) !== 0), Effect.orElseSucceed(() => false));
+	const top = (yield* git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+	const outside = {
+		folder: "most",
+		signsOff: false
+	};
+	if (top === "") return outside;
+	const hooks = (yield* git(top, ["rev-parse", ...frequentHooks.flatMap((name) => ["--git-path", `hooks/${name}`])])).split("\n").filter(Boolean);
+	const folder = (yield* Effect.forEach(hooks, (hook) => executable(path.resolve(top, hook)))).some(Boolean) ? "all" : "most";
+	if (yield* fs.exists(path.join(top, ".github", "dco.yml")).pipe(Effect.orElseSucceed(() => false))) return {
+		folder,
+		signsOff: true
+	};
+	const defaultBranch = (yield* git(top, [
+		"symbolic-ref",
+		"-q",
+		"refs/remotes/origin/HEAD"
+	])).trim();
+	return {
+		folder,
+		signsOff: (yield* git(top, [
+			"log",
+			"--no-show-signature",
+			"-n",
+			`${signedOffWithin}`,
+			"--format=%(trailers:key=Signed-off-by,valueonly)",
+			defaultBranch === "" ? "HEAD" : defaultBranch,
+			"--"
+		])).trim() !== ""
+	};
+});
+/**
+* Adds the agent's commit environment to the file Claude Code names, for the session opening in
+* `cwd`: 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.
+*/
+const setCommitEnvironment = Effect.fnUntraced(function* (cwd) {
+	const fs = yield* FileSystem.FileSystem;
+	const folders = yield* ConfigFolders;
+	const file = yield* Config.String("CLAUDE_ENV_FILE").pipe(Config.withDefault(""));
+	if (file === "") return false;
+	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;
+	const checkout = yield* checkoutAt(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) => ({
+		name: agentCommitName(grant.owner, grant.agent),
+		email: agentCommitEmail(grant.agentId)
+	}));
+	yield* fs.writeFileString(file, environmentScript({
+		author,
+		folder,
+		harness: "claude-code"
+	}), { flag: "a" });
+	return true;
+});
+//#endregion
 //#region src/harness/session-start.ts
 /**
 * `ref0 hook session-start`: the harness's `SessionStart` hook, a command, before `ref0 mcp`
@@ -31876,11 +32250,19 @@ 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.cwd ?? ".").pipe(Effect.orElseSucceed(() => false))) yield* Console.log(hookInstallerWords);
 	const binding = yield* bindingHere(hook.value.session_id);
 	if (Option.isNone(binding)) return;
 	const harnessName = binding.value.harness === "codex" ? "codex" : "claude-code";
 	const folder = yield* agents.folder(harnessName);
-	const agent = yield* (yield* HostGrant).get(folder);
+	const kept = yield* (yield* HostGrant).get(folder).pipe(Effect.map((agent) => ({
+		agent,
+		readable: true
+	})), Effect.catchIf((failed) => failed.unreadable === true, () => Effect.succeed({
+		agent: Option.none(),
+		readable: false
+	})));
+	const agent = kept.agent;
 	const repair = Option.isSome(agent) ? installLine(folder) : yield* connectLineFor(harnessName, folder);
 	const update = updateLine({
 		protocol,
@@ -31889,7 +32271,8 @@ const startOnHook = (protocol) => Effect.gen(function* () {
 	if (Option.isSome(update)) return yield* Console.log(update.value);
 	if (Option.isNone(agent)) {
 		const name = harnessName === "codex" ? "Codex" : "Claude Code";
-		return yield* Console.log(`ref0: no agent is connected for this ${name} config folder, ${folder}, so no session starts. In your own terminal, run: ${repair}`);
+		const why = kept.readable ? `no agent is connected for this ${name} config folder, ${folder}` : `the host grant kept for this ${name} config folder, ${folder}, can't be read`;
+		return yield* Console.log(`ref0: ${why}, so no session starts. In your own terminal, run: ${repair}`);
 	}
 	const account = sessionAccount(binding.value);
 	const held = yield* keychain.get(account);
@@ -32060,12 +32443,13 @@ const statusCommands = [Command.make(harnessCommandNames.status, { json }, ({ js
 	const reports = [];
 	for (const configFolder of paths) {
 		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();
 		const harness = Option.isSome(grant) ? grant.value.harness : candidates.get(configFolder);
 		if (Result.isFailure(kept) || Option.isNone(grant)) {
 			const report = {
 				configFolder,
-				checks: [checkOf("connected", Result.isFailure(kept) ? "unknown" : "no", Result.isFailure(kept) ? "The keychain didn’t say whether this config folder holds a host grant." : "not connected", Result.isFailure(kept) ? kept.failure.nextStep : harness === void 0 ? "ref0 connect" : yield* connectLineFor(harness, 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 : {
 				...report,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ref0/cli",
-  "version": "0.7.0",
+  "version": "0.8.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.7.0",
+    "@ref0/sdk": "0.8.0",
     "@types/node": "24.19.2",
     "typescript": "7.0.2",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.3.0",