@ref0/sdk 0.5.0 → 0.6.0

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

@@ -1,4 +1,4 @@
-import { $t as WorkflowCallRefused, An as WorkflowText, B as GetIssueInput, Cn as WorkflowPermissions, E as ConnectionCallAnswer, En as WorkflowPullRequestOpen, I as EventRunInput, It as ThreadStage, Jt as WorkflowCall, L as ForkAnswer$1, Mn as WorkflowTrigger, Mt as StartActor$1, Nt as StartRun$1, On as WorkflowStartEnded, Qt as WorkflowCallRefusal, R as ForkCreate, Sn as WorkflowPasskeyState, St as SandboxPushAnswer, T as ConnectionCall, Tn as WorkflowPullRequestAnswer, Ut as WorkflowAction, Wt as WorkflowActionAnswer, Xt as WorkflowCallEnded, Yt as WorkflowCallAnswer, Zt as WorkflowCallInput, _ as CheckRunError, _n as WorkflowOwn, _t as SandboxExec, an as WorkflowCheckResultsAnswer, bn as WorkflowPasskeyEnded, bt as SandboxOpenAnswer, cn as WorkflowCheckStart, dn as WorkflowCheckStatesAnswer, en as WorkflowCalledState, fn as WorkflowCheckWhere, g as CheckOwn, gn as WorkflowFilters, h as CheckOn, hn as WorkflowEvent, in as WorkflowCheckResults, jn as WorkflowThreadStart, kn as WorkflowStartState, ln as WorkflowCheckStartAnswer, mn as WorkflowConnections, nn as WorkflowCheckRefusal, on as WorkflowCheckRun, pn as WorkflowComment, pt as Ref0Owned, qt as WorkflowAskClosed, rn as WorkflowCheckRefused, sn as WorkflowCheckRunEnded, tn as WorkflowCalledStateAnswer, un as WorkflowCheckStates, v as CheckRunParams, vn as WorkflowPasskeyAsk, vt as SandboxExecAnswer, xn as WorkflowPasskeyRead, xt as SandboxPush, y as CheckTreeEntry, yn as WorkflowPasskeyAsked, yt as SandboxOpen } from "./index-Dns8tCkT.mjs";
+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 { z } from "zod";
 //#region src/needs.d.ts
 /**
@@ -551,10 +551,10 @@ interface CheckSpec<Params extends z.ZodObject, Output> {
   /** For the whole check run, 45 minutes unless it says, and 6 hours at most. */
   readonly timeout?: DurationText;
   /**
-   * When ref0 starts it itself, each once: `'change'`, on each change before it joins `main`;
-   * `'tip'`, on the merge queue's tip before `main` moves, so it guards `main`; `'deployed'`, on
-   * what deployed. `['change', 'tip']` unless it says, and `[]` for ref0 never to start it, so only
-   * other code and people do, as its start rule lets them.
+   * When ref0 starts it itself, each once: `'change'`, on each change before it joins `main`; or
+   * `'tip'`, on the merge queue's tip before `main` moves, so it guards `main`. `['change', 'tip']`
+   * unless it says, and `[]` for ref0 never to start it, so only other code and people do, as its
+   * start rule lets them.
    */
   readonly on?: CheckOn;
   /**
@@ -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-DBqoeS-u.d.mts.map
+//# sourceMappingURL=browse-DHgV6DTF.d.mts.map

package/dist/browser.d.mts

@@ -1,4 +1,4 @@
-import { t as Browser } from "./browse-DBqoeS-u.mjs";
+import { t as Browser } from "./browse-DHgV6DTF.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 OwnerThreadView, A as ConnectionView, At as SignedIn, Bn as liveSocketUrl, Bt as TypedApprovalCode, C as ConnectChosen, D as ConnectionChanged, Dt as SentryRegion, Et as SentryOrg, F as EndpointName, Fn as connectEndpoint, Ft as ThreadId, G as LiveTrackName, H as ImportFailure, Hn as repoNameKey, Ht as Welcome, In as encodeSecret, It as ThreadStage, J as MirrorEntry, K as MachineConnected, Ln as hookTokenPrefix, Lt as TrackClosed, M as ConsentClient, N as ConsentProject, Nn as WrittenProject, O as ConnectionKind, Ot as SentryToken, P as CredentialView, Pn as commandLine, Pt as StatementView, Q as OwnerThreadPage, Rn as hookUrl, Rt as TrackSession, S as ConnectAgent, Tt as SecretHash, U as LiveTicket, Un as surfaceOf, V as Harness, Vn as projectParts, W as LiveTicketRequest, X as OwnerId, Y as MirrorView, Z as OwnerName, a as Api, b as ClientAccess, c as ApprovalPreview, ct as PreviewUnavailable, d as AttachmentFailed, dt as RanOf, et as OwnerTrackMessage, f as AttachmentRequestView, ft as ReadEvent, gt as RepoView, ht as RepoUrl, i as AgentView, j as ConsentAsked, jt as SocketUrl, k as ConnectionName, kt as SignInDestination, l as ApprovalState, lt as ProjectName, mt as RepoName, n as AgentPermissionChoice, nt as PasskeyCreated, o as ApiOrigin, ot as PasskeyRequestOptions, p as Authorization, q as MirrorChoice, r as AgentPermissionSetting, rt as PasskeyCreationOptions, s as ApprovalId, st as PreviewEcho, t as AgentHandle, tt as PasskeyAsserted, u as ApprovalView, ut as ProjectTrackMessage, w as ConnectableAgent, wn as WorkflowPreview, wt as ScopeAction, x as ClientGranted, zn as isRef0Path, zt as TrackThread } from "./index-Dns8tCkT.mjs";
+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 { 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 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, 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 };
 //# sourceMappingURL=client.d.mts.map

package/dist/client.mjs

@@ -3353,14 +3353,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,30 +6416,29 @@ 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.
+* 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.
 */
 const RequestAttachment = Schema.Struct({
-	owner: OwnerName,
 	machine: MachineId,
 	machineName: MachineName,
 	harness: Schema.optionalKey(ConnectHarness),
 	secretHash: SecretHash,
-	collectHash: SecretHash
+	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}$/))
+	}))
 });
 /** An attachment request, as its person reads it once they type its code. */
 const AttachmentRequestView = Schema.Struct({
@@ -6776,7 +6771,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
@@ -6846,6 +6841,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 +6872,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 +6891,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 +10670,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 +10708,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 +10736,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 +10747,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 +11686,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
@@ -14870,12 +14962,14 @@ 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({ answerCode: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(64))) }),
 	headers: idempotency,
 	success: RequestConfirmed,
 	error: [AttachmentNotFound, AuthorityUnavailable]
@@ -14925,7 +15019,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 +15248,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 +15379,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 +16970,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",

package/dist/{index-Dns8tCkT.d.mts → index-CJGX88qF.d.mts}

@@ -434,6 +434,32 @@ declare const ApprovalState: Schema.Union<readonly [Schema.Struct<{
   readonly endpoint: Schema.String;
 }>]>;
 type ApprovalState = typeof ApprovalState.Type;
+/** Only the answering browser receives a machine's answer code; state reads never carry it. */
+declare const ApprovalAnswer: Schema.Union<readonly [Schema.Struct<{
+  readonly state: Schema.Literal<"approved">;
+  readonly answerCode: Schema.String;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly state: Schema.Literal<"ran">;
+  readonly endpoint: Schema.String;
+  readonly answerCode: Schema.String;
+}>, Schema.Union<readonly [Schema.Struct<{
+  readonly state: Schema.Literal<"waiting">;
+  readonly expiresAt: Schema.DateTimeUtcFromString;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"approved">;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"refused">;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"expired">;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly state: Schema.Literal<"ran">;
+  readonly endpoint: Schema.String;
+}>]>]>;
+type ApprovalAnswer = typeof ApprovalAnswer.Type;
 declare const ApprovalNotFound_base: Schema.Class<ApprovalNotFound, Schema.TaggedStruct<"ApprovalNotFound", {
   readonly nextStep: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -1144,6 +1170,52 @@ type ApprovalId = typeof ApprovalId.Type;
  */
 declare const ConnectionId: Schema.brand<Schema.TemplateLiteral<readonly ["connection_", Schema.String]>, "ConnectionId">;
 type ConnectionId = typeof ConnectionId.Type;
+declare const RepoNotReady_base: Schema.Class<RepoNotReady, Schema.TaggedStruct<"RepoNotReady", {
+  readonly nextStep: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A repo whose baseline isn't readable yet: Git is told to try again in a few seconds. */
+declare class RepoNotReady extends RepoNotReady_base {}
+/** An owner's name, a person's or an organization's. One set of names for both, as on GitHub. */
+declare const OwnerName: Schema.brand<Schema.String, "OwnerName">;
+type OwnerName = typeof OwnerName.Type;
+/** A project's name. It shares one set of names with its owner's repos. */
+declare const ProjectName: Schema.brand<Schema.String, "ProjectName">;
+type ProjectName = typeof ProjectName.Type;
+declare const RepoName: Schema.brand<Schema.String, "RepoName">;
+type RepoName = typeof RepoName.Type;
+/** An agent's handle: unique within its owner, renamable, and always shown with whose it is. */
+declare const AgentHandle: Schema.brand<Schema.String, "AgentHandle">;
+type AgentHandle = typeof AgentHandle.Type;
+//#endregion
+//#region src/routes.d.ts
+/**
+ * ref0's one origin, as a client is given it: `http` or `https`, a host and maybe a port, and no
+ * credentials, path, query or fragment. That pattern alone lets through a host or port no URL has,
+ * such as `https://1.2.3.999`, `https://[1::2::3]` or `https://ref0.test:99999`, so the platform's own URL parser must take
+ * it too. It's kept as written, case and any default port too: every path here is appended to it
+ * as it is.
+ */
+declare const ApiOrigin: Schema.brand<Schema.String, "ApiOrigin">;
+type ApiOrigin = typeof ApiOrigin.Type;
+/**
+ * Whether a path is Worker "server"'s to answer, not a page's: the API's, signing in's, a
+ * connection's webhook, or OAuth's metadata.
+ */
+declare const isRef0Path: (pathname: string) => boolean;
+declare const NoFork_base: Schema.Class<NoFork, Schema.TaggedStruct<"NoFork", {
+  readonly nextStep: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** No fork of this repo for that session: it hasn't asked for one. */
+declare class NoFork extends NoFork_base {}
+declare const NoBase_base: Schema.Class<NoBase, Schema.TaggedStruct<"NoBase", {
+  readonly why: Schema.Literals<readonly ["main empty", "held by a run"]>;
+  readonly nextStep: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * 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.
+ */
+declare class NoBase extends NoBase_base {}
 declare const PullRequestNotFound_base: Schema.Class<PullRequestNotFound, Schema.TaggedStruct<"PullRequestNotFound", {
   readonly nextStep: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -1408,11 +1480,6 @@ declare const AuthorizationNotFound_base: Schema.Class<AuthorizationNotFound, Sc
 }>, import("effect/Cause").YieldableError>;
 /** No such authorization: the attachment was never authorized here. */
 declare class AuthorizationNotFound extends AuthorizationNotFound_base {}
-declare const RepoNotReady_base: Schema.Class<RepoNotReady, Schema.TaggedStruct<"RepoNotReady", {
-  readonly nextStep: Schema.String;
-}>, import("effect/Cause").YieldableError>;
-/** A repo whose baseline isn't readable yet: Git is told to try again in a few seconds. */
-declare class RepoNotReady extends RepoNotReady_base {}
 declare const IntentSourceNotFound_base: Schema.Class<IntentSourceNotFound, Schema.TaggedStruct<"IntentSourceNotFound", {
   readonly nextStep: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -1433,17 +1500,6 @@ declare const CommentRecipientNotFound_base: Schema.Class<CommentRecipientNotFou
 }>, import("effect/Cause").YieldableError>;
 /** A session a comment is to that isn't one of this thread's. */
 declare class CommentRecipientNotFound extends CommentRecipientNotFound_base {}
-/** An owner's name, a person's or an organization's. One set of names for both, as on GitHub. */
-declare const OwnerName: Schema.brand<Schema.String, "OwnerName">;
-type OwnerName = typeof OwnerName.Type;
-/** A project's name. It shares one set of names with its owner's repos. */
-declare const ProjectName: Schema.brand<Schema.String, "ProjectName">;
-type ProjectName = typeof ProjectName.Type;
-declare const RepoName: Schema.brand<Schema.String, "RepoName">;
-type RepoName = typeof RepoName.Type;
-/** An agent's handle: unique within its owner, renamable, and always shown with whose it is. */
-declare const AgentHandle: Schema.brand<Schema.String, "AgentHandle">;
-type AgentHandle = typeof AgentHandle.Type;
 //#endregion
 //#region src/repos.d.ts
 /**
@@ -1921,7 +1977,15 @@ declare const PasskeysGroup_base: HttpApiGroup.HttpApiGroup<"passkeys", HttpApiE
   }>>;
   readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
   readonly attestation: Schema.optionalKey<Schema.Literals<readonly ["direct", "enterprise", "indirect", "none"]>>;
-}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enrolFirst", "POST", "/v1/me/passkeys/first", never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/me/passkeys", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly passkeys: Schema.$Array<Schema.Struct<{
+    readonly passkey: Schema.brand<Schema.TemplateLiteral<readonly ["passkey_", Schema.String]>, "PasskeyId">;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly backedUp: Schema.Boolean;
+  }>>;
+  readonly approvesHere: Schema.Boolean;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enrolFirst", "POST", "/v1/me/passkeys/first", never, never, Schema.toCodecJson<Schema.Struct<{
   readonly id: Schema.String;
   readonly rawId: Schema.String;
   readonly type: Schema.Literal<"public-key">;
@@ -1943,15 +2007,7 @@ declare const PasskeysGroup_base: HttpApiGroup.HttpApiGroup<"passkeys", HttpApiE
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly passkey: Schema.brand<Schema.TemplateLiteral<readonly ["passkey_", Schema.String]>, "PasskeyId">;
-}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/me/passkeys", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly passkeys: Schema.$Array<Schema.Struct<{
-    readonly passkey: Schema.brand<Schema.TemplateLiteral<readonly ["passkey_", Schema.String]>, "PasskeyId">;
-    readonly name: Schema.optionalKey<Schema.String>;
-    readonly createdAt: Schema.String;
-    readonly backedUp: Schema.Boolean;
-  }>>;
-  readonly approvesHere: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never>, false>;
+}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never>, false>;
 /**
  * A person's passkeys: listing them, and enrolling the first, which signing in asks for straight
  * away and a browser session does on its own, once. Every passkey after is an approval.
@@ -2063,9 +2119,11 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
   readonly state: Schema.Literal<"failed">;
   readonly reason: Schema.Literals<readonly ["agent not found", "agent turned off", "agent changed", "handle taken", "session ended", "recovered", "not confirmed"]>;
   readonly nextStep: Schema.String;
-}>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"collect", "GET", "/v1/attachments/requests/:approval/result", Schema.toCodecStringTree<Schema.Struct<{
+}>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"collect", "POST", "/v1/attachments/requests/:approval/result", Schema.toCodecStringTree<Schema.Struct<{
   approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-}>>, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly answerCode: Schema.optionalKey<Schema.String>;
+}>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly state: Schema.Literal<"waiting">;
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
@@ -2097,17 +2155,23 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
   readonly nextStep: Schema.String;
 }>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"confirm", "POST", "/v1/attachments/requests/:approval/collected", Schema.toCodecStringTree<Schema.Struct<{
   approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly answerCode: Schema.optionalKey<Schema.String>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly confirmed: Schema.Boolean;
 }>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"request", "POST", "/v1/attachments/requests", never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly owner: Schema.brand<Schema.String, "OwnerName">;
   readonly machine: Schema.brand<Schema.TemplateLiteral<readonly ["machine_", Schema.String]>, "MachineId">;
   readonly machineName: Schema.String;
   readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
   readonly secretHash: Schema.brand<Schema.String, "SecretHash">;
   readonly collectHash: Schema.brand<Schema.String, "SecretHash">;
+  readonly linkHash: Schema.brand<Schema.String, "SecretHash">;
+  readonly callback: Schema.optionalKey<Schema.Struct<{
+    readonly port: Schema.Int;
+    readonly state: Schema.String;
+  }>>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
@@ -2366,9 +2430,11 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
     readonly askedAt: Schema.DateTimeUtcFromString;
     readonly expiresAt: Schema.DateTimeUtcFromString;
   }>>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"find", "POST", "/v1/approvals/find", never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"find", "POST", "/v1/approvals/find", never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly code: Schema.String;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
+}>, Schema.Struct<{
+  readonly link: Schema.String;
+}>]>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
@@ -2727,6 +2793,15 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
 }>]>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly state: Schema.Literal<"approved">;
+  readonly answerCode: Schema.String;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly state: Schema.Literal<"ran">;
+  readonly endpoint: Schema.String;
+  readonly answerCode: Schema.String;
+}>, Schema.Union<readonly [Schema.Struct<{
   readonly state: Schema.Literal<"waiting">;
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
@@ -2740,7 +2815,7 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
   readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
   readonly state: Schema.Literal<"ran">;
   readonly endpoint: Schema.String;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ApprovalStale | typeof PreviewNotReady | typeof PasskeyRefused | typeof ApprovalNotFound>, Authorization, never>, false>;
+}>]>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ApprovalStale | typeof PreviewNotReady | typeof PasskeyRefused | typeof ApprovalNotFound>, Authorization, never>, false>;
 /**
  * A person's side of approvals, in an approving browser: what waits for them, finding a
  * terminal's request or a machine's attachment request by its code, and answering one, with
@@ -4343,7 +4418,18 @@ declare const OrgThreadsGroup_base: HttpApiGroup.HttpApiGroup<"orgThreads", Http
  * endpoint but the list, which is the owner's, `ownerThreads.list`.
  */
 declare class OrgThreadsGroup extends OrgThreadsGroup_base {}
-declare const SessionsGroup_base: HttpApiGroup.HttpApiGroup<"sessions", HttpApiEndpoint.HttpApiEndpoint<"blockers", "GET", "/v1/sessions/:session/blockers", Schema.toCodecStringTree<Schema.Struct<{
+declare const SessionsGroup_base: HttpApiGroup.HttpApiGroup<"sessions", HttpApiEndpoint.HttpApiEndpoint<"base", "GET", "/v1/sessions/:session/repos/:repo/base", Schema.toCodecStringTree<Schema.Struct<{
+  session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly on: Schema.Union<readonly [Schema.Literal<"main">, Schema.Struct<{
+    readonly thread: Schema.Int;
+  }>]>;
+  readonly commit: Schema.brand<Schema.String, "CommitOid">;
+  readonly path: Schema.String;
+  readonly url: Schema.String;
+  readonly ref: Schema.Literal<"refs/heads/main">;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof RepoNotFound | typeof RepoNotReady | typeof NoFork | typeof NoBase>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"blockers", "GET", "/v1/sessions/:session/blockers", Schema.toCodecStringTree<Schema.Struct<{
   session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   wait: Schema.optionalKey<Schema.Int>;
@@ -4801,6 +4887,7 @@ declare const SessionsGroup_base: HttpApiGroup.HttpApiGroup<"sessions", HttpApiE
     readonly generation: Schema.Int;
     readonly counter: Schema.Int;
   }>;
+  readonly reserved: Schema.optionalKey<Schema.Int>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
   readonly attempts: Schema.$Array<Schema.Struct<{
     readonly key: Schema.Union<readonly [Schema.Struct<{
@@ -4822,6 +4909,7 @@ declare const SessionsGroup_base: HttpApiGroup.HttpApiGroup<"sessions", HttpApiE
     readonly mayRepeat: Schema.Boolean;
   }>>;
   readonly left: Schema.Int;
+  readonly reservedKept: Schema.Boolean;
 }>>, Schema.toCodecJson<typeof NotPermitted | typeof TakeRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"tasks", "PUT", "/v1/sessions/:session/tasks", Schema.toCodecStringTree<Schema.Struct<{
   session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
@@ -19965,7 +20053,7 @@ interface GateOwn {
  * `[]` for a check other code calls or people run by hand. Whether any other start may make a new
  * run is its start rule's.
  */
-declare const CheckOn: Schema.$Array<Schema.Literals<readonly ["change", "tip", "deployed"]>>;
+declare const CheckOn: Schema.$Array<Schema.Literals<readonly ["change", "tip"]>>;
 type CheckOn = typeof CheckOn.Type;
 /** A sandbox's size, each Cloudflare's instance type: `standard-1` unless its file says. */
 declare const SandboxSize: Schema.Literals<readonly ["standard-1", "standard-2", "standard-4"]>;
@@ -27115,22 +27203,6 @@ declare const ReadEvent: Schema.Union<readonly [Schema.Union<readonly [Schema.St
   readonly kind: Schema.String;
 }>]>;
 type ReadEvent = typeof ReadEvent.Type;
-//#endregion
-//#region src/routes.d.ts
-/**
- * ref0's one origin, as a client is given it: `http` or `https`, a host and maybe a port, and no
- * credentials, path, query or fragment. That pattern alone lets through a host or port no URL has,
- * such as `https://1.2.3.999`, `https://[1::2::3]` or `https://ref0.test:99999`, so the platform's own URL parser must take
- * it too. It's kept as written, case and any default port too: every path here is appended to it
- * as it is.
- */
-declare const ApiOrigin: Schema.brand<Schema.String, "ApiOrigin">;
-type ApiOrigin = typeof ApiOrigin.Type;
-/**
- * Whether a path is Worker "server"'s to answer, not a page's: the API's, signing in's, a
- * connection's webhook, or OAuth's metadata.
- */
-declare const isRef0Path: (pathname: string) => boolean;
 /**
  * A track as its socket's URL names it: `session:<session>`, `owner:<owner>`, and so on. Any
  * string crosses the wire as one; `trackFromName` says whether it names a track.
@@ -28909,5 +28981,5 @@ declare const SandboxExecAnswer: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 type SandboxExecAnswer = typeof SandboxExecAnswer.Type;
 //#endregion
-export { OwnerThreadView as $, WorkflowCallRefused as $t, ConnectionView as A, WorkflowText as An, SignedIn as At, GetIssueInput as B, liveSocketUrl as Bn, TypedApprovalCode as Bt, ConnectChosen as C, WorkflowPermissions as Cn, SandboxSize as Ct, ConnectionChanged as D, WorkflowRequestRefusal as Dn, SentryRegion as Dt, ConnectionCallAnswer as E, WorkflowPullRequestOpen as En, SentryOrg as Et, EndpointName as F, connectEndpoint as Fn, ThreadId as Ft, LiveTrackName as G, WorkflowAnswerer as Gt, ImportFailure as H, repoNameKey as Hn, Welcome as Ht, EventRunInput as I, encodeSecret as In, ThreadStage as It, MirrorEntry as J, WorkflowCall as Jt, MachineConnected as K, WorkflowAsk as Kt, ForkAnswer as L, hookTokenPrefix as Ln, TrackClosed as Lt, ConsentClient as M, WorkflowTrigger as Mn, StartActor as Mt, ConsentProject as N, WrittenProject as Nn, StartRun as Nt, ConnectionKind as O, WorkflowStartEnded as On, SentryToken as Ot, CredentialView as P, commandLine as Pn, StatementView as Pt, OwnerThreadPage as Q, WorkflowCallRefusal as Qt, ForkCreate as R, hookUrl as Rn, TrackSession as Rt, ConnectAgent as S, WorkflowPasskeyState as Sn, SandboxPushAnswer as St, ConnectionCall as T, WorkflowPullRequestAnswer as Tn, SecretHash as Tt, LiveTicket as U, surfaceOf as Un, WorkflowAction as Ut, Harness as V, projectParts as Vn, VersionFile as Vt, LiveTicketRequest as W, WorkflowActionAnswer as Wt, OwnerId as X, WorkflowCallEnded as Xt, MirrorView as Y, WorkflowCallAnswer as Yt, OwnerName as Z, WorkflowCallInput as Zt, CheckRunError as _, WorkflowOwn as _n, SandboxExec as _t, Api as a, WorkflowCheckResultsAnswer as an, PasskeyRefusal as at, ClientAccess as b, WorkflowPasskeyEnded as bn, SandboxOpenAnswer as bt, ApprovalPreview as c, WorkflowCheckStart as cn, PreviewUnavailable as ct, AttachmentFailed as d, WorkflowCheckStatesAnswer as dn, RanOf as dt, WorkflowCalledState as en, OwnerTrackMessage as et, AttachmentRequestView as f, WorkflowCheckWhere as fn, ReadEvent as ft, CheckOwn as g, WorkflowFilters as gn, RepoView as gt, CheckOn as h, WorkflowEvent as hn, RepoUrl as ht, AgentView as i, WorkflowCheckResults as in, PasskeyFrom as it, ConsentAsked as j, WorkflowThreadStart as jn, SocketUrl as jt, ConnectionName as k, WorkflowStartState as kn, SignInDestination as kt, ApprovalState as l, WorkflowCheckStartAnswer as ln, ProjectName as lt, ChangeAuthor as m, WorkflowConnections as mn, RepoName as mt, AgentPermissionChoice as n, WorkflowCheckRefusal as nn, PasskeyCreated as nt, ApiOrigin as o, WorkflowCheckRun as on, PasskeyRequestOptions as ot, Authorization as p, WorkflowComment as pn, Ref0Owned as pt, MirrorChoice as q, WorkflowAskClosed as qt, AgentPermissionSetting as r, WorkflowCheckRefused as rn, PasskeyCreationOptions as rt, ApprovalId as s, WorkflowCheckRunEnded as sn, PreviewEcho as st, AgentHandle as t, WorkflowCalledStateAnswer as tn, PasskeyAsserted as tt, ApprovalView as u, WorkflowCheckStates as un, ProjectTrackMessage as ut, CheckRunParams as v, WorkflowPasskeyAsk as vn, SandboxExecAnswer as vt, ConnectableAgent as w, WorkflowPreview as wn, ScopeAction as wt, ClientGranted as x, WorkflowPasskeyRead as xn, SandboxPush as xt, CheckTreeEntry as y, WorkflowPasskeyAsked as yn, SandboxOpen as yt, GateOwn as z, isRef0Path as zn, TrackThread as zt };
-//# sourceMappingURL=index-Dns8tCkT.d.mts.map
+export { OwnerThreadPage as $, WorkflowCallRefusal as $t, ConnectionName as A, WorkflowStartState as An, SignInDestination as At, GateOwn as B, isRef0Path as Bn, TrackThread as Bt, ConnectAgent as C, WorkflowPasskeyState as Cn, SandboxPushAnswer as Ct, ConnectionCallAnswer as D, WorkflowPullRequestOpen as Dn, SentryOrg as Dt, ConnectionCall as E, WorkflowPullRequestAnswer as En, SecretHash as Et, CredentialView as F, commandLine as Fn, StatementView as Ft, LiveTicketRequest as G, WorkflowActionAnswer as Gt, Harness as H, projectParts as Hn, VersionFile as Ht, EndpointName as I, connectEndpoint as In, ThreadId as It, MirrorChoice as J, WorkflowAskClosed as Jt, LiveTrackName as K, WorkflowAnswerer as Kt, EventRunInput as L, encodeSecret as Ln, ThreadStage as Lt, ConsentAsked as M, WorkflowThreadStart as Mn, SocketUrl as Mt, ConsentClient as N, WorkflowTrigger as Nn, StartActor as Nt, ConnectionChanged as O, WorkflowRequestRefusal as On, SentryRegion as Ot, ConsentProject as P, WrittenProject as Pn, StartRun as Pt, OwnerName as Q, WorkflowCallInput as Qt, ForkAnswer as R, hookTokenPrefix as Rn, TrackClosed as Rt, ClientGranted as S, WorkflowPasskeyRead as Sn, SandboxPush as St, ConnectableAgent as T, WorkflowPreview as Tn, ScopeAction as Tt, ImportFailure as U, repoNameKey as Un, Welcome as Ut, GetIssueInput as V, liveSocketUrl as Vn, TypedApprovalCode as Vt, LiveTicket as W, surfaceOf as Wn, WorkflowAction as Wt, MirrorView as X, WorkflowCallAnswer as Xt, MirrorEntry as Y, WorkflowCall as Yt, OwnerId as Z, WorkflowCallEnded as Zt, CheckOwn as _, WorkflowFilters as _n, RepoView as _t, Api as a, WorkflowCheckResults as an, PasskeyFrom as at, CheckTreeEntry as b, WorkflowPasskeyAsked as bn, SandboxOpen as bt, ApprovalId as c, WorkflowCheckRunEnded as cn, PreviewEcho as ct, ApprovalView as d, WorkflowCheckStates as dn, ProjectTrackMessage as dt, WorkflowCallRefused as en, OwnerThreadView as et, AttachmentFailed as f, WorkflowCheckStatesAnswer as fn, RanOf as ft, CheckOn as g, WorkflowEvent as gn, RepoUrl as gt, ChangeAuthor as h, WorkflowConnections as hn, RepoName as ht, AgentView as i, WorkflowCheckRefused as in, PasskeyCreationOptions as it, ConnectionView as j, WorkflowText as jn, SignedIn as jt, ConnectionKind as k, WorkflowStartEnded as kn, SentryToken as kt, ApprovalPreview as l, WorkflowCheckStart as ln, PreviewUnavailable as lt, Authorization as m, WorkflowComment as mn, Ref0Owned as mt, AgentPermissionChoice as n, WorkflowCalledStateAnswer as nn, PasskeyAsserted as nt, ApiOrigin as o, WorkflowCheckResultsAnswer as on, PasskeyRefusal as ot, AttachmentRequestView as p, WorkflowCheckWhere as pn, ReadEvent as pt, MachineConnected as q, WorkflowAsk as qt, AgentPermissionSetting as r, WorkflowCheckRefusal as rn, PasskeyCreated as rt, ApprovalAnswer as s, WorkflowCheckRun as sn, PasskeyRequestOptions as st, AgentHandle as t, WorkflowCalledState as tn, OwnerTrackMessage as tt, ApprovalState as u, WorkflowCheckStartAnswer as un, ProjectName as ut, CheckRunError as v, WorkflowOwn as vn, SandboxExec as vt, ConnectChosen as w, WorkflowPermissions as wn, SandboxSize as wt, ClientAccess as x, WorkflowPasskeyEnded as xn, SandboxOpenAnswer as xt, CheckRunParams as y, WorkflowPasskeyAsk as yn, SandboxExecAnswer as yt, ForkCreate as z, hookUrl as zn, TrackSession as zt };
+//# sourceMappingURL=index-CJGX88qF.d.mts.map

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { An as WorkflowText, Ct as SandboxSize, Dn as WorkflowRequestRefusal, Gt as WorkflowAnswerer, Kt as WorkflowAsk, St as SandboxPushAnswer, Vt as VersionFile, at as PasskeyRefusal, it as PasskeyFrom$1, m as ChangeAuthor, pt as Ref0Owned, qt as WorkflowAskClosed, z as GateOwn } from "./index-Dns8tCkT.mjs";
-import { $ as StartActor, A as ForkOptions, B as WorkflowContext, C as Comment, D as EventWorkflow, E as EventOf, F as StepConfig, G as CalledWorkflow, H as text, I as StepContext, J as TreeEntry, K as JsonValue, L as ThreadStart, M as PullRequestAnswer, N as PullRequestOptions, O as EventWorkflowSpec, P as Ref0Actions, Q as Refusal, R as WaitType, S as CheckRunEnded, T as Duration, U as workflow, V as WorkflowStep, W as CalledRunFailed, X as Allow, Y as TreeRead, Z as CalledRun, _ as ActionAnswer, a as CheckRunOptions, at as allow, b as CalledContext, c as CheckRunResult, ct as Need, d as OneOfValues, et as StartContext, f as OutputResult, g as oneOf, h as check, i as CheckResult, it as StartRun, j as NeedAddOptions, k as ForkAnswer, l as CheckSpec, m as Step, n as Check, nt as StartOutput, o as CheckRunReference, ot as refuse, p as OutputSchema, q as Tree, r as CheckContext, rt as StartRule, s as CheckRunRefused, st as CheckNeed, t as Browser, tt as StartItem, u as DurationText, v as CallAnswer, w as ConnectionsOf, x as CalledWorkflowSpec, y as CallEnded, z as WaitedEvent } from "./browse-DBqoeS-u.mjs";
+import { B as GateOwn, Ct as SandboxPushAnswer, Ht as VersionFile, Jt as WorkflowAskClosed, Kt as WorkflowAnswerer, On as WorkflowRequestRefusal, at as PasskeyFrom$1, h as ChangeAuthor, jn as WorkflowText, mt as Ref0Owned, ot as PasskeyRefusal, qt as WorkflowAsk, wt as SandboxSize } from "./index-CJGX88qF.mjs";
+import { $ as StartActor, A as ForkOptions, B as WorkflowContext, C as Comment, D as EventWorkflow, E as EventOf, F as StepConfig, G as CalledWorkflow, H as text, I as StepContext, J as TreeEntry, K as JsonValue, L as ThreadStart, M as PullRequestAnswer, N as PullRequestOptions, O as EventWorkflowSpec, P as Ref0Actions, Q as Refusal, R as WaitType, S as CheckRunEnded, T as Duration, U as workflow, V as WorkflowStep, W as CalledRunFailed, X as Allow, Y as TreeRead, Z as CalledRun, _ as ActionAnswer, a as CheckRunOptions, at as allow, b as CalledContext, c as CheckRunResult, ct as Need, d as OneOfValues, et as StartContext, f as OutputResult, g as oneOf, h as check, i as CheckResult, it as StartRun, j as NeedAddOptions, k as ForkAnswer, l as CheckSpec, m as Step, n as Check, nt as StartOutput, o as CheckRunReference, ot as refuse, p as OutputSchema, q as Tree, r as CheckContext, rt as StartRule, s as CheckRunRefused, st as CheckNeed, t as Browser, tt as StartItem, u as DurationText, v as CallAnswer, w as ConnectionsOf, x as CalledWorkflowSpec, y as CallEnded, z as WaitedEvent } from "./browse-DHgV6DTF.mjs";
 //#region src/ask.d.ts
 /**
  * `ask`, ref0's leaf that asks someone a question and waits in the run for the answer, as a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ref0/sdk",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "What a repo's .ref0/ code imports to run on ref0, and ref0's HTTP client",
   "license": "Apache-2.0",
   "repository": {