@ref0/sdk 0.6.0 → 0.8.0

package/README.md

@@ -181,7 +181,7 @@ export default workflow({
 
 `ask.run` is a step of its own. It waits for `{ key, by, via, at }`. At its deadline it returns the lean with `via: 'deadline'` and no `by`. It offers two to five answers, and a run uses each ask key once. A refused or withdrawn ask throws `AskRefused`.
 
-`passkey.run` is also a step of its own. Only the person in their approving browser can answer yes with their passkey. The result has `approved`, `at` and, when someone answered, `by`. A deadline answers no. `from` can also name `{ person: 'mo' }` or `{ permission: 'deploy' }`, with `person` or `permission` in `permissions.ask`. Agents have no passkey.
+`passkey.run` is also a step of its own. Only the person in their approving browser can answer yes with their passkey. The result has `approved`, `at` and, when someone answered, `by`. A deadline answers no. `from` can also name someone else, `{ person: 'pip' }` or `{ permission: 'deploy' }`, with `person` or `permission` in `permissions.ask`. Someone else is never the run's accountable person: naming Mo here, or a permission only Mo holds, throws `PasskeyRequestRefused` with `self`. Agents have no passkey.
 
 Call both leaves outside `step.do` callbacks. Each request spends from the workflow's `asks` budget. Deadlines range from a minute to a day, bounded by the run's remaining day. A called workflow parses its input with one `z.object` and returns JSON to its caller.
 
@@ -248,7 +248,7 @@ The gate in story 1 takes local results with `local(unit())` and `passkey.check(
 
 The newest finished local run counts unless a ref0 failure stands. A newer local run replaces an earlier one, and a newer ref0 pass counts instead. A ref0 failure stands until an admin overrides it, even if a later run passes.
 
-`passkey.check` waits for the person behind the counted run to say yes over its result with their passkey. For a local run, that's the signer's person. For ref0's run, it's the version's accountable person. `{ from }` asks someone else, as in `passkey.check(local(e2e()), { from: { person: 'mo' } })`. The statement names the check-run identity, conclusion and outputs' hash. A newer counted run needs a new yes.
+`passkey.check` waits for the person behind the counted run to say yes over its result with their passkey. For a local run, that's the signer's person. For ref0's run, it's the version's accountable person. `{ from }` asks someone else, as in `passkey.check(local(e2e()), { from: { person: 'mo' } })`. Someone else is never the person behind the run: if Mo ran it, or only Mo holds the permission named, ref0 refuses the request at once, and the check needs an admin's override. The statement names the check-run identity, conclusion and outputs' hash. A newer counted run needs a new yes.
 
 When ref0 runs the same check-run identity as a signed success and it fails twice, the signer stops answering that check. For `local`, ref0 revokes the attachment. For `passkey.check`, it revokes the person whose yes stood over the result. An admin restores the signer with `ref0 checks signers restore`, using `--person` for a person. The floor's needs and the queue's tip take only ref0's runs.
 

package/dist/{browse-DHgV6DTF.d.mts → browse-DZcR8vTe.d.mts}

@@ -1,4 +1,4 @@
-import { $t as WorkflowCallRefusal, An as WorkflowStartState, Cn as WorkflowPasskeyState, Ct as SandboxPushAnswer, D as ConnectionCallAnswer, Dn as WorkflowPullRequestOpen, E as ConnectionCall, En as WorkflowPullRequestAnswer, Gt as WorkflowActionAnswer, Jt as WorkflowAskClosed, L as EventRunInput, Lt as ThreadStage, Mn as WorkflowThreadStart, Nn as WorkflowTrigger, Nt as StartActor$1, Pt as StartRun$1, Qt as WorkflowCallInput, R as ForkAnswer$1, Sn as WorkflowPasskeyRead, St as SandboxPush, V as GetIssueInput, Wt as WorkflowAction, Xt as WorkflowCallAnswer, Yt as WorkflowCall, Zt as WorkflowCallEnded, _ as CheckOwn, _n as WorkflowFilters, an as WorkflowCheckResults, b as CheckTreeEntry, bn as WorkflowPasskeyAsked, bt as SandboxOpen, cn as WorkflowCheckRunEnded, dn as WorkflowCheckStates, en as WorkflowCallRefused, fn as WorkflowCheckStatesAnswer, g as CheckOn, gn as WorkflowEvent, hn as WorkflowConnections, in as WorkflowCheckRefused, jn as WorkflowText, kn as WorkflowStartEnded, ln as WorkflowCheckStart, mn as WorkflowComment, mt as Ref0Owned, nn as WorkflowCalledStateAnswer, on as WorkflowCheckResultsAnswer, pn as WorkflowCheckWhere, rn as WorkflowCheckRefusal, sn as WorkflowCheckRun, tn as WorkflowCalledState, un as WorkflowCheckStartAnswer, v as CheckRunError, vn as WorkflowOwn, vt as SandboxExec, wn as WorkflowPermissions, xn as WorkflowPasskeyEnded, xt as SandboxOpenAnswer, y as CheckRunParams, yn as WorkflowPasskeyAsk, yt as SandboxExecAnswer, z as ForkCreate } from "./index-CJGX88qF.mjs";
+import { $t as WorkflowAskClosed, A as ConnectionCallAnswer, B as EventRunInput, Cn as WorkflowOwn, Ct as SandboxExec, Dn as WorkflowPasskeyRead, Dt as SandboxPush, En as WorkflowPasskeyEnded, Et as SandboxOpenAnswer, Fn as WorkflowStartState, G as GetIssueInput, H as ForkAnswer$1, Ht as ThreadStage, In as WorkflowText, Ln as WorkflowThreadStart, Mn as WorkflowPullRequestOpen, On as WorkflowPasskeyState, Ot as SandboxPushAnswer, Pn as WorkflowStartEnded, Rn as WorkflowTrigger, Rt as StartActor$1, Sn as WorkflowFilters, Tn as WorkflowPasskeyAsked, Tt as SandboxOpen, U as ForkCreate, Xt as WorkflowActionAnswer, Yt as WorkflowAction, _ as CheckOwn, _n as WorkflowCheckStatesAnswer, an as WorkflowCallRefused, b as CheckTreeEntry, bn as WorkflowConnections, cn as WorkflowCheckRefusal, dn as WorkflowCheckResultsAnswer, en as WorkflowCall, fn as WorkflowCheckRun, g as CheckOn, gn as WorkflowCheckStates, hn as WorkflowCheckStartAnswer, in as WorkflowCallRefusal, jn as WorkflowPullRequestAnswer, k as ConnectionCall, kn as WorkflowPermissions, ln as WorkflowCheckRefused, mn as WorkflowCheckStart, nn as WorkflowCallEnded, on as WorkflowCalledState, pn as WorkflowCheckRunEnded, rn as WorkflowCallInput, sn as WorkflowCalledStateAnswer, tn as WorkflowCallAnswer, un as WorkflowCheckResults, v as CheckRunError, vn as WorkflowCheckWhere, vt as Ref0Owned, wn as WorkflowPasskeyAsk, wt as SandboxExecAnswer, xn as WorkflowEvent, y as CheckRunParams, yn as WorkflowComment, zt as StartRun$1 } from "./index-Bm4HWooV.mjs";
 import { z } from "zod";
 //#region src/needs.d.ts
 /**
@@ -671,4 +671,4 @@ interface Browser {
 }
 //#endregion
 export { StartActor as $, ForkOptions as A, WorkflowContext as B, Comment as C, EventWorkflow as D, EventOf as E, StepConfig as F, CalledWorkflow as G, text as H, StepContext as I, TreeEntry as J, JsonValue as K, ThreadStart as L, PullRequestAnswer as M, PullRequestOptions as N, EventWorkflowSpec as O, Ref0Actions as P, Refusal as Q, WaitType as R, CheckRunEnded as S, Duration as T, workflow as U, WorkflowStep as V, CalledRunFailed as W, Allow as X, TreeRead as Y, CalledRun as Z, ActionAnswer as _, CheckRunOptions as a, allow as at, CalledContext as b, CheckRunResult as c, Need as ct, OneOfValues as d, StartContext as et, OutputResult as f, oneOf as g, check as h, CheckResult as i, StartRun as it, NeedAddOptions as j, ForkAnswer as k, CheckSpec as l, Step as m, Check as n, StartOutput as nt, CheckRunReference as o, refuse as ot, OutputSchema as p, Tree as q, CheckContext as r, StartRule as rt, CheckRunRefused as s, CheckNeed as st, Browser as t, StartItem as tt, DurationText as u, CallAnswer as v, ConnectionsOf as w, CalledWorkflowSpec as x, CallEnded as y, WaitedEvent as z };
-//# sourceMappingURL=browse-DHgV6DTF.d.mts.map
+//# sourceMappingURL=browse-DZcR8vTe.d.mts.map

package/dist/browser.d.mts

@@ -1,4 +1,4 @@
-import { t as Browser } from "./browse-DHgV6DTF.mjs";
+import { t as Browser } from "./browse-DZcR8vTe.mjs";
 import { BrowserContext, BrowserContext as BrowserContext$1, BrowserContextOptions, Locator, Page, Page as Page$1, Request, Response } from "@cloudflare/playwright";
 import { expect as expect$1 } from "@cloudflare/playwright/test";
 //#region src/browser-stub.d.ts

package/dist/client.d.mts

@@ -1,4 +1,4 @@
-import { $ as OwnerThreadPage, A as ConnectionName, At as SignInDestination, Bn as isRef0Path, Bt as TrackThread, C as ConnectAgent, Dt as SentryOrg, Et as SecretHash, F as CredentialView, Fn as commandLine, Ft as StatementView, G as LiveTicketRequest, H as Harness, Hn as projectParts, I as EndpointName, In as connectEndpoint, It as ThreadId, J as MirrorChoice, K as LiveTrackName, Ln as encodeSecret, Lt as ThreadStage, M as ConsentAsked, Mt as SocketUrl, N as ConsentClient, O as ConnectionChanged, Ot as SentryRegion, P as ConsentProject, Pn as WrittenProject, Q as OwnerName, Rn as hookTokenPrefix, Rt as TrackClosed, S as ClientGranted, T as ConnectableAgent, Tn as WorkflowPreview, Tt as ScopeAction, U as ImportFailure, Un as repoNameKey, Ut as Welcome, Vn as liveSocketUrl, Vt as TypedApprovalCode, W as LiveTicket, Wn as surfaceOf, X as MirrorView, Y as MirrorEntry, Z as OwnerId, _t as RepoView, a as Api, c as ApprovalId, ct as PreviewEcho, d as ApprovalView, dt as ProjectTrackMessage, et as OwnerThreadView, f as AttachmentFailed, ft as RanOf, gt as RepoUrl, ht as RepoName, i as AgentView, it as PasskeyCreationOptions, j as ConnectionView, jt as SignedIn, k as ConnectionKind, kt as SentryToken, l as ApprovalPreview, lt as PreviewUnavailable, m as Authorization, n as AgentPermissionChoice, nt as PasskeyAsserted, o as ApiOrigin, p as AttachmentRequestView, pt as ReadEvent, q as MachineConnected, r as AgentPermissionSetting, rt as PasskeyCreated, s as ApprovalAnswer, st as PasskeyRequestOptions, t as AgentHandle, tt as OwnerTrackMessage, u as ApprovalState, ut as ProjectName, w as ConnectChosen, x as ClientAccess, zn as hookUrl, zt as TrackSession } from "./index-CJGX88qF.mjs";
+import { $ as MirrorEntry, An as WorkflowPreview, At as ScopeAction, Bn as commandLine, Bt as StatementView, C as ConnectAgent, D as ConnectOptions, E as ConnectFolderOption, F as ConsentAsked, Ft as SignInDestination, Gn as isRef0Path, Gt as TrackThread, Hn as encodeSecret, Ht as ThreadStage, I as ConsentClient, It as SignedIn, J as LiveTicket, Jn as repoNameKey, Jt as Welcome, K as Harness, Kn as liveSocketUrl, Kt as TypedApprovalCode, L as ConsentProject, Lt as SocketUrl, M as ConnectionKind, Mt as SentryOrg, N as ConnectionName, Nt as SentryRegion, O as ConnectableAgent, P as ConnectionView, Pt as SentryToken, Q as MirrorChoice, R as CredentialView, S as ClientGranted, St as RequestFolder, T as ConnectFolderChoices, Un as hookTokenPrefix, Ut as TrackClosed, V as FoldersConnected, Vn as connectEndpoint, Vt as ThreadId, Wn as hookUrl, Wt as TrackSession, X as LiveTrackName, Y as LiveTicketRequest, Yn as surfaceOf, Z as MachineConnected, _t as ReadEvent, a as Api, at as OwnerTrackMessage, bt as RepoUrl, c as ApprovalId, ct as PasskeyCreationOptions, d as ApprovalView, dt as PasskeyRequestOptions, et as MirrorView, f as AttachmentFailed, ft as PreviewEcho, gt as RanOf, ht as ProjectTrackMessage, i as AgentView, it as OwnerThreadView, j as ConnectionChanged, jt as SecretHash, l as ApprovalPreview, m as Authorization, mt as ProjectName, n as AgentPermissionChoice, nt as OwnerName, o as ApiOrigin, ot as PasskeyAsserted, p as AttachmentRequestView, pt as PreviewUnavailable, q as ImportFailure, qn as projectParts, r as AgentPermissionSetting, rt as OwnerThreadPage, s as ApprovalAnswer, st as PasskeyCreated, t as AgentHandle, tt as OwnerId, u as ApprovalState, w as ConnectChosen, x as ClientAccess, xt as RepoView, yt as RepoName, z as EndpointName, zn as WrittenProject } from "./index-Bm4HWooV.mjs";
 import { Effect, Layer, Option, Redacted, Schema, Stream } from "effect";
 import { HttpApi, HttpApiClient, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 import { HttpBody, HttpClient } from "effect/http";
@@ -90,5 +90,5 @@ export declare const startGitHubSignIn: (landing: {
  */
 export declare const signOut: (origin?: ApiOrigin) => Effect.Effect<void, import("effect/http/HttpClientError").HttpClientError, HttpClient.HttpClient>;
 //#endregion
-export { AgentHandle, type AgentPermissionChoice, type AgentPermissionSetting, type AgentView, ApiOrigin, type ApprovalAnswer, type ApprovalId, type ApprovalPreview, type ApprovalState, type ApprovalView, AttachmentFailed, type AttachmentRequestView, ClientAccess, ClientGranted, type ConnectAgent, type ConnectChosen, type ConnectableAgent, ConnectionChanged, ConnectionKind, ConnectionName, type ConnectionView, type ConsentAsked, type ConsentClient, ConsentProject, type CredentialView, type Harness, type ImportFailure, type LiveTicket, type LiveTicketRequest, LiveTrackName, MachineConnected, type MirrorChoice, type MirrorEntry, type MirrorView, type OwnerId, OwnerName, type OwnerThreadPage, type OwnerThreadView, OwnerTrackMessage, PasskeyAsserted, PasskeyCreated, type PasskeyCreationOptions, type PasskeyRequestOptions, type PreviewEcho, PreviewUnavailable, ProjectName, ProjectTrackMessage, type ReadEvent, type Ref0Client, RepoName, RepoUrl, type RepoView, type ScopeAction, SecretHash, SentryOrg, SentryRegion, SentryToken, type SettledApproval, SignInDestination, type StatementView, ThreadId, ThreadStage, type TrackClosed, type TrackSession, type TrackThread, TypedApprovalCode, type Welcome, WorkflowPreview, WrittenProject, commandLine, connectEndpoint, encodeSecret, hookTokenPrefix, hookUrl, isRef0Path, liveSocketUrl, projectParts, repoNameKey, surfaceOf };
+export { AgentHandle, type AgentPermissionChoice, type AgentPermissionSetting, type AgentView, ApiOrigin, type ApprovalAnswer, type ApprovalId, type ApprovalPreview, type ApprovalState, type ApprovalView, AttachmentFailed, AttachmentRequestView, ClientAccess, ClientGranted, type ConnectAgent, type ConnectChosen, type ConnectFolderChoices, type ConnectFolderOption, type ConnectOptions, type ConnectableAgent, ConnectionChanged, ConnectionKind, ConnectionName, type ConnectionView, type ConsentAsked, type ConsentClient, ConsentProject, type CredentialView, FoldersConnected, type Harness, type ImportFailure, type LiveTicket, type LiveTicketRequest, LiveTrackName, MachineConnected, type MirrorChoice, type MirrorEntry, type MirrorView, type OwnerId, OwnerName, type OwnerThreadPage, type OwnerThreadView, OwnerTrackMessage, PasskeyAsserted, PasskeyCreated, type PasskeyCreationOptions, type PasskeyRequestOptions, type PreviewEcho, PreviewUnavailable, ProjectName, ProjectTrackMessage, type ReadEvent, type Ref0Client, RepoName, RepoUrl, type RepoView, type RequestFolder, type ScopeAction, SecretHash, SentryOrg, SentryRegion, SentryToken, type SettledApproval, SignInDestination, type StatementView, ThreadId, ThreadStage, type TrackClosed, type TrackSession, type TrackThread, TypedApprovalCode, type Welcome, WorkflowPreview, WrittenProject, commandLine, connectEndpoint, encodeSecret, hookTokenPrefix, hookUrl, isRef0Path, liveSocketUrl, projectParts, repoNameKey, surfaceOf };
 //# sourceMappingURL=client.d.mts.map

package/dist/client.mjs

@@ -1266,7 +1266,9 @@ const FindingRef = Schema.Struct({
 * Who a passkey request asks: the accountable person; a person, by their name; or anyone holding
 * one of the repo's permissions, the first of whom to answer decides. Until a permission's holders
 * are kept, they're its owner's admins. A workflow run's `passkey.run` asks its run's accountable
-* person; a gate's `passkey.check` asks the person behind the run that meets its need.
+* person; a gate's `passkey.check` asks the person behind the run that meets its need. A person or
+* a permission is someone else, a second pair of eyes, so the person `'accountable'` would ask
+* never answers it: a request with nobody else to ask is refused.
 */
 const PasskeyFrom = Schema.Union([
 	Schema.Literal("accountable"),
@@ -6417,39 +6419,57 @@ 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"));
 /** 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"]);
-/**
-* A machine asks with no owner and sends hashes of its grant, collecting and link secrets.
-* The optional callback names only a loopback port and a random state segment, never a host.
-*/
+/** The machine's loopback listener; no caller may choose its host. */
+const AttachmentCallback = Schema.Struct({
+	port: Schema.Int.check(Schema.isBetween({
+		minimum: 1024,
+		maximum: 65535
+	})),
+	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), 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,
+	harness: ConnectHarness,
+	secretHash: SecretHash,
+	replaces: Schema.optionalKey(TokenId)
+});
+/** One to eight config folders, each with its own grant secret. */
 const RequestAttachment = Schema.Struct({
 	machine: MachineId,
 	machineName: MachineName,
-	harness: Schema.optionalKey(ConnectHarness),
-	secretHash: SecretHash,
+	folders: Schema.Array(RequestFolder).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths),
 	collectHash: SecretHash,
 	linkHash: SecretHash,
-	callback: Schema.optionalKey(Schema.Struct({
-		port: Schema.Int.check(Schema.isBetween({
-			minimum: 1024,
-			maximum: 65535
-		})),
-		state: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{22}$/))
-	}))
+	callback: Schema.optionalKey(AttachmentCallback)
 });
 /** An attachment request, as its person reads it once they type its code. */
 const AttachmentRequestView = Schema.Struct({
 	approval: ApprovalId,
 	/** The machine's own word for itself, never fact. */
 	machineName: MachineName,
-	/** The harness the machine says it uses, never fact. */
-	harness: Schema.optionalKey(ConnectHarness),
+	folders: Schema.Array(Schema.Struct({
+		path: ConfigFolderPath,
+		harness: ConnectHarness,
+		replaces: Schema.optionalKey(TokenId)
+	})),
 	askedFrom: Schema.optionalKey(Schema.String),
 	askedAt: Timestamp,
-	expiresAt: Timestamp
+	expiresAt: Timestamp,
+	callback: Schema.optionalKey(AttachmentCallback)
 });
 /**
 * What its answerer chooses to connect a machine's request to: one of the person's own agents,
@@ -6473,6 +6493,16 @@ const ConnectOrganization = Schema.Struct({
 	organization: OrgId,
 	name: OwnerName
 });
+/** Whether admission replaced a live host grant, or skipped one that no longer belongs here. */
+const GrantReplacement = Schema.Struct({
+	grant: TokenId,
+	state: Schema.Literals([
+		"replaces",
+		"revoked",
+		"skipped"
+	]),
+	attachedAt: Schema.optionalKey(Timestamp)
+});
 /**
 * What a yes would connect the machine to, as options resolved the choice: the agent, or none
 * yet, to make with the handle; and each organization its attachment is authorized in.
@@ -6480,22 +6510,32 @@ const ConnectOrganization = Schema.Struct({
 const ConnectChosen = Schema.Struct({
 	agent: Schema.optionalKey(AgentRef),
 	handle: AgentHandle,
-	organizations: Schema.Array(ConnectOrganization)
+	organizations: Schema.Array(ConnectOrganization),
+	replacement: Schema.optionalKey(GrantReplacement)
 });
-/**
-* A machine's request, as its answerer chooses what it connects to. Without a choice: the
-* request and the person's agents that are on, and nothing chosen for them. With one: the
-* request, what the choice resolved to, and the passkey's options, whose challenge signs over
-* the connect it would run.
-*/
-const ConnectOptions = Schema.Union([Schema.Struct({
-	request: AttachmentRequestView,
-	agents: Schema.Array(ConnectableAgent)
+/** A complete choice: name every folder once, leaving at least one in. */
+const ConnectFolderChoice = Schema.Union([Schema.Struct({
+	path: ConfigFolderPath,
+	excluded: Schema.Literal(true)
+}), Schema.Struct({
+	path: ConfigFolderPath,
+	agent: ConnectAgent
+})]);
+const ConnectFolderChoices = Schema.Array(ConnectFolderChoice).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths);
+const ConnectFolderOption = Schema.Union([Schema.Struct({
+	path: ConfigFolderPath,
+	excluded: Schema.Literal(true)
 }), Schema.Struct({
+	path: ConfigFolderPath,
+	connect: ConnectChosen
+})]);
+/** Defaults and explicit choices both resolve the entire request and sign one challenge. */
+const ConnectOptions = Schema.Struct({
 	request: AttachmentRequestView,
-	connect: ConnectChosen,
+	agents: Schema.Array(ConnectableAgent),
+	folders: Schema.Array(ConnectFolderOption),
 	passkey: PasskeyRequestOptions
-})]);
+});
 /** Why connecting connected nothing, said for the person. */
 const AttachmentFailure = Schema.Struct({
 	reason: Schema.Literals([
@@ -6523,11 +6563,9 @@ const RequestOrganization = Schema.Struct({
 	])
 });
 /**
-* Where a machine's request stands, for the machine that asked, by its collecting secret: waiting,
-* or how it ended. Every answer but waiting is final, but a connect nobody confirmed 10 minutes
-* after it connected fails `not confirmed` once ref0 takes its grant to revoke it. Connected
-* names the owner by its name, and the host grant, whose token the machine makes from its ID and
-* the grant's secret.
+* The result collected with the machine's two proofs: each included folder's identity and grant,
+* its agent's owner name and organizations, and excluded paths. Confirmation checks each saved
+* grant's live deadline in the Owner DO.
 */
 const RequestState = Schema.Union([
 	Schema.Struct({
@@ -6537,20 +6575,30 @@ const RequestState = Schema.Union([
 	Schema.Struct({
 		state: Schema.Literal("connected"),
 		owner: OwnerName,
-		agent: AgentRef,
-		handle: AgentHandle,
-		credential: CredentialRef,
-		organizations: Schema.Array(RequestOrganization)
+		folders: Schema.Array(Schema.Struct({
+			path: ConfigFolderPath,
+			owner: OwnerName,
+			...MachineConnected.fields,
+			organizations: Schema.Array(RequestOrganization),
+			replacement: Schema.optionalKey(GrantReplacement)
+		})),
+		excluded: Schema.Array(ConfigFolderPath)
 	}),
 	Schema.Struct({ state: Schema.Literal("refused") }),
 	Schema.Struct({ state: Schema.Literal("aborted") }),
 	Schema.Struct({ state: Schema.Literal("expired") }),
 	Schema.Struct({
 		state: Schema.Literal("failed"),
-		reason: Schema.Literals([...AttachmentFailure.fields.reason.literals, "not confirmed"]),
+		reason: AttachmentFailure.fields.reason,
 		nextStep: Schema.String
 	})
 ]);
+/** The grant IDs saved by this terminal, each belonging to the same admission. */
+const SavedMachineGrants = Schema.Array(TokenId).check(Schema.isMinLength(1), Schema.isMaxLength(8), Schema.isUnique());
+Schema.Struct({
+	approval: ApprovalId,
+	grants: SavedMachineGrants
+});
 /**
 * The machine saying it saved the grant it collected: confirmed, the same again, or not, once ref0
 * has taken the grant to revoke it, and the machine deletes what it saved.
@@ -6583,21 +6631,34 @@ const AuthorizeIn = Schema.Struct({
 	organization: OrgId,
 	targetGeneration: TargetGeneration
 });
-/** What every connect names: the agent, the machine and its host grant, and what it was bound to. */
-const connectFields = {
+/** One folder admitted under the request's machine and approving browser. */
+const ConnectFolderCommand = Schema.Struct({
+	path: ConfigFolderPath,
 	agent: AttachmentAgent,
-	machine: MachineId,
-	machineName: MachineName,
 	token: TokenId,
 	secretHash: SecretHash,
-	browserSession: TokenId,
-	personGeneration: Generation,
+	replaces: Schema.optionalKey(TokenId),
 	authorizeIn: Schema.Array(AuthorizeIn)
-};
+});
 Schema.Struct({
 	request: ApprovalId,
-	...connectFields
+	machine: MachineId,
+	machineName: MachineName,
+	browserSession: TokenId,
+	personGeneration: Generation,
+	folders: Schema.Array(ConnectFolderCommand).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths),
+	excluded: Schema.Array(ConfigFolderPath).check(Schema.isMaxLength(7), Schema.isUnique())
+});
+const FoldersConnected = Schema.Struct({
+	folders: Schema.Array(Schema.Struct({
+		path: ConfigFolderPath,
+		...MachineConnected.fields,
+		replacement: Schema.optionalKey(GrantReplacement)
+	})),
+	excluded: Schema.Array(ConfigFolderPath)
 });
+Schema.Array(GrantReplacement);
+Schema.Array(TokenId).check(Schema.isMaxLength(8));
 /** An attachment that isn't there, or isn't the caller's, answers the same. */
 var AttachmentNotFound = class extends Schema.TaggedError()("AttachmentNotFound", { nextStep: Schema.String }, { httpApiStatus: 404 }) {};
 /** Connecting connected nothing, and why: what an attachment's approval came to instead. */
@@ -6779,7 +6840,7 @@ const FindApproval = Schema.Union([Schema.Struct({ code: TypedApprovalCode }), S
 */
 const ApprovalOptionsRequest = Schema.Struct({
 	code: Schema.optionalKey(TypedApprovalCode),
-	agent: Schema.optionalKey(ConnectAgent)
+	folders: Schema.optionalKey(ConnectFolderChoices)
 });
 /**
 * An answer: yes, with the passkey, or no. For an agent's ask, each answer can set the owner's
@@ -6832,7 +6893,11 @@ const ApprovalState = Schema.Union([
 		state: Schema.Literal("waiting"),
 		expiresAt: Timestamp
 	}),
-	Schema.Struct({ state: Schema.Literal("approved") }),
+	Schema.Struct({
+		state: Schema.Literal("approved"),
+		/** A machine's answering browser may forget its saved answer once the terminal kept it. */
+		collected: Schema.optionalKey(Schema.Literal(true))
+	}),
 	Schema.Struct({ state: Schema.Literal("refused") }),
 	Schema.Struct({ state: Schema.Literal("expired") }),
 	Schema.Struct({
@@ -11635,10 +11700,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. */
@@ -11660,17 +11727,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
@@ -11701,19 +11772,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({
@@ -11731,15 +11799,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,
@@ -11787,10 +11854,10 @@ const GateInPlaceView = Schema.Struct({
 /**
 * One `from`'s yes over the run that counts for a part that needs one (L2), as `passkey.check`
 * asks: `asked`, waiting, of `asked` when it's one person; `yes`, by whom and when; `no`;
-* `expired`, its day passed unanswered; `refused`, the person it names can't be asked; or
-* `revoked`, a yes whose answerer a miss revoked since, until an admin restores them. A local
-* run's no or day passing waits for a newer local run; a ref0 run's, or a refusal, leaves the
-* part with no yes, until an admin overrides it.
+* `expired`, its day passed unanswered; `refused`, asking nobody, `why`; or `revoked`, a yes whose
+* answerer a miss revoked since, until an admin restores them. A local run's no or day passing
+* waits for a newer local run; a ref0 run's, or a refusal, leaves the part with no yes, until an
+* admin overrides it.
 */
 const GatePartYes = Schema.Struct({
 	from: PasskeyFrom,
@@ -11802,6 +11869,12 @@ const GatePartYes = Schema.Struct({
 		"refused",
 		"revoked"
 	]),
+	/**
+	* Why a request was refused: `target`, nobody it names can be asked, a person who isn't there
+	* or can't see the pull request's thread; or `self`, it names the person behind the run, or a
+	* permission only they hold, who can't be the second pair of eyes over their own run.
+	*/
+	why: Schema.optionalKey(Schema.Literals(["target", "self"])),
 	asked: Schema.optionalKey(PersonId),
 	by: Schema.optionalKey(OwnerName),
 	at: Schema.optionalKey(Schema.DateTimeUtcFromMillis)
@@ -14839,6 +14912,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 = {
 	owner: OwnerRef,
@@ -14962,14 +15040,17 @@ 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,
 	error: [AttachmentNotFound, AuthorityUnavailable]
 }).middleware(ApprovalSecret), HttpApiEndpoint.post("confirm", "/v1/attachments/requests/:approval/collected", {
 	params: { approval: ApprovalId },
-	payload: Schema.Struct({ answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64))) }),
+	payload: Schema.Struct({
+		grants: SavedMachineGrants,
+		answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64)))
+	}),
 	headers: idempotency,
 	success: RequestConfirmed,
 	error: [AttachmentNotFound, AuthorityUnavailable]
@@ -17978,7 +18059,7 @@ HttpApi.reflect(Api, {
 * leaves out only `ApprovalNeeded`, at `202`.
 */
 const schemasOf = (name) => Option.fromNullishOr(reflected.get(name));
-Schema.toCodecJson(MachineConnected), Schema.toCodecJson(AttachmentFailed);
+Schema.toCodecJson(FoldersConnected), Schema.toCodecJson(AttachmentFailed);
 const isEndpointName = (name) => name in surfaces;
 const encodeJson = Schema.encodeEffect(Schema.fromJsonString(Schema.Json));
 const decodeJson = Schema.decodeUnknownEffect(Schema.Json);
@@ -18247,6 +18328,6 @@ const signOut = (origin) => Effect.gen(function* () {
 	yield* client.execute(HttpClientRequest.make(method)(path, { body: HttpBody.jsonUnsafe({}) }));
 });
 //#endregion
-export { AgentHandle, ApiOrigin, AttachmentFailed, ClientAccess, ClientGranted, ConnectionChanged, ConnectionKind, ConnectionName, ConsentProject, LiveTrackName, MachineConnected, OwnerName, OwnerTrackMessage, PasskeyAsserted, PasskeyCreated, PreviewUnavailable, ProjectName, ProjectTrackMessage, RepoName, RepoUrl, SecretHash, SentryOrg, SentryRegion, SentryToken, SignInDestination, ThreadId, ThreadStage, TypedApprovalCode, WorkflowPreview, WrittenProject, anonymousCredential, bearerCredential, browserCredential, commandLine, connectEndpoint, encodeSecret, fetchTransport, followApproval, hookTokenPrefix, hookUrl, isRef0Path, liveMessages, liveSocketUrl, newRequestId, projectParts, ref0Client, repoNameKey, settledOf, signOut, startGitHubSignIn, surfaceOf };
+export { AgentHandle, ApiOrigin, AttachmentFailed, AttachmentRequestView, ClientAccess, ClientGranted, ConnectionChanged, ConnectionKind, ConnectionName, ConsentProject, FoldersConnected, LiveTrackName, MachineConnected, OwnerName, OwnerTrackMessage, PasskeyAsserted, PasskeyCreated, PreviewUnavailable, ProjectName, ProjectTrackMessage, RepoName, RepoUrl, SecretHash, SentryOrg, SentryRegion, SentryToken, SignInDestination, ThreadId, ThreadStage, TypedApprovalCode, WorkflowPreview, WrittenProject, anonymousCredential, bearerCredential, browserCredential, commandLine, connectEndpoint, encodeSecret, fetchTransport, followApproval, hookTokenPrefix, hookUrl, isRef0Path, liveMessages, liveSocketUrl, newRequestId, projectParts, ref0Client, repoNameKey, settledOf, signOut, startGitHubSignIn, surfaceOf };
 
 //# sourceMappingURL=client.mjs.map