@runuai/host 0.9.148 → 0.9.150

package/src/protocol.ts

@@ -128,6 +128,2192 @@ export const HOST_ENGINE_ACCOUNT_SCOPES_PROTOCOL_FEATURE =
  * unrelated respawn and never stops a removed one, so the cloud refuses to
  * edit or remove a running task's agents on it. */
 export const LIVE_ROSTER_EDIT_PROTOCOL_FEATURE = "live-roster-edit-v1";
+/** ADR-153 declarations + owner bindings. Advertising this means the host
+ * understands every additive env frame field, persists bindings separately
+ * from values, and reports immutable repository schema observations. Keep it
+ * out of buildCapabilities until that whole contract is wired end to end. */
+export const PROJECT_ENV_BINDINGS_PROTOCOL_FEATURE =
+  "project-env-bindings-v1";
+
+/** Existing env writes are bounded by a 512 KiB raw request, not a smaller
+ * key-specific cap. Keep the additive binding ack able to describe any key
+ * the current API can already have stored. */
+export const MAX_PROJECT_ENV_KEY_CHARS = 512 * 1024;
+export const MAX_PROJECT_ENV_PROJECT_ID_CHARS = 128;
+export const MAX_PROJECT_ENV_SCHEMA_DECLARATIONS = 256;
+export const MAX_PROJECT_ENV_SCHEMA_ISSUES =
+  MAX_PROJECT_ENV_SCHEMA_DECLARATIONS + 16;
+export const MAX_PROJECT_ENV_SCHEMA_REPORTS = 256;
+export const MAX_PROJECT_ENV_PROXY_DOMAINS = 16;
+export const MAX_PROJECT_ENV_REASON_CODE_CHARS = 64;
+export const MAX_PROJECT_ENV_TYPE_CHARS = 128;
+export const MAX_PROJECT_ENV_PLACEHOLDER_CHARS = 256;
+/** Modern inventory pages stay well below the authenticated bridge's 100 MiB
+ * frame ceiling. A page builder measures the complete encoded frame and must
+ * still return at least one record when any remain. */
+export const MAX_PROJECT_ENV_PAGE_BYTES = 8 * 1024 * 1024;
+/** Kept as the explicit owned-runner ack bound for callers already using it. */
+export const MAX_PROJECT_ENV_ACK_PAGE_BYTES = MAX_PROJECT_ENV_PAGE_BYTES;
+export const MAX_PROJECT_ENV_POLICY_EPOCHS = 64;
+/** The one epoch a pre-record value can be migrated under in bindings-v1. */
+export const INITIAL_PROJECT_ENV_POLICY_EPOCH = 1;
+/**
+ * Highest schema-observation interpretation this build understands.
+ *
+ * Bump this for any change to parser, reader, or commit-metadata semantics.
+ * The wire guard accepts every historical positive epoch through this value,
+ * but rejects a future epoch until this peer knows how to interpret it.
+ */
+export const CURRENT_PROJECT_ENV_PARSER_EPOCH = 1;
+
+export const PROJECT_ENV_UNSUPPORTED_REASON_CODES = [
+  "malformed",
+  "invalid_value",
+  "conflicting_forms",
+  "missing_domain",
+  "option_path",
+  "option_method",
+  "option_block",
+  "option_keys",
+  "option_substitute_in",
+  "option_transform",
+  "option_approval",
+  "option_rules",
+  "option_unknown",
+  "wildcard_domain",
+  "ip_literal",
+  "localhost",
+  "reserved_domain",
+  "invalid_domain",
+  "too_many_domains",
+  "header_rule",
+  "duplicate_key",
+] as const;
+export const PROJECT_ENV_SCHEMA_ISSUE_CODES = [
+  "header_proxy_rule",
+  "proxy_config",
+  "placeholder_ignored",
+] as const;
+/** Unavailable reasons from a runner that never reached the commit's
+ * schema: they say nothing about it, so they carry no commit (ADR-153 §4,
+ * "The latest observation"). */
+export const PROJECT_ENV_SCHEMA_UNREACHED_REASON_CODES = [
+  "base_commit_missing",
+  "schema_read_failed",
+] as const;
+/** Unavailable reasons from a runner that read the commit's schema and could
+ * not interpret it: a verdict about that commit, so they carry it. */
+export const PROJECT_ENV_SCHEMA_UNREADABLE_REASON_CODES = [
+  "schema_not_regular_file",
+  "schema_too_large",
+  "schema_too_many_declarations",
+  "schema_unterminated_value",
+  "schema_not_text",
+  "schema_malformed",
+] as const;
+export const PROJECT_ENV_SCHEMA_UNAVAILABLE_REASON_CODES = [
+  ...PROJECT_ENV_SCHEMA_UNREACHED_REASON_CODES,
+  ...PROJECT_ENV_SCHEMA_UNREADABLE_REASON_CODES,
+] as const;
+
+/** Reason and issue codes are lower-case snake_case on the wire. They remain
+ * open strings so a newer peer can explain a fail-closed state to an older
+ * one without making the whole observation unreadable. */
+export type KnownProjectEnvUnsupportedReason =
+  (typeof PROJECT_ENV_UNSUPPORTED_REASON_CODES)[number];
+export type KnownProjectEnvSchemaIssueCode =
+  (typeof PROJECT_ENV_SCHEMA_ISSUE_CODES)[number];
+export type KnownProjectEnvSchemaUnavailableReason =
+  (typeof PROJECT_ENV_SCHEMA_UNAVAILABLE_REASON_CODES)[number];
+export type ProjectEnvUnsupportedReason = string;
+export type ProjectEnvSchemaUnavailableReason = string;
+export type ProjectEnvSchemaIssueCode = string;
+export type ProjectEnvWithholdReason = string;
+
+/** What one repository declaration asks Uai to do with a stored value. */
+export type ProjectEnvDirective =
+  | { kind: "none" }
+  | { kind: "proxy"; domains: string[] }
+  | { kind: "passthrough" }
+  | { kind: "omit" }
+  | { kind: "unsupported"; reason: ProjectEnvUnsupportedReason };
+
+/** Cloud-safe declaration captured from a trusted `.env.schema` base.
+ * `placeholder` is a shape only: the repository's literal never crosses the
+ * bridge and is never used as a task placeholder. */
+export interface ProjectEnvSchemaDeclaration {
+  key: string;
+  required: boolean;
+  sensitive: boolean;
+  type?: string;
+  directive: ProjectEnvDirective;
+  placeholder?: {
+    prefix: string;
+    totalLength: number;
+  };
+}
+
+/** A schema condition that cannot be represented on the declaration itself.
+ * Missing `key` means project-wide. */
+export interface ProjectEnvSchemaIssue {
+  code: ProjectEnvSchemaIssueCode;
+  key?: string;
+}
+
+/** One immutable observation per task/project. OID and commit time are a
+ * coherent pair: both identify the commit reached, or both are null for a
+ * proven-empty repository or a failure before reaching a commit. An unreadable
+ * base is unavailable, never a resolved empty schema. */
+export type ProjectEnvSchemaObservation =
+  | {
+      projectId: string;
+      status: "resolved";
+      parserEpoch: number;
+      baseOid: string | null;
+      baseCommitTimeMs: number | null;
+      declarations: ProjectEnvSchemaDeclaration[];
+      issues: ProjectEnvSchemaIssue[];
+    }
+  | {
+      projectId: string;
+      status: "unavailable";
+      parserEpoch: number;
+      baseOid: string | null;
+      baseCommitTimeMs: number | null;
+      reason: ProjectEnvSchemaUnavailableReason;
+    };
+
+/** Wire/report synonym: the host's durable observation is what task-up
+ * reports to the cloud. */
+export type ProjectEnvSchemaReport = ProjectEnvSchemaObservation;
+
+/** The most permissive policy the owner has approved for one stored value. */
+export type ProjectEnvBinding =
+  | { kind: "proxy"; domains: string[] }
+  | { kind: "passthrough" }
+  | { kind: "omit" }
+  | { kind: "withhold"; reason: ProjectEnvWithholdReason };
+
+/** A modern host reports every record of the project, tombstones and fences
+ * included (ADR-153 §4, "Where bindings live" and "Protocol"): the record's
+ * head, its binding (null: none), the policy epoch that was written under,
+ * and the highest listing generation a change to it carried. The record
+ * outlives its value, so a stale compare-and-swap cannot match a re-created
+ * one. A fence has never held a value: its head is `r1, g0`, with no binding
+ * and no epoch. A legacy host omits the whole bindings field rather than
+ * manufacturing these entries. */
+export interface ProjectEnvBindingState {
+  key: string;
+  head: ProjectEnvHead;
+  binding: ProjectEnvBinding | null;
+  /** Null exactly for a fence. */
+  policyEpoch: number | null;
+  listingGeneration: number;
+}
+
+const PROJECT_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const PROJECT_ENV_REASON_RE = /^[a-z][a-z0-9_]{0,63}$/;
+const PROJECT_ENV_OID_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+const PROJECT_ENV_DOMAIN_LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+const PROJECT_ENV_PLACEHOLDER_PREFIX_RE = /^(?:[A-Za-z0-9._~-]*[_-])?$/;
+const PROJECT_ENV_NEVER_PROXIED_SUFFIXES = [
+  "github.com",
+  "githubusercontent.com",
+  "runuai.com",
+  "localhost",
+] as const;
+
+function isProjectEnvKey(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_PROJECT_ENV_KEY_CHARS &&
+    PROJECT_ENV_KEY_RE.test(value)
+  );
+}
+
+function isProjectEnvProjectId(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= MAX_PROJECT_ENV_PROJECT_ID_CHARS
+  );
+}
+
+function isProjectEnvReason(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    value.length <= MAX_PROJECT_ENV_REASON_CODE_CHARS &&
+    PROJECT_ENV_REASON_RE.test(value)
+  );
+}
+
+function isProjectEnvParserEpoch(value: unknown): value is number {
+  return (
+    typeof value === "number" &&
+    Number.isSafeInteger(value) &&
+    value >= 1 &&
+    value <= CURRENT_PROJECT_ENV_PARSER_EPOCH
+  );
+}
+
+/** A canonical public DNS name that ADR-153 permits as a proxy boundary. */
+function isProjectEnvDomain(value: unknown): value is string {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > 253 ||
+    value.endsWith(".") ||
+    value !== value.toLowerCase()
+  ) {
+    return false;
+  }
+  const labels = value.split(".");
+  if (
+    labels.length < 2 ||
+    !labels.every((label) => PROJECT_ENV_DOMAIN_LABEL_RE.test(label))
+  ) {
+    return false;
+  }
+  const last = labels[labels.length - 1] ?? "";
+  if (/^[0-9]+$/.test(last) || /^0x[0-9a-f]*$/.test(last)) return false;
+  return !PROJECT_ENV_NEVER_PROXIED_SUFFIXES.some(
+    (suffix) => value === suffix || value.endsWith(`.${suffix}`),
+  );
+}
+
+function isUniqueStringArray(
+  value: unknown,
+  max: number,
+  item: (candidate: unknown) => candidate is string,
+): value is string[] {
+  return (
+    isDenseArray(value) &&
+    value.length <= max &&
+    value.every(item) &&
+    new Set(value).size === value.length
+  );
+}
+
+/** JSON arrays are dense. Reject a JavaScript hole before it becomes a null
+ * on the wire and changes the value a validator thought it approved. */
+function isDenseArray(value: unknown): value is unknown[] {
+  if (!Array.isArray(value)) return false;
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.hasOwn(value, index)) return false;
+  }
+  return true;
+}
+
+function isSortedUniqueStringArray(
+  value: unknown,
+  max: number,
+  item: (candidate: unknown) => candidate is string,
+): value is string[] {
+  return (
+    isUniqueStringArray(value, max, item) &&
+    value.every((candidate, index) => index === 0 || value[index - 1]! < candidate)
+  );
+}
+
+export function isProjectEnvKeys(value: unknown): value is string[] {
+  return (
+    isDenseArray(value) &&
+    value.every(isProjectEnvKey) &&
+    new Set(value).size === value.length
+  );
+}
+
+function hasExactlyTheSameStrings(
+  left: readonly string[],
+  right: readonly string[],
+): boolean {
+  if (left.length !== right.length) return false;
+  const rightSet = new Set(right);
+  return left.every((item) => rightSet.has(item));
+}
+
+export function isProjectEnvDirective(
+  value: unknown,
+): value is ProjectEnvDirective {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const kind = (value as { kind?: unknown }).kind;
+  if (kind === "none" || kind === "passthrough" || kind === "omit") {
+    return exactWireObject(value, ["kind"]) !== null;
+  }
+  if (kind === "proxy") {
+    const object = exactWireObject(value, ["kind", "domains"]);
+    return (
+      object !== null &&
+      isSortedUniqueStringArray(
+        object.domains,
+        MAX_PROJECT_ENV_PROXY_DOMAINS,
+        isProjectEnvDomain,
+      ) &&
+      object.domains.length > 0
+    );
+  }
+  if (kind === "unsupported") {
+    const object = exactWireObject(value, ["kind", "reason"]);
+    return object !== null && isProjectEnvReason(object.reason);
+  }
+  return false;
+}
+
+export function isProjectEnvSchemaDeclaration(
+  value: unknown,
+): value is ProjectEnvSchemaDeclaration {
+  const object = exactWireObject(
+    value,
+    ["key", "required", "sensitive", "directive"],
+    ["type", "placeholder"],
+  );
+  if (
+    object === null ||
+    !isProjectEnvKey(object.key) ||
+    typeof object.required !== "boolean" ||
+    typeof object.sensitive !== "boolean" ||
+    !isProjectEnvDirective(object.directive) ||
+    (object.directive.kind !== "none" && object.sensitive !== true) ||
+    (object.type !== undefined &&
+      (typeof object.type !== "string" ||
+        object.type.length === 0 ||
+        object.type.length > MAX_PROJECT_ENV_TYPE_CHARS ||
+        /[\u0000-\u001f\u007f]/.test(object.type)))
+  ) {
+    return false;
+  }
+  if (object.placeholder === undefined) return true;
+  if (object.directive.kind !== "proxy") return false;
+  const placeholder = exactWireObject(object.placeholder, [
+    "prefix",
+    "totalLength",
+  ]);
+  return (
+    placeholder !== null &&
+    typeof placeholder.prefix === "string" &&
+    PROJECT_ENV_PLACEHOLDER_PREFIX_RE.test(placeholder.prefix) &&
+    typeof placeholder.totalLength === "number" &&
+    Number.isSafeInteger(placeholder.totalLength) &&
+    placeholder.totalLength >= placeholder.prefix.length + 32 &&
+    placeholder.totalLength <= MAX_PROJECT_ENV_PLACEHOLDER_CHARS
+  );
+}
+
+export function isProjectEnvSchemaIssue(
+  value: unknown,
+): value is ProjectEnvSchemaIssue {
+  const object = exactWireObject(value, ["code"], ["key"]);
+  return (
+    object !== null &&
+    isProjectEnvReason(object.code) &&
+    (object.key === undefined || isProjectEnvKey(object.key))
+  );
+}
+
+export function isProjectEnvSchemaObservation(
+  value: unknown,
+): value is ProjectEnvSchemaObservation {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const status = (value as { status?: unknown }).status;
+  if (status === "unavailable") {
+    const object = exactWireObject(value, [
+      "projectId",
+      "status",
+      "parserEpoch",
+      "baseOid",
+      "baseCommitTimeMs",
+      "reason",
+    ]);
+    const emptyBase =
+      object?.baseOid === null && object.baseCommitTimeMs === null;
+    const committedBase =
+      typeof object?.baseOid === "string" &&
+      PROJECT_ENV_OID_RE.test(object.baseOid) &&
+      typeof object.baseCommitTimeMs === "number" &&
+      Number.isSafeInteger(object.baseCommitTimeMs) &&
+      object.baseCommitTimeMs >= 0;
+    // A known reason fixes which base it carries; the comparator orders a
+    // report by it. A reason this peer does not know yet is taken at its base.
+    const reason: unknown = object?.reason;
+    const coherentBase = (
+      PROJECT_ENV_SCHEMA_UNREACHED_REASON_CODES as readonly unknown[]
+    ).includes(reason)
+      ? emptyBase
+      : (PROJECT_ENV_SCHEMA_UNREADABLE_REASON_CODES as readonly unknown[]).includes(
+            reason,
+          )
+        ? committedBase
+        : emptyBase || committedBase;
+    return (
+      object !== null &&
+      isProjectEnvProjectId(object.projectId) &&
+      isProjectEnvParserEpoch(object.parserEpoch) &&
+      isProjectEnvReason(object.reason) &&
+      coherentBase
+    );
+  }
+  if (status !== "resolved") return false;
+  const object = exactWireObject(value, [
+    "projectId",
+    "status",
+    "parserEpoch",
+    "baseOid",
+    "baseCommitTimeMs",
+    "declarations",
+    "issues",
+  ]);
+  if (
+    object === null ||
+    !isProjectEnvProjectId(object.projectId) ||
+    !isProjectEnvParserEpoch(object.parserEpoch) ||
+    !isDenseArray(object.declarations) ||
+    object.declarations.length > MAX_PROJECT_ENV_SCHEMA_DECLARATIONS ||
+    !object.declarations.every(isProjectEnvSchemaDeclaration) ||
+    new Set(
+      object.declarations.map(
+        (declaration: ProjectEnvSchemaDeclaration) => declaration.key,
+      ),
+    ).size !== object.declarations.length ||
+    !isDenseArray(object.issues) ||
+    object.issues.length > MAX_PROJECT_ENV_SCHEMA_ISSUES ||
+    !object.issues.every(isProjectEnvSchemaIssue) ||
+    new Set(
+      object.issues.map(
+        (issue: ProjectEnvSchemaIssue) => `${issue.code}\u0000${issue.key ?? ""}`,
+      ),
+    ).size !== object.issues.length
+  ) {
+    return false;
+  }
+  const emptyBase = object.baseOid === null && object.baseCommitTimeMs === null;
+  const committedBase =
+    typeof object.baseOid === "string" &&
+    PROJECT_ENV_OID_RE.test(object.baseOid) &&
+    typeof object.baseCommitTimeMs === "number" &&
+    Number.isSafeInteger(object.baseCommitTimeMs) &&
+    object.baseCommitTimeMs >= 0;
+  return (
+    (emptyBase &&
+      object.declarations.length === 0 &&
+      object.issues.length === 0) ||
+    committedBase
+  );
+}
+
+export const isProjectEnvSchemaReport = isProjectEnvSchemaObservation;
+
+export function isProjectEnvSchemaObservations(
+  value: unknown,
+  projectIds?: readonly string[],
+): value is ProjectEnvSchemaObservation[] {
+  if (
+    !isDenseArray(value) ||
+    (projectIds === undefined &&
+      value.length > MAX_PROJECT_ENV_SCHEMA_REPORTS) ||
+    !value.every(isProjectEnvSchemaObservation)
+  ) {
+    return false;
+  }
+  const observedProjectIds = value.map((observation) => observation.projectId);
+  if (new Set(observedProjectIds).size !== observedProjectIds.length) {
+    return false;
+  }
+  if (projectIds === undefined) return true;
+  return (
+    isDenseArray(projectIds) &&
+    projectIds.every(isProjectEnvProjectId) &&
+    new Set(projectIds).size === projectIds.length &&
+    hasExactlyTheSameStrings(observedProjectIds, projectIds)
+  );
+}
+
+export const isProjectEnvSchemaReports = isProjectEnvSchemaObservations;
+
+export function isProjectEnvBinding(
+  value: unknown,
+): value is ProjectEnvBinding {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const kind = (value as { kind?: unknown }).kind;
+  if (kind === "passthrough" || kind === "omit") {
+    return exactWireObject(value, ["kind"]) !== null;
+  }
+  if (kind === "proxy") {
+    const object = exactWireObject(value, ["kind", "domains"]);
+    return (
+      object !== null &&
+      isSortedUniqueStringArray(
+        object.domains,
+        MAX_PROJECT_ENV_PROXY_DOMAINS,
+        isProjectEnvDomain,
+      ) &&
+      object.domains.length > 0
+    );
+  }
+  if (kind === "withhold") {
+    const object = exactWireObject(value, ["kind", "reason"]);
+    return object !== null && isProjectEnvReason(object.reason);
+  }
+  return false;
+}
+
+/** Where a key's live value is (ADR-153 §4, "Value references"): in the
+ * record's own row (owned runners), in a staged parameter named by its
+ * staging id, or in the key's legacy parameter at one exact SSM version. */
+export type ProjectEnvValueRef =
+  | { kind: "row" }
+  | { kind: "staged"; stagingId: string }
+  | { kind: "legacy"; ssmVersion: number };
+
+/** A key's head (ADR-153 §4, "Where bindings live"). A tombstone has no
+ * value, so no value reference; a live head always has one. A removal's
+ * fence is the tombstone at generation 0 (`isProjectEnvFence`). */
+export type ProjectEnvHead =
+  | {
+      revision: number;
+      generation: number;
+      tombstone: false;
+      valueRef: ProjectEnvValueRef;
+    }
+  | { revision: number; generation: number; tombstone: true; valueRef: null };
+
+export type ProjectEnvLiveHead = Extract<
+  ProjectEnvHead,
+  { tombstone: false }
+>;
+
+/** One runner's durable cursor in the cloud-authored env delivery stream.
+ * The stream id changes if the cloud must replace or reconstruct the stream;
+ * sequence zero is the beginning of a new stream, before any mutation. */
+export interface ProjectEnvDeliveryCursor {
+  streamId: HostOpId;
+  sequence: number;
+}
+
+/** A staging id is a lowercase UUID: unique per attempt, never reused. */
+const PROJECT_ENV_STAGING_ID_RE =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const PROJECT_ENV_STORE_PATH_SEGMENT_RE = /^[A-Za-z0-9_.-]+$/;
+
+/** AWS SSM Advanced parameters accept at most 8 KiB. The limit applies to
+ * the complete v2 envelope, not just its secret value. */
+export const MAX_PROJECT_ENV_STAGED_ENVELOPE_BYTES = 8 * 1024;
+
+const isNonNegativeSafeInteger = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+
+const isPositiveSafeInteger = (value: unknown): value is number =>
+  typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+
+export function isProjectEnvValueRef(
+  value: unknown,
+): value is ProjectEnvValueRef {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const kind = (value as { kind?: unknown }).kind;
+  if (kind === "row") return exactWireObject(value, ["kind"]) !== null;
+  if (kind === "staged") {
+    const object = exactWireObject(value, ["kind", "stagingId"]);
+    return (
+      object !== null &&
+      typeof object.stagingId === "string" &&
+      PROJECT_ENV_STAGING_ID_RE.test(object.stagingId)
+    );
+  }
+  if (kind === "legacy") {
+    const object = exactWireObject(value, ["kind", "ssmVersion"]);
+    return object !== null && isPositiveSafeInteger(object.ssmVersion);
+  }
+  return false;
+}
+
+/** The heads the head table reaches, and only those (ADR-153 §4): a live
+ * head with both counters positive; a tombstone with both at 2 or more, since
+ * a delete or removal advances both from a live head; and a fence, which is
+ * exactly `r1, g0`, since nothing but a first save moves it. */
+export function isProjectEnvHead(value: unknown): value is ProjectEnvHead {
+  const object = exactWireObject(value, [
+    "revision",
+    "generation",
+    "tombstone",
+    "valueRef",
+  ]);
+  if (object === null) return false;
+  const { revision, generation, tombstone, valueRef } = object;
+  if (tombstone === false) {
+    return (
+      isPositiveSafeInteger(revision) &&
+      isPositiveSafeInteger(generation) &&
+      isProjectEnvValueRef(valueRef)
+    );
+  }
+  if (tombstone !== true || valueRef !== null) return false;
+  if (generation === 0) return revision === 1;
+  return (
+    isPositiveSafeInteger(revision) &&
+    isPositiveSafeInteger(generation) &&
+    revision >= 2 &&
+    generation >= 2
+  );
+}
+
+/** Whether a head is a removal's fence: the one record that has never held a
+ * value, so a save expecting it is a first save (ADR-153 §4). */
+export function isProjectEnvFence(head: ProjectEnvHead): boolean {
+  return head.generation === 0;
+}
+
+/** Whether two heads are the same, field by field. */
+export function sameProjectEnvHead(
+  left: ProjectEnvHead,
+  right: ProjectEnvHead,
+): boolean {
+  if (
+    left.revision !== right.revision ||
+    left.generation !== right.generation ||
+    left.tombstone !== right.tombstone
+  ) {
+    return false;
+  }
+  const a = left.valueRef;
+  const b = right.valueRef;
+  if (a === null || b === null) return a === b;
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "staged") {
+    return b.kind === "staged" && a.stagingId === b.stagingId;
+  }
+  if (a.kind === "legacy") {
+    return b.kind === "legacy" && a.ssmVersion === b.ssmVersion;
+  }
+  return true;
+}
+
+export function isProjectEnvDeliveryCursor(
+  value: unknown,
+): value is ProjectEnvDeliveryCursor {
+  const object = exactWireObject(value, ["streamId", "sequence"]);
+  return Boolean(
+    object &&
+      isHostOpId(object.streamId) &&
+      isNonNegativeSafeInteger(object.sequence),
+  );
+}
+
+export function isProjectEnvBindingState(
+  value: unknown,
+): value is ProjectEnvBindingState {
+  const object = exactWireObject(value, [
+    "key",
+    "head",
+    "binding",
+    "policyEpoch",
+    "listingGeneration",
+  ]);
+  if (
+    object === null ||
+    !isProjectEnvKey(object.key) ||
+    !isProjectEnvHead(object.head)
+  ) {
+    return false;
+  }
+  const { head, binding, policyEpoch, listingGeneration } = object;
+  if (!isNonNegativeSafeInteger(listingGeneration)) return false;
+
+  // A fence: no binding, no epoch, and a removal's listing generation.
+  if (isProjectEnvFence(head)) {
+    return (
+      binding === null &&
+      policyEpoch === null &&
+      listingGeneration >= 2 &&
+      listingGeneration % 2 === 0
+    );
+  }
+  if (
+    !isPositiveSafeInteger(policyEpoch) ||
+    !(binding === null || isProjectEnvBinding(binding))
+  ) {
+    return false;
+  }
+
+  // Generation zero exists only for the two states migration can create:
+  // an existing live row, or a backfilled legacy row a late-write sweep then
+  // tombstoned. Neither has ever been approved, and staging is feature-era.
+  if (listingGeneration === 0) {
+    if (
+      binding !== null ||
+      policyEpoch !== INITIAL_PROJECT_ENV_POLICY_EPOCH
+    ) {
+      return false;
+    }
+    if (!head.tombstone) {
+      return (
+        head.revision === 1 &&
+        head.generation === 1 &&
+        (head.valueRef.kind === "row" || head.valueRef.kind === "legacy")
+      );
+    }
+    return head.revision === 2 && head.generation === 2;
+  }
+
+  // A live value belongs to a listed key. A tombstone can carry either the
+  // listed generation of a value delete or an even removal generation.
+  return head.tombstone || listingGeneration % 2 === 1;
+}
+
+export function isProjectEnvBindingStates(
+  value: unknown,
+  keys?: readonly string[],
+): value is ProjectEnvBindingState[] {
+  if (
+    !isDenseArray(value) ||
+    !value.every(isProjectEnvBindingState)
+  ) {
+    return false;
+  }
+  const stateKeys = value.map((state) => state.key);
+  if (new Set(stateKeys).size !== stateKeys.length) return false;
+  // Tombstones and fences are reported too; the live records are exactly
+  // the ack's keys.
+  const liveKeys = value
+    .filter((state) => !state.head.tombstone)
+    .map((state) => state.key);
+  return (
+    keys === undefined ||
+    (isProjectEnvKeys(keys) &&
+      liveKeys.length === keys.length &&
+      liveKeys.every((key, index) => key === keys[index]))
+  );
+}
+
+/** One reconciliation reads a stable page walk from each project under this
+ * id. `streamId` names the cloud-authored ordered mutation stream the runner
+ * must drain before the attempt may open its delivery gate. */
+export interface ProjectEnvReconciliationAttempt {
+  attemptId: HostOpId;
+  streamId: HostOpId;
+}
+
+export interface ProjectEnvRecordVersion {
+  projectId: string;
+  recordVersion: number;
+}
+
+type ProjectEnvListFrameBase = {
+  kind: "env.var.list";
+  opId: HostOpId;
+  projectId: string;
+  orgId?: string;
+};
+
+export type ProjectEnvListFrame = ProjectEnvListFrameBase &
+  (
+    | {
+        /** The exact legacy request; a bare list is never a modern page. */
+        after?: never;
+        refreshFromStore?: never;
+        reconciliationAttemptId?: never;
+      }
+    | {
+        /** Every owned-runner modern page belongs to an explicit attempt. */
+        after?: string;
+        refreshFromStore?: never;
+        reconciliationAttemptId: HostOpId;
+      }
+  );
+
+/** Begins a new inventory attempt and closes the runner's delivery gate
+ * before any page is read. Separate from list so a runner with zero projects
+ * still has an active attempt and stale completion markers cannot open it. */
+export interface ProjectEnvReconcileBeginFrame {
+  kind: "env.reconcile.begin";
+  opId: HostOpId;
+  attempt: ProjectEnvReconciliationAttempt;
+}
+
+type ProjectEnvSetFrameBase = {
+  kind: "env.var.set";
+  opId: HostOpId;
+  projectId: string;
+  key: string;
+  value: string;
+  orgId?: string;
+};
+
+type ProjectEnvLegacySetFrame = ProjectEnvSetFrameBase & {
+  expectedHead?: never;
+  initialBinding?: never;
+  policyEpoch?: never;
+  listingGeneration?: never;
+  delivery?: never;
+  reconciliationAttemptId?: never;
+};
+
+type ProjectEnvModernSetFrameBase = ProjectEnvSetFrameBase & {
+  policyEpoch: number;
+  listingGeneration: number;
+  delivery: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+};
+
+type ProjectEnvModernSetFrame = ProjectEnvModernSetFrameBase &
+  (
+    | {
+        /** No record is unambiguously a first save. */
+        expectedHead: null;
+        initialBinding: ProjectEnvBinding | null;
+      }
+    | {
+        /** A fence is also a first save, enforced by the runtime guard because
+         * TypeScript cannot exclude numeric generation zero from `number`. */
+        expectedHead: ProjectEnvHead;
+        initialBinding?: ProjectEnvBinding | null;
+      }
+  );
+
+export type ProjectEnvSetFrame =
+  | ProjectEnvLegacySetFrame
+  | ProjectEnvModernSetFrame;
+
+type ProjectEnvDeleteFrameBase = {
+  kind: "env.var.delete";
+  opId: HostOpId;
+  projectId: string;
+  key: string;
+};
+
+type ProjectEnvLegacyDeleteFrame = ProjectEnvDeleteFrameBase & {
+  expectedHead?: never;
+  policyEpoch?: never;
+  listingGeneration?: never;
+  delivery?: never;
+  reconciliationAttemptId?: never;
+};
+
+type ProjectEnvModernDeleteFrame = ProjectEnvDeleteFrameBase & {
+  expectedHead: ProjectEnvLiveHead;
+  policyEpoch: number;
+  listingGeneration: number;
+  delivery: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+};
+
+export type ProjectEnvDeleteFrame =
+  | ProjectEnvLegacyDeleteFrame
+  | ProjectEnvModernDeleteFrame;
+
+/** One project-wide removal as applied to an owned runner. It fences a
+ * missing row, tombstones a live row, and is idempotent on a tombstone/fence. */
+export interface ProjectEnvRemoveFrame {
+  kind: "env.var.remove";
+  opId: HostOpId;
+  projectId: string;
+  key: string;
+  listingGeneration: number;
+  delivery: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+}
+
+/** Owner-approved binding CAS. The cloud derives the binding; the browser
+ * never supplies it. Approve is available only while a value is live. */
+export interface ProjectEnvBindingSetFrame {
+  kind: "env.binding.set";
+  opId: HostOpId;
+  projectId: string;
+  key: string;
+  binding: ProjectEnvBinding | null;
+  expectedHead: ProjectEnvLiveHead;
+  policyEpoch: number;
+  listingGeneration: number;
+  delivery: ProjectEnvDeliveryCursor;
+  orgId?: string;
+  reconciliationAttemptId?: HostOpId;
+}
+
+/** The cloud sends this only after a complete, stable inventory and after it
+ * has applied every queued mutation through `highWater`. The runner accepts it
+ * only for the named attempt, cursor and still-current project versions. */
+export interface ProjectEnvReconciledFrame {
+  kind: "env.reconciled";
+  opId: HostOpId;
+  attemptId: HostOpId;
+  highWater: ProjectEnvDeliveryCursor;
+  versions: ProjectEnvRecordVersion[];
+}
+
+/** Closes one reserved delivery sequence whose original operation can no
+ * longer be replayed (notably a plaintext save lost with its cloud process).
+ * If the operation already applied, this is an idempotent cursor read. */
+export interface ProjectEnvDeliverySkipFrame {
+  kind: "env.delivery.skip";
+  opId: HostOpId;
+  delivery: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+}
+
+/** The secret-blind cloud reserves a unique staging id before asking the
+ * write-only sign-in box to create its immutable SSM parameter. The deadline
+ * remains cloud-side: a late or ambiguous create is harmless garbage that the
+ * permanent sweep removes, and host clock skew must not decide promotion. */
+export interface ProjectEnvStagingPutFrame {
+  kind: "env.staging.put";
+  opId: HostOpId;
+  orgId: string;
+  projectId: string;
+  key: string;
+  stagingId: string;
+  value: string;
+}
+
+export type ProjectEnvStagingErrorCode =
+  | "staging_conflict"
+  | "staging_invalid"
+  | "staging_unavailable";
+
+export function isProjectEnvStagingErrorCode(
+  value: unknown,
+): value is ProjectEnvStagingErrorCode {
+  return (
+    value === "staging_conflict" ||
+    value === "staging_invalid" ||
+    value === "staging_unavailable"
+  );
+}
+
+/** A success means the deterministic envelope exists at the unique path and
+ * its tenant tags are in place. Values and store metadata never cross back. */
+export type ProjectEnvStagingAckFrame =
+  | {
+      kind: "env.staging.ack";
+      opId: HostOpId;
+      ok: true;
+      stagingId: string;
+    }
+  | {
+      kind: "env.staging.ack";
+      opId: HostOpId;
+      ok: false;
+      stagingId: string;
+      code: ProjectEnvStagingErrorCode;
+      error: string;
+    };
+
+/** Uai Cloud is authoritative for task-machine records. A replica may read
+ * only immutable staged values or one pinned legacy SSM version; `row` is an
+ * owned-runner reference and is never meaningful on a sidecar. */
+export type ProjectEnvReplicaHead =
+  | Extract<ProjectEnvHead, { tombstone: true }>
+  | (Omit<ProjectEnvLiveHead, "valueRef"> & {
+      valueRef: Exclude<ProjectEnvValueRef, { kind: "row" }>;
+    });
+
+type ProjectEnvReplicaBindingStateBase = Omit<
+  ProjectEnvBindingState,
+  "head"
+>;
+type ProjectEnvReplicaTombstoneState = ProjectEnvReplicaBindingStateBase & {
+  head: Extract<ProjectEnvReplicaHead, { tombstone: true }>;
+};
+type ProjectEnvReplicaLiveState = ProjectEnvReplicaBindingStateBase & {
+  head: Extract<ProjectEnvReplicaHead, { tombstone: false }>;
+};
+export type ProjectEnvReplicaBindingState =
+  | ProjectEnvReplicaTombstoneState
+  | ProjectEnvReplicaLiveState;
+
+/** Close the sidecar's serving gate and start a whole-task replica snapshot.
+ * Project ids are canonical (sorted, unique); the empty set is valid. */
+export interface ProjectEnvReplicaBeginFrame {
+  kind: "env.replica.begin";
+  opId: HostOpId;
+  attempt: ProjectEnvReconciliationAttempt;
+  projectIds: string[];
+}
+
+/** One stable page of the cloud-authoritative project snapshot. `after` is
+ * the exclusive cursor used for this page and is null on the first page. */
+export interface ProjectEnvReplicaPageFrame {
+  kind: "env.replica.page";
+  opId: HostOpId;
+  attemptId: HostOpId;
+  projectId: string;
+  after: string | null;
+  recordVersion: number;
+  records: ProjectEnvReplicaBindingState[];
+  complete: boolean;
+}
+
+/** An ordered exact-state delta. Re-sending the current state under a later
+ * delivery is also the durable materialisation retry for an unavailable SSM
+ * value; applying its metadata is independent from fetching its value. */
+export interface ProjectEnvReplicaApplyFrame {
+  kind: "env.replica.apply";
+  opId: HostOpId;
+  projectId: string;
+  recordVersion: number;
+  state: ProjectEnvReplicaBindingState;
+  delivery: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+}
+
+/** Activate the staged whole-task snapshot only after every delivery through
+ * `highWater` has been applied. No page or delta changes the live view before
+ * this marker commits. */
+export interface ProjectEnvReplicaCommitFrame {
+  kind: "env.replica.commit";
+  opId: HostOpId;
+  attemptId: HostOpId;
+  highWater: ProjectEnvDeliveryCursor;
+  versions: ProjectEnvRecordVersion[];
+}
+
+type ProjectEnvReplicaInstalled = { kind: "installed" };
+type ProjectEnvReplicaWithheld = {
+  kind: "withheld";
+  reason: ProjectEnvWithholdReason;
+};
+type ProjectEnvReplicaUnavailable = {
+  kind: "unavailable";
+  reason: ProjectEnvWithholdReason;
+};
+export type ProjectEnvReplicaMaterialization =
+  | ProjectEnvReplicaInstalled
+  | ProjectEnvReplicaWithheld
+  | ProjectEnvReplicaUnavailable;
+
+/** Exact retained metadata is echoed because a removal can advance only the
+ * listing generation while leaving the head unchanged. Values never cross. */
+export type ProjectEnvReplicaResult =
+  | {
+      state: ProjectEnvReplicaTombstoneState;
+      materialization: ProjectEnvReplicaWithheld;
+    }
+  | {
+      state: ProjectEnvReplicaLiveState;
+      materialization: ProjectEnvReplicaMaterialization;
+    };
+
+type ProjectEnvReplicaErrorAckFrame = {
+  kind: "env.replica.ack";
+  opId: HostOpId;
+  ok: false;
+  code: ProjectEnvWithholdReason;
+  error: string;
+  policyEpochs: number[];
+  appliedThrough: ProjectEnvDeliveryCursor;
+} &
+  (
+    | { phase: "applied"; attemptId: HostOpId | null }
+    | {
+        phase: "begun" | "page" | "complete";
+        attemptId: HostOpId;
+      }
+  );
+
+export type ProjectEnvReplicaAckFrame =
+  | {
+      kind: "env.replica.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "begun";
+      attemptId: HostOpId;
+      policyEpochs: number[];
+      appliedThrough: ProjectEnvDeliveryCursor;
+      projectId?: never;
+      after?: never;
+      recordVersion?: never;
+      results?: never;
+      complete?: never;
+      result?: never;
+      highWater?: never;
+      code?: never;
+      error?: never;
+    }
+  | {
+      kind: "env.replica.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "page";
+      attemptId: HostOpId;
+      projectId: string;
+      after: string | null;
+      recordVersion: number;
+      results: ProjectEnvReplicaResult[];
+      complete: boolean;
+      policyEpochs: number[];
+      appliedThrough: ProjectEnvDeliveryCursor;
+      result?: never;
+      highWater?: never;
+      code?: never;
+      error?: never;
+    }
+  | {
+      kind: "env.replica.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "applied";
+      attemptId: HostOpId | null;
+      projectId: string;
+      recordVersion: number;
+      result: ProjectEnvReplicaResult;
+      policyEpochs: number[];
+      appliedThrough: ProjectEnvDeliveryCursor;
+      after?: never;
+      results?: never;
+      complete?: never;
+      highWater?: never;
+      code?: never;
+      error?: never;
+    }
+  | {
+      kind: "env.replica.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "complete";
+      attemptId: HostOpId;
+      highWater: ProjectEnvDeliveryCursor;
+      policyEpochs: number[];
+      appliedThrough: ProjectEnvDeliveryCursor;
+      projectId?: never;
+      after?: never;
+      recordVersion?: never;
+      results?: never;
+      complete?: never;
+      result?: never;
+      code?: never;
+      error?: never;
+    }
+  | ProjectEnvReplicaErrorAckFrame;
+
+type ProjectEnvAckBase = {
+  kind: "env.var.ack";
+  opId: HostOpId;
+  ok: true;
+  keys: string[];
+};
+
+type ProjectEnvAckSuccessOnly = {
+  code?: never;
+  error?: never;
+};
+
+export type ProjectEnvLegacyAckFrame = ProjectEnvAckBase &
+  ProjectEnvAckSuccessOnly & {
+    bindings?: never;
+    policyEpochs?: never;
+    recordVersion?: never;
+    appliedThrough?: never;
+    complete?: never;
+    reconciliationAttemptId?: never;
+  };
+
+export type ProjectEnvMutationAckFrame = ProjectEnvAckBase &
+  ProjectEnvAckSuccessOnly & {
+    bindings: [ProjectEnvBindingState];
+    policyEpochs: number[];
+    recordVersion: number;
+    appliedThrough: ProjectEnvDeliveryCursor;
+    complete?: never;
+    reconciliationAttemptId?: HostOpId;
+  };
+
+export type ProjectEnvListAckFrame = ProjectEnvAckBase &
+  ProjectEnvAckSuccessOnly & {
+    bindings: ProjectEnvBindingState[];
+    policyEpochs: number[];
+    recordVersion: number;
+    appliedThrough: ProjectEnvDeliveryCursor;
+    complete: boolean;
+    reconciliationAttemptId?: HostOpId;
+  };
+
+type ProjectEnvLegacyErrorAckFrame = {
+  kind: "env.var.ack";
+  opId: HostOpId;
+  ok: false;
+  error: string;
+  keys?: never;
+  bindings?: never;
+  policyEpochs?: never;
+  recordVersion?: never;
+  appliedThrough?: never;
+  complete?: never;
+  reconciliationAttemptId?: never;
+  code?: never;
+};
+
+type ProjectEnvModernErrorAckFrame = {
+  kind: "env.var.ack";
+  opId: HostOpId;
+  ok: false;
+  code: ProjectEnvWithholdReason;
+  error: string;
+  /** Current cursor after the attempted mutation. Equal to the request's
+   * cursor only when a terminal refusal consumed its reservation. */
+  appliedThrough: ProjectEnvDeliveryCursor;
+  reconciliationAttemptId?: HostOpId;
+  keys?: never;
+  bindings?: never;
+  policyEpochs?: never;
+  recordVersion?: never;
+  complete?: never;
+};
+
+export type ProjectEnvAckFrame =
+  | ProjectEnvLegacyAckFrame
+  | ProjectEnvMutationAckFrame
+  | ProjectEnvListAckFrame
+  | ProjectEnvLegacyErrorAckFrame
+  | ProjectEnvModernErrorAckFrame;
+
+export type ProjectEnvReconcileAckFrame =
+  | {
+      kind: "env.reconcile.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "begun";
+      attemptId: HostOpId;
+      appliedThrough: ProjectEnvDeliveryCursor;
+    }
+  | {
+      kind: "env.reconcile.ack";
+      opId: HostOpId;
+      ok: true;
+      phase: "complete";
+      attemptId: HostOpId;
+      highWater: ProjectEnvDeliveryCursor;
+      appliedThrough: ProjectEnvDeliveryCursor;
+    }
+  | {
+      kind: "env.reconcile.ack";
+      opId: HostOpId;
+      ok: false;
+      attemptId: HostOpId;
+      phase: "begun" | "complete";
+      code: ProjectEnvWithholdReason;
+      error: string;
+      appliedThrough: ProjectEnvDeliveryCursor;
+    };
+
+export type ProjectEnvDeliveryAckFrame =
+  | {
+      kind: "env.delivery.ack";
+      opId: HostOpId;
+      ok: true;
+      appliedThrough: ProjectEnvDeliveryCursor;
+    }
+  | {
+      kind: "env.delivery.ack";
+      opId: HostOpId;
+      ok: false;
+      code: ProjectEnvWithholdReason;
+      error: string;
+      appliedThrough: ProjectEnvDeliveryCursor;
+    };
+
+export function isProjectEnvReconciliationAttempt(
+  value: unknown,
+): value is ProjectEnvReconciliationAttempt {
+  const object = exactWireObject(value, ["attemptId", "streamId"]);
+  return Boolean(
+    object &&
+      isHostOpId(object.attemptId) &&
+      isHostOpId(object.streamId),
+  );
+}
+
+export function isProjectEnvRecordVersions(
+  value: unknown,
+): value is ProjectEnvRecordVersion[] {
+  if (!isDenseArray(value)) return false;
+  let previous = "";
+  for (const candidate of value) {
+    const object = exactWireObject(candidate, ["projectId", "recordVersion"]);
+    if (
+      object === null ||
+      !isProjectEnvProjectId(object.projectId) ||
+      !isNonNegativeSafeInteger(object.recordVersion) ||
+      (previous !== "" && previous >= object.projectId)
+    ) {
+      return false;
+    }
+    previous = object.projectId;
+  }
+  return true;
+}
+
+export function isProjectEnvPolicyEpochs(value: unknown): value is number[] {
+  return (
+    isDenseArray(value) &&
+    value.length > 0 &&
+    value.length <= MAX_PROJECT_ENV_POLICY_EPOCHS &&
+    value.every(
+      (epoch, index) =>
+        isPositiveSafeInteger(epoch) &&
+        (index === 0 || (value[index - 1] as number) < epoch),
+    )
+  );
+}
+
+export function isProjectEnvProjectIds(value: unknown): value is string[] {
+  return (
+    isDenseArray(value) &&
+    value.length <= MAX_PROJECT_ENV_SCHEMA_REPORTS &&
+    value.every(
+      (projectId, index) =>
+        isProjectEnvProjectId(projectId) &&
+        (index === 0 || (value[index - 1] as string) < projectId),
+    )
+  );
+}
+
+export function isProjectEnvReplicaBindingState(
+  value: unknown,
+): value is ProjectEnvReplicaBindingState {
+  return (
+    isProjectEnvBindingState(value) &&
+    (value.head.tombstone || value.head.valueRef.kind !== "row")
+  );
+}
+
+function isProjectEnvReplicaBindingStates(
+  value: unknown,
+): value is ProjectEnvReplicaBindingState[] {
+  return (
+    isDenseArray(value) &&
+    value.every(isProjectEnvReplicaBindingState) &&
+    value.every(
+      (state, index) => index === 0 || value[index - 1]!.key < state.key,
+    )
+  );
+}
+
+export function isProjectEnvReplicaMaterialization(
+  value: unknown,
+): value is ProjectEnvReplicaMaterialization {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const kind = (value as { kind?: unknown }).kind;
+  if (kind === "installed") {
+    return exactWireObject(value, ["kind"]) !== null;
+  }
+  if (kind === "withheld" || kind === "unavailable") {
+    const object = exactWireObject(value, ["kind", "reason"]);
+    return object !== null && isProjectEnvReason(object.reason);
+  }
+  return false;
+}
+
+export function isProjectEnvReplicaResult(
+  value: unknown,
+): value is ProjectEnvReplicaResult {
+  const object = exactWireObject(value, ["state", "materialization"]);
+  if (
+    object === null ||
+    !isProjectEnvReplicaBindingState(object.state) ||
+    !isProjectEnvReplicaMaterialization(object.materialization)
+  ) {
+    return false;
+  }
+  return object.state.head.tombstone
+    ? object.materialization.kind === "withheld"
+    : true;
+}
+
+function isProjectEnvReplicaResults(
+  value: unknown,
+): value is ProjectEnvReplicaResult[] {
+  return (
+    isDenseArray(value) &&
+    value.every(isProjectEnvReplicaResult) &&
+    value.every(
+      (result, index) =>
+        index === 0 || value[index - 1]!.state.key < result.state.key,
+    )
+  );
+}
+
+function isProjectEnvPageWithinBound(value: unknown): boolean {
+  try {
+    const encoded = JSON.stringify(value);
+    return (
+      typeof encoded === "string" &&
+      utf8ByteLength(encoded) <= MAX_PROJECT_ENV_PAGE_BYTES
+    );
+  } catch {
+    return false;
+  }
+}
+
+function isProjectEnvMutationDelivery(
+  value: unknown,
+): value is ProjectEnvDeliveryCursor {
+  return isProjectEnvDeliveryCursor(value) && value.sequence > 0;
+}
+
+function isProjectEnvOrgId(value: unknown): value is string {
+  return (
+    typeof value === "string" && value.length > 0 && value.length <= 128
+  );
+}
+
+export function isProjectEnvListFrame(
+  value: unknown,
+): value is ProjectEnvListFrame {
+  const frame = exactWireObject(
+    value,
+    ["kind", "opId", "projectId"],
+    ["orgId", "after", "reconciliationAttemptId"],
+  );
+  if (
+    frame === null ||
+    frame.kind !== "env.var.list" ||
+    !isHostOpId(frame.opId) ||
+    !isProjectEnvProjectId(frame.projectId) ||
+    (frame.orgId !== undefined && !isProjectEnvOrgId(frame.orgId)) ||
+    (frame.after !== undefined && !isProjectEnvKey(frame.after)) ||
+    (frame.reconciliationAttemptId !== undefined &&
+      !isHostOpId(frame.reconciliationAttemptId))
+  ) {
+    return false;
+  }
+  // A bare list is the exact legacy request. Every modern page belongs to an
+  // explicit attempt, so shutdown and dispatch never have to guess.
+  if (frame.reconciliationAttemptId !== undefined) return true;
+  return frame.after === undefined;
+}
+
+export function isProjectEnvReconcileBeginFrame(
+  value: unknown,
+): value is ProjectEnvReconcileBeginFrame {
+  const frame = exactWireObject(value, ["kind", "opId", "attempt"]);
+  return Boolean(
+    frame &&
+      frame.kind === "env.reconcile.begin" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvReconciliationAttempt(frame.attempt),
+  );
+}
+
+export function isProjectEnvSetFrame(
+  value: unknown,
+): value is ProjectEnvSetFrame {
+  const base = exactWireObject(
+    value,
+    ["kind", "opId", "projectId", "key", "value"],
+    [
+      "orgId",
+      "expectedHead",
+      "initialBinding",
+      "policyEpoch",
+      "listingGeneration",
+      "delivery",
+      "reconciliationAttemptId",
+    ],
+  );
+  if (
+    base === null ||
+    base.kind !== "env.var.set" ||
+    !isHostOpId(base.opId) ||
+    !isProjectEnvProjectId(base.projectId) ||
+    !isProjectEnvKey(base.key) ||
+    typeof base.value !== "string" ||
+    (base.orgId !== undefined && !isProjectEnvOrgId(base.orgId))
+  ) {
+    return false;
+  }
+  const modernFields = [
+    "expectedHead",
+    "initialBinding",
+    "policyEpoch",
+    "listingGeneration",
+    "delivery",
+    "reconciliationAttemptId",
+  ].filter((key) => Object.hasOwn(base, key));
+  if (modernFields.length === 0) return true;
+  if (
+    !Object.hasOwn(base, "expectedHead") ||
+    !Object.hasOwn(base, "policyEpoch") ||
+    !Object.hasOwn(base, "listingGeneration") ||
+    !Object.hasOwn(base, "delivery") ||
+    !(base.expectedHead === null || isProjectEnvHead(base.expectedHead)) ||
+    !isPositiveSafeInteger(base.policyEpoch) ||
+    !isPositiveSafeInteger(base.listingGeneration) ||
+    base.listingGeneration % 2 !== 1 ||
+    !isProjectEnvMutationDelivery(base.delivery) ||
+    (base.reconciliationAttemptId !== undefined &&
+      !isHostOpId(base.reconciliationAttemptId))
+  ) {
+    return false;
+  }
+  const firstSave =
+    base.expectedHead === null ||
+    (isProjectEnvHead(base.expectedHead) && isProjectEnvFence(base.expectedHead));
+  const hasInitialBinding = Object.hasOwn(base, "initialBinding");
+  return firstSave
+    ? hasInitialBinding &&
+        (base.initialBinding === null || isProjectEnvBinding(base.initialBinding))
+    : !hasInitialBinding;
+}
+
+export function isProjectEnvDeleteFrame(
+  value: unknown,
+): value is ProjectEnvDeleteFrame {
+  const frame = exactWireObject(
+    value,
+    ["kind", "opId", "projectId", "key"],
+    [
+      "expectedHead",
+      "policyEpoch",
+      "listingGeneration",
+      "delivery",
+      "reconciliationAttemptId",
+    ],
+  );
+  if (
+    frame === null ||
+    frame.kind !== "env.var.delete" ||
+    !isHostOpId(frame.opId) ||
+    !isProjectEnvProjectId(frame.projectId) ||
+    !isProjectEnvKey(frame.key)
+  ) {
+    return false;
+  }
+  const modernFields = [
+    "expectedHead",
+    "policyEpoch",
+    "listingGeneration",
+    "delivery",
+    "reconciliationAttemptId",
+  ].filter((key) => Object.hasOwn(frame, key));
+  if (modernFields.length === 0) return true;
+  return (
+    Object.hasOwn(frame, "expectedHead") &&
+    Object.hasOwn(frame, "policyEpoch") &&
+    Object.hasOwn(frame, "listingGeneration") &&
+    Object.hasOwn(frame, "delivery") &&
+    isProjectEnvHead(frame.expectedHead) &&
+    !frame.expectedHead.tombstone &&
+    isPositiveSafeInteger(frame.policyEpoch) &&
+    isPositiveSafeInteger(frame.listingGeneration) &&
+    frame.listingGeneration % 2 === 1 &&
+    isProjectEnvMutationDelivery(frame.delivery) &&
+    (frame.reconciliationAttemptId === undefined ||
+      isHostOpId(frame.reconciliationAttemptId))
+  );
+}
+
+export function isProjectEnvRemoveFrame(
+  value: unknown,
+): value is ProjectEnvRemoveFrame {
+  const frame = exactWireObject(
+    value,
+    [
+      "kind",
+      "opId",
+      "projectId",
+      "key",
+      "listingGeneration",
+      "delivery",
+    ],
+    ["reconciliationAttemptId"],
+  );
+  return Boolean(
+    frame &&
+      frame.kind === "env.var.remove" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvProjectId(frame.projectId) &&
+      isProjectEnvKey(frame.key) &&
+      isPositiveSafeInteger(frame.listingGeneration) &&
+      (frame.listingGeneration as number) >= 2 &&
+      (frame.listingGeneration as number) % 2 === 0 &&
+      isProjectEnvMutationDelivery(frame.delivery) &&
+      (frame.reconciliationAttemptId === undefined ||
+        isHostOpId(frame.reconciliationAttemptId)),
+  );
+}
+
+export function isProjectEnvBindingSetFrame(
+  value: unknown,
+): value is ProjectEnvBindingSetFrame {
+  const frame = exactWireObject(
+    value,
+    [
+      "kind",
+      "opId",
+      "projectId",
+      "key",
+      "binding",
+      "expectedHead",
+      "policyEpoch",
+      "listingGeneration",
+      "delivery",
+    ],
+    ["orgId", "reconciliationAttemptId"],
+  );
+  return Boolean(
+    frame &&
+      frame.kind === "env.binding.set" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvProjectId(frame.projectId) &&
+      isProjectEnvKey(frame.key) &&
+      (frame.binding === null || isProjectEnvBinding(frame.binding)) &&
+      isProjectEnvHead(frame.expectedHead) &&
+      !frame.expectedHead.tombstone &&
+      isPositiveSafeInteger(frame.policyEpoch) &&
+      isPositiveSafeInteger(frame.listingGeneration) &&
+      (frame.listingGeneration as number) % 2 === 1 &&
+      isProjectEnvMutationDelivery(frame.delivery) &&
+      (frame.orgId === undefined || isProjectEnvOrgId(frame.orgId)) &&
+      (frame.reconciliationAttemptId === undefined ||
+        isHostOpId(frame.reconciliationAttemptId)),
+  );
+}
+
+export function isProjectEnvReconciledFrame(
+  value: unknown,
+): value is ProjectEnvReconciledFrame {
+  const frame = exactWireObject(value, [
+    "kind",
+    "opId",
+    "attemptId",
+    "highWater",
+    "versions",
+  ]);
+  return Boolean(
+    frame &&
+      frame.kind === "env.reconciled" &&
+      isHostOpId(frame.opId) &&
+      isHostOpId(frame.attemptId) &&
+      isProjectEnvDeliveryCursor(frame.highWater) &&
+      isProjectEnvRecordVersions(frame.versions),
+  );
+}
+
+export function isProjectEnvDeliverySkipFrame(
+  value: unknown,
+): value is ProjectEnvDeliverySkipFrame {
+  const frame = exactWireObject(
+    value,
+    ["kind", "opId", "delivery"],
+    ["reconciliationAttemptId"],
+  );
+  return Boolean(
+    frame &&
+      frame.kind === "env.delivery.skip" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvMutationDelivery(frame.delivery) &&
+      (frame.reconciliationAttemptId === undefined ||
+        isHostOpId(frame.reconciliationAttemptId)),
+  );
+}
+
+export function isProjectEnvStagingPutFrame(
+  value: unknown,
+): value is ProjectEnvStagingPutFrame {
+  const frame = exactWireObject(value, [
+    "kind",
+    "opId",
+    "orgId",
+    "projectId",
+    "key",
+    "stagingId",
+    "value",
+  ]);
+  return Boolean(
+    frame &&
+      frame.kind === "env.staging.put" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvOrgId(frame.orgId) &&
+      PROJECT_ENV_STORE_PATH_SEGMENT_RE.test(frame.orgId) &&
+      isProjectEnvProjectId(frame.projectId) &&
+      PROJECT_ENV_STORE_PATH_SEGMENT_RE.test(frame.projectId) &&
+      isProjectEnvKey(frame.key) &&
+      typeof frame.stagingId === "string" &&
+      PROJECT_ENV_STAGING_ID_RE.test(frame.stagingId) &&
+      typeof frame.value === "string",
+  );
+}
+
+export function isProjectEnvStagingAckFrame(
+  value: unknown,
+): value is ProjectEnvStagingAckFrame {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as WireObject;
+  if (candidate.ok === true) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "stagingId",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.staging.ack" &&
+        isHostOpId(frame.opId) &&
+        typeof frame.stagingId === "string" &&
+        PROJECT_ENV_STAGING_ID_RE.test(frame.stagingId),
+    );
+  }
+  if (candidate.ok === false) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "stagingId",
+      "code",
+      "error",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.staging.ack" &&
+        isHostOpId(frame.opId) &&
+        typeof frame.stagingId === "string" &&
+        PROJECT_ENV_STAGING_ID_RE.test(frame.stagingId) &&
+        isProjectEnvStagingErrorCode(frame.code) &&
+        isBoundedMessage(frame.error),
+    );
+  }
+  return false;
+}
+
+export function isProjectEnvReplicaBeginFrame(
+  value: unknown,
+): value is ProjectEnvReplicaBeginFrame {
+  const frame = exactWireObject(value, [
+    "kind",
+    "opId",
+    "attempt",
+    "projectIds",
+  ]);
+  return Boolean(
+    frame &&
+      frame.kind === "env.replica.begin" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvReconciliationAttempt(frame.attempt) &&
+      isProjectEnvProjectIds(frame.projectIds),
+  );
+}
+
+export function isProjectEnvReplicaPageFrame(
+  value: unknown,
+): value is ProjectEnvReplicaPageFrame {
+  const frame = exactWireObject(value, [
+    "kind",
+    "opId",
+    "attemptId",
+    "projectId",
+    "after",
+    "recordVersion",
+    "records",
+    "complete",
+  ]);
+  if (
+    frame === null ||
+    frame.kind !== "env.replica.page" ||
+    !isHostOpId(frame.opId) ||
+    !isHostOpId(frame.attemptId) ||
+    !isProjectEnvProjectId(frame.projectId) ||
+    !(frame.after === null || isProjectEnvKey(frame.after)) ||
+    !isNonNegativeSafeInteger(frame.recordVersion) ||
+    !isProjectEnvReplicaBindingStates(frame.records) ||
+    typeof frame.complete !== "boolean"
+  ) {
+    return false;
+  }
+  const records = frame.records as ProjectEnvReplicaBindingState[];
+  if (records.length === 0) {
+    if (!(frame.complete && frame.after === null)) return false;
+  } else if (
+    frame.after !== null &&
+    records[0]!.key <= frame.after
+  ) {
+    return false;
+  }
+  return isProjectEnvPageWithinBound(value);
+}
+
+export function isProjectEnvReplicaApplyFrame(
+  value: unknown,
+): value is ProjectEnvReplicaApplyFrame {
+  const frame = exactWireObject(
+    value,
+    [
+      "kind",
+      "opId",
+      "projectId",
+      "recordVersion",
+      "state",
+      "delivery",
+    ],
+    ["reconciliationAttemptId"],
+  );
+  return Boolean(
+    frame &&
+      frame.kind === "env.replica.apply" &&
+      isHostOpId(frame.opId) &&
+      isProjectEnvProjectId(frame.projectId) &&
+      isPositiveSafeInteger(frame.recordVersion) &&
+      isProjectEnvReplicaBindingState(frame.state) &&
+      isProjectEnvMutationDelivery(frame.delivery) &&
+      (frame.reconciliationAttemptId === undefined ||
+        isHostOpId(frame.reconciliationAttemptId)),
+  );
+}
+
+export function isProjectEnvReplicaCommitFrame(
+  value: unknown,
+): value is ProjectEnvReplicaCommitFrame {
+  const frame = exactWireObject(value, [
+    "kind",
+    "opId",
+    "attemptId",
+    "highWater",
+    "versions",
+  ]);
+  return Boolean(
+    frame &&
+      frame.kind === "env.replica.commit" &&
+      isHostOpId(frame.opId) &&
+      isHostOpId(frame.attemptId) &&
+      isProjectEnvDeliveryCursor(frame.highWater) &&
+      isProjectEnvRecordVersions(frame.versions),
+  );
+}
+
+function hasSortedBindingStates(value: ProjectEnvBindingState[]): boolean {
+  return value.every(
+    (state, index) => index === 0 || value[index - 1]!.key < state.key,
+  );
+}
+
+export function isProjectEnvAckFrame(
+  value: unknown,
+): value is ProjectEnvAckFrame {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as WireObject;
+  if (candidate.ok === false) {
+    if (Object.hasOwn(candidate, "appliedThrough")) {
+      const frame = exactWireObject(value, [
+        "kind",
+        "opId",
+        "ok",
+        "code",
+        "error",
+        "appliedThrough",
+      ], ["reconciliationAttemptId"]);
+      return Boolean(
+        frame &&
+          frame.kind === "env.var.ack" &&
+          isHostOpId(frame.opId) &&
+          isProjectEnvReason(frame.code) &&
+          isBoundedMessage(frame.error) &&
+          isProjectEnvDeliveryCursor(frame.appliedThrough) &&
+          (frame.reconciliationAttemptId === undefined ||
+            isHostOpId(frame.reconciliationAttemptId)),
+      );
+    }
+    const frame = exactWireObject(value, ["kind", "opId", "ok", "error"]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.var.ack" &&
+        isHostOpId(frame.opId) &&
+        isBoundedMessage(frame.error),
+    );
+  }
+  if (candidate.ok !== true) return false;
+  const legacy = exactWireObject(value, ["kind", "opId", "ok", "keys"]);
+  if (legacy !== null) {
+    return (
+      legacy.kind === "env.var.ack" &&
+      isHostOpId(legacy.opId) &&
+      isProjectEnvKeys(legacy.keys)
+    );
+  }
+  const frame = exactWireObject(
+    value,
+    [
+      "kind",
+      "opId",
+      "ok",
+      "keys",
+      "bindings",
+      "policyEpochs",
+      "recordVersion",
+      "appliedThrough",
+    ],
+    ["complete", "reconciliationAttemptId"],
+  );
+  if (
+    frame === null ||
+    frame.kind !== "env.var.ack" ||
+    !isHostOpId(frame.opId) ||
+    !isProjectEnvBindingStates(frame.bindings, frame.keys as readonly string[]) ||
+    !hasSortedBindingStates(frame.bindings as ProjectEnvBindingState[]) ||
+    !isProjectEnvPolicyEpochs(frame.policyEpochs) ||
+    !isNonNegativeSafeInteger(frame.recordVersion) ||
+    !isProjectEnvDeliveryCursor(frame.appliedThrough) ||
+    (frame.reconciliationAttemptId !== undefined &&
+      !isHostOpId(frame.reconciliationAttemptId))
+  ) {
+    return false;
+  }
+  const states = frame.bindings as ProjectEnvBindingState[];
+  if (frame.complete === undefined) {
+    return states.length === 1;
+  }
+  return (
+    typeof frame.complete === "boolean" &&
+    (frame.complete || states.length > 0)
+  );
+}
+
+export function isProjectEnvReconcileAckFrame(
+  value: unknown,
+): value is ProjectEnvReconcileAckFrame {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as WireObject;
+  if (candidate.ok === true) {
+    const phase = candidate.phase;
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "appliedThrough",
+      ...(phase === "complete" ? ["highWater"] : []),
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.reconcile.ack" &&
+        isHostOpId(frame.opId) &&
+        (frame.phase === "begun" || frame.phase === "complete") &&
+        isHostOpId(frame.attemptId) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough) &&
+        (frame.phase === "begun"
+          ? frame.highWater === undefined
+          : isProjectEnvDeliveryCursor(frame.highWater) &&
+            frame.appliedThrough.streamId === frame.highWater.streamId &&
+            frame.appliedThrough.sequence === frame.highWater.sequence),
+    );
+  }
+  if (candidate.ok === false) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "attemptId",
+      "phase",
+      "code",
+      "error",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.reconcile.ack" &&
+        isHostOpId(frame.opId) &&
+        isHostOpId(frame.attemptId) &&
+        (frame.phase === "begun" || frame.phase === "complete") &&
+        isProjectEnvReason(frame.code) &&
+        isBoundedMessage(frame.error) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough),
+    );
+  }
+  return false;
+}
+
+export function isProjectEnvDeliveryAckFrame(
+  value: unknown,
+): value is ProjectEnvDeliveryAckFrame {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as WireObject;
+  if (candidate.ok === true) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.delivery.ack" &&
+        isHostOpId(frame.opId) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough),
+    );
+  }
+  if (candidate.ok === false) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "code",
+      "error",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.delivery.ack" &&
+        isHostOpId(frame.opId) &&
+        isProjectEnvReason(frame.code) &&
+        isBoundedMessage(frame.error) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough),
+    );
+  }
+  return false;
+}
+
+export function isProjectEnvReplicaAckFrame(
+  value: unknown,
+): value is ProjectEnvReplicaAckFrame {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const candidate = value as WireObject;
+  if (candidate.ok === false) {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "code",
+      "error",
+      "policyEpochs",
+      "appliedThrough",
+    ]);
+    if (
+      frame === null ||
+      frame.kind !== "env.replica.ack" ||
+      !isHostOpId(frame.opId) ||
+      !(
+        frame.phase === "begun" ||
+        frame.phase === "page" ||
+        frame.phase === "applied" ||
+        frame.phase === "complete"
+      ) ||
+      !(
+        frame.attemptId === null || isHostOpId(frame.attemptId)
+      ) ||
+      (frame.phase !== "applied" && frame.attemptId === null) ||
+      !isProjectEnvReason(frame.code) ||
+      !isBoundedMessage(frame.error) ||
+      !isProjectEnvPolicyEpochs(frame.policyEpochs) ||
+      !isProjectEnvDeliveryCursor(frame.appliedThrough)
+    ) {
+      return false;
+    }
+    return true;
+  }
+  if (candidate.ok !== true) return false;
+
+  if (candidate.phase === "begun") {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "policyEpochs",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.replica.ack" &&
+        isHostOpId(frame.opId) &&
+        isHostOpId(frame.attemptId) &&
+        isProjectEnvPolicyEpochs(frame.policyEpochs) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough),
+    );
+  }
+
+  if (candidate.phase === "page") {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "projectId",
+      "after",
+      "recordVersion",
+      "results",
+      "complete",
+      "policyEpochs",
+      "appliedThrough",
+    ]);
+    if (
+      frame === null ||
+      frame.kind !== "env.replica.ack" ||
+      !isHostOpId(frame.opId) ||
+      !isHostOpId(frame.attemptId) ||
+      !isProjectEnvProjectId(frame.projectId) ||
+      !(frame.after === null || isProjectEnvKey(frame.after)) ||
+      !isNonNegativeSafeInteger(frame.recordVersion) ||
+      !isProjectEnvReplicaResults(frame.results) ||
+      typeof frame.complete !== "boolean" ||
+      !isProjectEnvPolicyEpochs(frame.policyEpochs) ||
+      !isProjectEnvDeliveryCursor(frame.appliedThrough)
+    ) {
+      return false;
+    }
+    const results = frame.results as ProjectEnvReplicaResult[];
+    if (results.length === 0) {
+      if (!(frame.complete && frame.after === null)) return false;
+    } else if (
+      frame.after !== null &&
+      results[0]!.state.key <= frame.after
+    ) {
+      return false;
+    }
+    return isProjectEnvPageWithinBound(value);
+  }
+
+  if (candidate.phase === "applied") {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "projectId",
+      "recordVersion",
+      "result",
+      "policyEpochs",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.replica.ack" &&
+        isHostOpId(frame.opId) &&
+        (frame.attemptId === null || isHostOpId(frame.attemptId)) &&
+        isProjectEnvProjectId(frame.projectId) &&
+        isPositiveSafeInteger(frame.recordVersion) &&
+        isProjectEnvReplicaResult(frame.result) &&
+        isProjectEnvPolicyEpochs(frame.policyEpochs) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough),
+    );
+  }
+
+  if (candidate.phase === "complete") {
+    const frame = exactWireObject(value, [
+      "kind",
+      "opId",
+      "ok",
+      "phase",
+      "attemptId",
+      "highWater",
+      "policyEpochs",
+      "appliedThrough",
+    ]);
+    return Boolean(
+      frame &&
+        frame.kind === "env.replica.ack" &&
+        isHostOpId(frame.opId) &&
+        isHostOpId(frame.attemptId) &&
+        isProjectEnvDeliveryCursor(frame.highWater) &&
+        isProjectEnvPolicyEpochs(frame.policyEpochs) &&
+        isProjectEnvDeliveryCursor(frame.appliedThrough) &&
+        frame.appliedThrough.streamId === frame.highWater.streamId &&
+        frame.appliedThrough.sequence === frame.highWater.sequence,
+    );
+  }
+  return false;
+}
 /** The owner-level account scope; every pre-scope account lives here. */
 export const HOST_ACCOUNT_SCOPE = "host";
 const ORG_ACCOUNT_SCOPE_RE = /^org:[A-Za-z0-9_-]{1,128}$/;
@@ -1056,6 +3242,10 @@ export interface HostCapabilities {
   /** Optional protocol features. Absence means an older host and fails closed
    *  for features whose fallback would weaken isolation (ADR-083). */
   protocolFeatures?: string[];
+  /** Policy interpretations retained by this runner. Required whenever
+   * `project-env-bindings-v1` is advertised so the cloud never guesses an
+   * epoch while deciding whether a stored binding can still be applied. */
+  projectEnvPolicyEpochs?: number[];
   agentKinds: Array<{
     kind: string;
     label: string;
@@ -1157,6 +3347,13 @@ export interface TaskUpResult {
   worktreePath: string;
   codeServerPort?: number;
   previewPorts?: Array<{ name: string; hostPort: number }>;
+  /** The value-delivery mode this exact task-machine start actually used.
+   * Absent on older runners and therefore interpreted by the cloud as the
+   * fail-safe baked mode. */
+  envMode?: "baked" | "loader";
+  /** Immutable, value-free schema observation captured for every task project
+   * before any task-controlled process started. Absent means a legacy host. */
+  envSchemas?: ProjectEnvSchemaObservation[];
   /** Degraded start: uai-init failed twice; the task is up without deps/editor. */
   initWarning?: string;
 }
@@ -1693,16 +3890,19 @@ export type CloudToHost =
   // mirrored parameter for the tag-scoped task-machine lease policy (ADR-133,
   // docs/credential-store.md). A list carrying it also backfills rows that
   // were mirrored before the org was known. Absent from an older cloud.
-  | { kind: "env.var.list"; opId: string; projectId: string; orgId?: string }
-  | {
-      kind: "env.var.set";
-      opId: string;
-      projectId: string;
-      key: string;
-      value: string;
-      orgId?: string;
-    }
-  | { kind: "env.var.delete"; opId: string; projectId: string; key: string }
+  | ProjectEnvListFrame
+  | ProjectEnvSetFrame
+  | ProjectEnvDeleteFrame
+  | ProjectEnvRemoveFrame
+  | ProjectEnvBindingSetFrame
+  | ProjectEnvReconcileBeginFrame
+  | ProjectEnvReconciledFrame
+  | ProjectEnvDeliverySkipFrame
+  | ProjectEnvStagingPutFrame
+  | ProjectEnvReplicaBeginFrame
+  | ProjectEnvReplicaPageFrame
+  | ProjectEnvReplicaApplyFrame
+  | ProjectEnvReplicaCommitFrame
   // User-authed MCP connections (ADR-057). Ops run entirely host-side —
   // discovery, DCR, PKCE, token exchange, encrypted storage. Secrets in a
   // probe (headerValue, clientSecret) are write-only; nothing secret ever
@@ -1893,11 +4093,15 @@ export type HostToCloud =
   // is null when the user has no key (after delete, or a get-miss).
   | { kind: "ssh.key.ack"; userId: string; ok: true; publicKey: string | null }
   | { kind: "ssh.key.ack"; userId: string; ok: false; error: string }
-  // Ack for env.var.list / env.var.set / env.var.delete. Returns the project's
-  // KEY NAMES only — values never cross the bridge (secret-blind, ADR-015).
-  // `opId` correlates to the request.
-  | { kind: "env.var.ack"; opId: string; ok: true; keys: string[] }
-  | { kind: "env.var.ack"; opId: string; ok: false; error: string }
+  // Acks for project-env inventory and mutations. Modern acks carry only
+  // record metadata, policy epochs and an ordered delivery cursor; values
+  // never cross back (secret-blind, ADR-015). Omitting all modern metadata is
+  // the legacy shape, not an unbound modern host.
+  | ProjectEnvAckFrame
+  | ProjectEnvReconcileAckFrame
+  | ProjectEnvDeliveryAckFrame
+  | ProjectEnvStagingAckFrame
+  | ProjectEnvReplicaAckFrame
   // Ack for mcp.op (ADR-057). `connected` = usable now; `auth_required` =
   // open authorizeUrl in the user's browser and wait for the callback;
   // `disconnected` = secrets gone. No secret material ever crosses back.