@ref0/sdk 0.5.0 → 0.7.0

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"),
@@ -3353,14 +3355,10 @@ const durationOf = (least, most, bounds) => Schema.String.check(Schema.makeFilte
 /** A check run's timeout, as its file writes it: 45 minutes unless it says, and 6 hours at most. */
 const CheckRunTimeout = durationOf(1, 21600, "from a second to 6 hours");
 /**
-* When ref0 starts a check itself: on each `change`, before the change joins `main`; on the
-* merge queue's `tip`, before `main` moves, so it guards `main`; or on what `deployed`.
+* When ref0 starts a check itself: on each `change`, before the change joins `main`; or on the
+* merge queue's `tip`, before `main` moves, so it guards `main`.
 */
-const CheckTrigger = Schema.Literals([
-	"change",
-	"tip",
-	"deployed"
-]);
+const CheckTrigger = Schema.Literals(["change", "tip"]);
 /**
 * Each time ref0 starts a check itself, each once: `['change', 'tip']` unless its file says, and
 * `[]` for a check other code calls or people run by hand. Whether any other start may make a new
@@ -6420,41 +6418,51 @@ const PasskeyList = Schema.Struct({
 var PasskeyRefused = class extends Schema.TaggedError()("PasskeyRefused", { nextStep: Schema.String }, { httpApiStatus: 400 }) {};
 //#endregion
 //#region ../contracts/src/attachments.ts
-/**
-* `ref0 connect`, as agent-connect builds it: a machine asks first, with no credential, to connect
-* to one of an owner's agents, and its terminal shows a code; the owner's person types it under
-* Waiting on you and answers, with their passkey for a yes; and the machine collects its host
-* grant with a secret it made.
-*/
+/** A machine asks, a signed-in person claims and approves, and the answer returns to its terminal. */
 /** 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));
 /** The harness a machine says it connects for, never proof of what it runs. */
 const ConnectHarness = Schema.Literals(["claude-code", "codex"]);
-/**
-* An attachment request: `ref0 connect --owner <name>` asking, with no credential, to connect this
-* machine to one of that owner's agents. It names the owner, the machine, and the hashes of two
-* secrets it made: the host grant's, which ref0 first sees when the grant is used, and another it
-* collects with, so the grant's own secret never goes to ref0 before then. Its terminal shows the
-* code its answer gives, which the owner's person types under Waiting on you.
-*/
+/** 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), Schema.isPattern(/^[^\p{C}\p{Zl}\p{Zp}]+$/u));
+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({
-	owner: OwnerName,
 	machine: MachineId,
 	machineName: MachineName,
-	harness: Schema.optionalKey(ConnectHarness),
-	secretHash: SecretHash,
-	collectHash: SecretHash
+	folders: Schema.Array(RequestFolder).check(Schema.isMinLength(1), Schema.isMaxLength(8), uniqueFolderPaths),
+	collectHash: SecretHash,
+	linkHash: SecretHash,
+	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,
@@ -6478,6 +6486,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.
@@ -6485,22 +6503,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([
@@ -6528,11 +6556,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({
@@ -6542,20 +6568,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.
@@ -6588,21 +6624,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. */
@@ -6776,7 +6825,7 @@ const ApprovalsWaiting = Schema.Struct({
 	requests: Schema.Array(AttachmentRequestView)
 });
 /** Finding a terminal's request by the code it showed. */
-const FindApproval = Schema.Struct({ code: TypedApprovalCode });
+const FindApproval = Schema.Union([Schema.Struct({ code: TypedApprovalCode }), Schema.Struct({ link: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{22}$/)) })]);
 /**
 * Asking for the passkey's options to answer a request: a terminal's request needs its code
 * again, so its ID alone, which travels where its code doesn't, never answers it. A machine's
@@ -6784,7 +6833,7 @@ const FindApproval = Schema.Struct({ code: TypedApprovalCode });
 */
 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
@@ -6837,7 +6886,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({
@@ -6846,6 +6899,18 @@ const ApprovalState = Schema.Union([
 		...Ran.fields
 	})
 ]);
+/** Only the answering browser receives a machine's answer code; state reads never carry it. */
+const ApprovalAnswer = Schema.Union([
+	Schema.Struct({
+		...ApprovalState.members[1].fields,
+		answerCode: ApprovalCode
+	}),
+	Schema.Struct({
+		...ApprovalState.members[4].fields,
+		answerCode: ApprovalCode
+	}),
+	ApprovalState
+]);
 /** A request that isn't there, or isn't the caller's to see, answers the same. */
 var ApprovalNotFound = class extends Schema.TaggedError()("ApprovalNotFound", { nextStep: Schema.String }, { httpApiStatus: 404 }) {};
 /** Too many asked, or too many codes typed, from here in the last hour. */
@@ -6865,6 +6930,8 @@ Schema.Struct({
 	/** When the request expires, in epoch milliseconds. */
 	deadline: Schema.Int,
 	challenge: Schema.String,
+	/** A machine answer retries only from its answering session, with this key. */
+	answerKey: Schema.optionalKey(RequestId),
 	/** An agent's ask: the credential it asked with, checked again before the answer counts. */
 	asking: Schema.optionalKey(TokenId),
 	/** The kind of action the person, answering, let agents take without asking from now on. */
@@ -6882,7 +6949,8 @@ Schema.Union([Schema.Struct({ denied: Schema.Literal(true) }), Schema.Struct({
 })]);
 Schema.Union([Schema.Struct({
 	admitted: Schema.Literal(true),
-	admittedAt: Schema.Int
+	admittedAt: Schema.Int,
+	answerCode: Schema.optionalKey(ApprovalCode)
 }), Schema.Struct({
 	admitted: Schema.Literal(false),
 	reason: Schema.Literals([
@@ -10660,7 +10728,16 @@ const DeliveryTake = Schema.Struct({
 	*/
 	requestKey: Schema.String.check(Schema.isBetweenLength(1, 256)),
 	/** Its place in the session's order, so a take from a process that's been replaced is refused. */
-	seq: HookSeq
+	seq: HookSeq,
+	/**
+	* The UTF-8 bytes `ref0 mcp` keeps in this hook's answer for text of its own, a notice of what
+	* merged into the session's base, at most one item's. The ledger's items fit beside it, unless
+	* one wouldn't: then they take the room, and the text waits whole for the next hook.
+	*/
+	reserved: Schema.optionalKey(Schema.Int.check(Schema.isBetween({
+		minimum: 1,
+		maximum: 7600
+	})))
 });
 /**
 * One item handed to a hook: its key, kind and text, rendered when it's taken, after who may
@@ -10689,6 +10766,15 @@ const DeliveriesTaken = Schema.Struct({
 	left: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
 });
 /**
+* What a hook's take answers: what it hands, and whether the bytes it reserved are still free
+* beside that. Not when a ledger item needed them, so the text they were kept for waits whole
+* for the next hook. Kept when none were reserved.
+*/
+const HookTaken = Schema.Struct({
+	...DeliveriesTaken.fields,
+	reservedKept: Schema.Boolean
+});
+/**
 * A take refused: the session ended, or the hook message is older than one its session already
 * sent, from a `ref0 mcp` that's since been replaced. Nothing is handed over.
 */
@@ -10708,8 +10794,8 @@ Schema.Struct({
 Schema.Union([DeliveriesTaken, TakeRefused]);
 /**
 * Where a take's notices may go once the Project DO has handed its own: the UTF-8 bytes left
-* in the hook's answer, and the repos whose Repo DOs owe the session one. Absent when the hook
-* can't carry a notice.
+* in the hook's answer, past any it kept reserved, and the repos whose Repo DOs owe the session
+* one. Absent when the hook can't carry a notice.
 */
 const NoticeRoom = Schema.Struct({
 	room: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
@@ -10719,7 +10805,7 @@ const NoticeRoom = Schema.Struct({
 });
 /** What the Project DO's take answers the Worker: its own attempts, and where notices may go. */
 const ProjectDeliveriesTaken = Schema.Struct({
-	...DeliveriesTaken.fields,
+	...HookTaken.fields,
 	notices: Schema.optionalKey(NoticeRoom)
 });
 Schema.Union([ProjectDeliveriesTaken, TakeRefused]);
@@ -11658,6 +11744,70 @@ Schema.Union([
 	NotPermitted
 ]);
 //#endregion
+//#region ../contracts/src/session-base.ts
+/**
+* A session's base in a repo: what its work there builds on now, read from its live fork. That's
+* the pin of the thread its thread is stacked on, when that thread has one in the repo, and
+* otherwise `main`. `ref0 sync` merges it, and the local check checks the agent's work against it.
+*/
+/** What a base is: `main`, or the thread this one is stacked on, by its number. */
+const BaseOn = Schema.Union([Schema.Literal("main"), Schema.Struct({ thread: ThreadNumber })]);
+/** A session's base, as `GET /v1/sessions/{session}/repos/{repo}/base` answers it. */
+const SessionBase = Schema.Struct({
+	on: BaseOn,
+	/** `main`'s tip, or the pin's commit: what `ref` reaches once fetched. */
+	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.
+	*/
+	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.
+*/
+var NoBase = class extends Schema.TaggedError()("NoBase", {
+	why: Schema.Literals(["main empty", "held by a run"]),
+	nextStep: Schema.String
+}, { httpApiStatus: 404 }) {};
+Schema.Struct({
+	session: SessionId,
+	/**
+	* For an agent that sees only threads it holds a grant on, those threads: a session whose
+	* thread is stacked, at any depth, on any other is refused, as its base holds that thread's
+	* work. Unset for one that sees the project as a whole.
+	*/
+	only: Schema.optionalKey(Schema.Array(ThreadId))
+});
+/** The base on `main`, at its tip. */
+const BaseOnMain = Schema.Struct({
+	on: Schema.Literal("main"),
+	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.
+*/
+const BaseOnStack = Schema.Struct({
+	on: Schema.Literal("stack"),
+	lower: ThreadId,
+	commit: CommitOid,
+	fork: ForkId,
+	session: Schema.NullOr(SessionId)
+});
+Schema.Union([
+	BaseOnMain,
+	BaseOnStack,
+	NoFork,
+	NoBase,
+	RepoNotReady,
+	NotPermitted
+]);
+//#endregion
 //#region ../contracts/src/gate-views.ts
 /**
 * A pull request's gate, as `ref0 gate` reads it: its current version, whether its needs are
@@ -11695,10 +11845,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,
@@ -11710,6 +11860,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)
@@ -14870,12 +15026,17 @@ var MachineAttachmentsGroup = class extends HttpApiGroup.make("machineAttachment
 		SlowDown,
 		AuthorityUnavailable
 	]
-}), HttpApiEndpoint.get("collect", "/v1/attachments/requests/:approval/result", {
+}), 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({
+		grants: SavedMachineGrants,
+		answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64)))
+	}),
 	headers: idempotency,
 	success: RequestConfirmed,
 	error: [AttachmentNotFound, AuthorityUnavailable]
@@ -14925,7 +15086,7 @@ var ApprovalsGroup = class extends HttpApiGroup.make("approvals").add(HttpApiEnd
 	params: { approval: ApprovalId },
 	headers: idempotency,
 	payload: AnswerApproval,
-	success: ApprovalState,
+	success: ApprovalAnswer,
 	error: [
 		ApprovalNotFound,
 		NotPermitted,
@@ -15154,6 +15315,19 @@ var SessionsGroup = class extends HttpApiGroup.make("sessions").add(HttpApiEndpo
 		RepoNotReady,
 		NotPermitted
 	]
+}), HttpApiEndpoint.get("base", "/:session/repos/:repo/base", {
+	params: {
+		session: SessionId,
+		repo: RepoName
+	},
+	success: SessionBase,
+	error: [
+		RepoNotFound,
+		RepoNotReady,
+		NotPermitted,
+		NoFork,
+		NoBase
+	]
 }), HttpApiEndpoint.post("openPull", "/:session/repos/:repo/pulls", {
 	params: {
 		session: SessionId,
@@ -15272,7 +15446,7 @@ var SessionsGroup = class extends HttpApiGroup.make("sessions").add(HttpApiEndpo
 }), HttpApiEndpoint.post("take", "/:session/deliveries/take", {
 	params: onSession,
 	payload: DeliveryTake,
-	success: DeliveriesTaken,
+	success: HookTaken,
 	error: [TakeRefused, NotPermitted]
 }), HttpApiEndpoint.post("report", "/:session/deliveries/report", {
 	params: onSession,
@@ -16863,6 +17037,15 @@ const ownSurfaces = {
 		cli: "clone",
 		mcp: "repo_fork"
 	},
+	"sessions.base": {
+		action: "project:read",
+		actors: "agent",
+		target: "session",
+		stepUp: "never",
+		asks: "never",
+		cli: "sync",
+		mcp: null
+	},
 	"sessions.openPull": {
 		action: "session:change",
 		actors: "agent",
@@ -17862,7 +18045,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);
@@ -18131,6 +18314,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