@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/contract.js

@@ -1,6 +1,6 @@
 import { CLAUDE_PASTED_CODE, CODEX_DEVICE_CODE, GROK_DEVICE_CODE } from "./agent-logins.js";
 
-export const KIT_CONTRACT_VERSION = "2026-09-27-private-room-scope";
+export const KIT_CONTRACT_VERSION = "3";
 export const KIT_CAPTURE_BATCH_MAX = 100;
 export const COMMAND_INPUT_MAX_BYTES = 4 * 1024;
 export const AUTHORIZATION_OUTPUT_MAX_BYTES = 4 * 1024;
@@ -21,10 +21,11 @@ export const COMMAND_ADAPTER_SESSION_TIMEOUT_MS = 30_000;
 export const WORKER_EXIT_GRACE_MS = 5_000;
 export const WORKER_EXIT_POLL_MS = 100;
 export const WORKER_SUPERVISION_POLL_MS = 2_000;
-export const WORKER_COMMAND_POLL_MS = 2_000;
-export const WORKER_HEARTBEAT_MS = 30_000;
 export const WORKER_COMMAND_BATCH_MAX = 10;
 export const WORKER_RUN_TOKEN_MARGIN_MS = 60_000;
+export const KIT_STREAM_RECONNECT_MS = 1_000;
+export const KIT_STREAM_RECONNECT_MAX_MS = 30_000;
+export const KIT_STREAM_REJOIN_MS = 2_000;
 export const TELEGRAM_IMAGE_UPLOAD_CEILING_BYTES = 10 * 1024 * 1024;
 export const CONVERSATION_FILE_TRANSFER_TIMEOUT_MS = 30_000;
 export const WORKER_INHERITED_ENVIRONMENT = ["PATH", "HOME"];
@@ -40,17 +41,15 @@ export function runOutcomePath(run) {
   return `/kit/runs/${encodeURIComponent(run)}/outcome`;
 }
 
+export function runRequestPath(run) {
+  return `/kit/runs/${encodeURIComponent(run)}/request`;
+}
+
 export const KIT_SESSIONS_REPORT_PATH = "/kit/sessions/report";
 export const KIT_SESSIONS_REPORT_MAX = 256;
 
-export const ASSISTANT_TEXT_MAX_BYTES = 4096;
-export const ASSISTANT_BLOCKS_MAX = 500;
 export const ASSISTANT_TABLE_COLUMNS_MAX = 20;
 
-export function assistantDraftsPath(workerSession) {
-  return `/kit/sessions/${encodeURIComponent(workerSession)}/drafts`;
-}
-
 export function assistantTextPath(workerSession) {
   return `/kit/sessions/${encodeURIComponent(workerSession)}/assistant-messages`;
 }
@@ -61,6 +60,10 @@ export const TELEGRAM_DELIVERY_BATCH_MAX = 10;
 export const TELEGRAM_DOWNLOAD_CEILING_BYTES = 20 * 1024 * 1024;
 export const TELEGRAM_BOT_API_TIMEOUT_MS = 30_000;
 export const TELEGRAM_GATEWAY_POLL_MS = 2_000;
+export const TELEGRAM_RICH_MESSAGE_CHARACTERS_MAX = 32_768;
+export const TELEGRAM_MESSAGE_CHARACTERS_MAX = 4_096;
+export const TELEGRAM_CAPTION_CHARACTERS_MAX = 1_024;
+export const TELEGRAM_RICH_MESSAGE_BLOCKS_MAX = 500;
 export const TELEGRAM_CONTROL_KEYBOARD_COMMANDS = ["/stop", "/kill"];
 export const TELEGRAM_MEDIA_KINDS = [
   "document",
@@ -114,6 +117,10 @@ export const BRIDGE_NONCE_ENVIRONMENT = "HOUSE_KIT_BRIDGE_NONCE";
 export const BRIDGE_RECONNECT_MS = 200;
 export const BRIDGE_RECONNECT_MAX_MS = 5_000;
 
+export const HOUSE_CLI_LINE = "The agents.house house CLI is available: run house --help.";
+export const HOW_WE_WORK_PATH = "/private/library/how-we-work.md";
+export const SHELL_RENDER = "shell/1";
+
 export const ACP_PROTOCOL = 1;
 export const ACP_AUTH_REQUIRED = -32000;
 export const ADAPTER_EXIT_GRACE_MS = 2_000;
@@ -195,7 +202,7 @@ export const ADAPTER_CONTRACTS = Object.freeze({
     guidedLogin: CLAUDE_PASTED_CODE,
     identity: Object.freeze({ agentInfo: "@agentclientprotocol/claude-agent-acp" }),
     nativeQuestion: null,
-    sessionLoad: false,
+    sessionLoad: true,
     sessionConfig: Object.freeze({ model: "model", effort: "effort" }),
     capabilities: Object.freeze({
       field_kinds: ELICITATION_FIELD_KINDS,
@@ -251,6 +258,10 @@ export const KIT_LOGIN_REPORT_PATH = "/kit/logins/report";
 export const GUIDED_LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
 export const GUIDED_LOGIN_OUTPUT_MAX_BYTES = 64 * 1024;
 
+export const KIT_SOURCES_DESIRED_PATH = "/kit/sources/desired";
+export const KIT_SOURCES_REPORT_PATH = "/kit/sources/report";
+export const SOURCE_CAPTURE_INTERVAL_MS = 15 * 60 * 1000;
+
 export const EXECUTION_AUTHORITIES = ["allow", "refuse"];
 
 export const PERMISSION_OPTION_KINDS = Object.freeze({
@@ -265,16 +276,21 @@ export const KIT_WORKSPACES_ACQUIRE_PATH = "/kit/workspaces/acquire";
 export const WORKSPACE_ACQUIRE_MAX = 10;
 export const WORKSPACE_POLL_MS = 2_000;
 export const WORKSPACE_LABEL = "house-kit.workspace";
-export const WORKSPACE_MOUNT = "/workspace";
-export const WORKSPACE_KIT_HOME = "/workspace/.house-kit";
+export const WORKSPACE_KIT_HOME = "/kit-home";
 export const WORKSPACE_DISK_IMAGE = "disk.img";
 export const WORKSPACE_DISK_MOUNT = "mnt";
+export const WORKSPACE_PREVIOUS_SUFFIX = "-previous";
+export const WORKSPACE_DISK_KIT_HOME = "kit-home";
+export const WORKSPACE_DISK_HOUSE = "house";
+export const WORKSPACE_SELECTED_IMAGE = "/opt/house-kit/image";
+export const WORKSPACE_RELEASE_IMAGE = /^ghcr\.io\/agentshouse\/kit@sha256:[0-9a-f]{64}$/;
 export const WORKSPACE_MOUNT_OPTIONS = "loop,nosuid,nodev";
 export const HOST_MOUNT_INFO = "/proc/self/mountinfo";
 export const WORKSPACE_SYSTEM_RESERVE_BYTES = 512 * 1024 * 1024;
 export const WORKSPACE_COMMAND_TIMEOUT_MS = 120_000;
 export const WORKSPACE_READY_ATTEMPTS = 60;
 export const WORKSPACE_READY_POLL_MS = 1_000;
+export const WORKSPACE_LOCK_POLL_MS = 1_000;
 export const WORKSPACE_STOP_TIMEOUT_SECONDS = 10;
 export const WORKSPACE_OPERATION_WITHDRAWN = "hosted_environment_operation_not_found";
 export const CGROUP_CONTROLLERS = "/sys/fs/cgroup/cgroup.controllers";
@@ -288,9 +304,25 @@ export const KIT_DOOR_DISCOVER_PATH = "/kit/door/discover";
 export const KIT_DOOR_BOOTSTRAP_PATH = "/kit/door/bootstrap";
 export const KIT_DOOR_ENUMERATE_PATH = "/kit/door/enumerate";
 export const KIT_DOOR_BATCH_PATH = "/kit/door/batch";
+export const KIT_DOOR_REVISIONS_PATH = "/kit/door/revisions";
 export const EXPLICIT_SYNC_VERSION = "explicit-sync/2";
 export const KIT_DOOR_UNMOUNT_PATH = "/kit/door/unmount";
 
+export const KIT_WORKING_COPY_SELECTION_PATH = "/kit/working-copy/selection";
+export const WORKING_COPY_VERSION = "working-copy-state/3";
+export const WORKING_COPIES_HOME = "working-copies";
+export const WORKING_COPY_ROOM_HOMES = ["capture", "library", "collaboration"];
+export const WORKING_COPY_PRIVATE_HOMES = ["library", "collaboration", "rooms", "agents", "house"];
+export const WORKING_COPY_RECEIVED_REF = "refs/house/received";
+export const WORKING_COPY_BRANCH = "main";
+export const ROOM_REFERENCE = /^r_[0-9a-z]+\.[0-9a-z]$/;
+export const WORKING_COPY_PUSH_METHOD = "house/git/push";
+export const WORKING_COPY_INDEX_METHOD = "house/git/index";
+export const WORKING_COPY_PUSH_HELP =
+  "Submit a Room commit to House; default HEAD. Use --owner only outside an Agent Session. Native git push is not a House remote.";
+export const WORKING_COPY_UPLOAD_COMMAND = "prepare_edit_upload";
+export const MCP_REQUEST_BODY_MAX_BYTES = 4 * 1024 * 1024;
+
 export const MIGRATOR_CONTRACT = "kit-migrator/1";
 export const MIGRATOR_CATEGORY = "migrator";
 export const MIGRATOR_MANIFEST = "migrator.json";

package/src/conversation-originals.js

@@ -43,9 +43,7 @@ export async function holdConversationFile(context, file, bytes) {
   const path = statePath(context.directory, identity);
   const noted = await readNote(path, null);
   const observed = bytes === null || oversized ? null : describedBytes(bytes);
-  // House fixes a version's descriptor the first time one is declared and refuses
-  // every later one, so a file held again keeps the descriptor its note carries.
-  // Bytes that no longer answer that descriptor are not this original's bytes.
+
   const descriptor = noted?.descriptor ?? observed;
   const beyondBound = descriptor === null && (oversized || noted?.exceeded === true);
   const held = {

package/src/delivery.js

@@ -54,10 +54,8 @@ const FAILURE_CATEGORIES = {
   google_provider_unavailable: "provider",
   google_provider_response_invalid: "provider",
   google_checkpoint_invalid: "provider",
-  google_service_unsupported: "config",
-  google_oauth_client_unconfigured: "config",
-  google_drive_selection_exceeded: "config",
   google_drive_item_missing: "provider",
+  api_disabled: "config",
 };
 
 export function fileDescriptor(file) {
@@ -184,8 +182,7 @@ export function stallOf(code, houseRetry = null) {
 
 export function healthOfRun(stall) {
   if (stall === null) return { state: "ok", category: null };
-  return {
-    state: stall.disposition === "retry" ? "retrying" : "failed",
-    category: stall.category ?? FAILURE_CATEGORIES[stall.code] ?? "internal",
-  };
+  const category = stall.category ?? FAILURE_CATEGORIES[stall.code] ?? "internal";
+  if (stall.disposition === "retry") return { state: "retrying", category };
+  return { state: "failed", category, cause: stall.code };
 }

package/src/directory.js

@@ -1,10 +1,8 @@
 import { constants } from "node:fs";
-import { access, mkdir, realpath, rename, rm, stat } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { access, mkdir, realpath, stat } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { LAUNCH_DIRECTORY_BASE } from "./contract.js";
 import { KitRefusal } from "./refusal.js";
-import { seedStarterSet } from "./starter-set.js";
 
 export function launchBase(dependencies = {}) {
   return dependencies.launchBase ?? LAUNCH_DIRECTORY_BASE;
@@ -39,25 +37,9 @@ function unavailable(path, cause) {
   return new KitRefusal("kit_launch_directory_unavailable", `${path} ${cause}`);
 }
 
-async function isDirectory(path) {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch {
-    return false;
-  }
-}
-
-async function seedDefaultDirectory(selected, base, path) {
-  const staging = join(base, `.${randomUUID()}.staging`);
-  try {
-    await seedStarterSet(staging);
-    await rename(staging, path);
-  } catch (error) {
-    await rm(staging, { recursive: true, force: true }).catch(() => undefined);
-    if (!(await isDirectory(path))) {
-      throw unavailable(selected, `could not be prepared (${error.code ?? "unknown"})`);
-    }
-  }
+async function createDefaultDirectory(selected, path) {
+  const refused = await made(path);
+  if (refused !== null) throw unavailable(selected, `could not be created (${refused})`);
 }
 
 function within(base, selected) {
@@ -73,9 +55,7 @@ export async function readyLaunchDirectory(selected, base, agentId = null, optio
   if (options.container && !within(resolve(base), path)) {
     throw unavailable(selected, `resolves outside ${base}`);
   }
-  if (path === defaultDirectory(base, agentId) && !(await isDirectory(path))) {
-    await seedDefaultDirectory(selected, base, path);
-  }
+  if (path === defaultDirectory(base, agentId)) await createDefaultDirectory(selected, path);
   let described;
   try {
     described = await stat(path);

package/src/draft.js

@@ -1,89 +1,11 @@
-import { assistantBlocks, blocksText, withinAssistantBound } from "./blocks.js";
-
-const DRAFT_INTERVAL_MS = 500;
+import { pacedLatest } from "./pacing.js";
 
 export function observedAssistantDrafts(options) {
-  const intervalMs = options.intervalMs ?? DRAFT_INTERVAL_MS;
-  const now = options.now ?? (() => Date.now());
-  let timer = null;
-  let sentAt = null;
-  let sent = null;
-  let latest = null;
-
-  function write() {
-    timer = null;
-    if (latest === null || latest === sent) return;
-    sent = latest;
-    sentAt = now();
-    options.send(sent);
-  }
-
-  function cancel() {
-    if (timer === null) return;
-    clearTimeout(timer);
-    timer = null;
-  }
-
+  const paced = pacedLatest(options);
   return {
     observe(view) {
-      if (typeof view !== "string" || view === "") return;
-      latest = view;
-      if (timer !== null) return;
-      const wait = sentAt === null ? 0 : sentAt + intervalMs - now();
-      if (wait <= 0) {
-        write();
-        return;
-      }
-      timer = setTimeout(write, wait);
-      timer.unref?.();
-    },
-    complete(view) {
-      if (typeof view !== "string" || view === "") return;
-      latest = view;
-      cancel();
-      write();
-    },
-    close: cancel,
-  };
-}
-
-export function openAssistantDrafts(options) {
-  let pending = null;
-  let sending = null;
-  let sent = null;
-  let closed = false;
-
-  function pump() {
-    if (sending !== null || pending === null) return;
-    const view = pending;
-    pending = null;
-    sent = view.text;
-    let started;
-    try {
-      started = Promise.resolve(options.send(view.blocks));
-    } catch {
-      started = Promise.resolve();
-    }
-    sending = started
-      .catch(() => undefined)
-      .finally(() => {
-        sending = null;
-        pump();
-      });
-  }
-
-  return {
-    update(text) {
-      if (closed || typeof text !== "string" || text === "") return;
-      if (text === sent || text === pending?.text) return;
-      const blocks = assistantBlocks(text);
-      if (blocks === null || !withinAssistantBound(blocksText(blocks))) return;
-      pending = { text, blocks };
-      pump();
-    },
-    close() {
-      closed = true;
-      pump();
+      if (typeof view === "string" && view !== "") paced.observe(view);
     },
+    close: paced.close,
   };
 }

package/src/git-main.js

@@ -0,0 +1,138 @@
+import { spawn, spawnSync } from "node:child_process";
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { constants as system } from "node:os";
+import { delimiter, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_INDEX_METHOD,
+  WORKING_COPY_RECEIVED_REF,
+} from "./contract.js";
+import { bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+
+const SHIM = realpathSync(fileURLToPath(new URL("session-bin/git", import.meta.url)));
+const VALUED = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--attr-source", "--super-prefix"]);
+const RELAYED = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+
+function nativeGit() {
+  for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+    if (directory === "") continue;
+    const candidate = join(directory, "git");
+    try {
+      if (!statSync(candidate).isFile() || realpathSync(candidate) === SHIM) continue;
+      accessSync(candidate, constants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
+
+function command(args) {
+  let index = 0;
+  while (index < args.length && args[index].startsWith("-")) index += VALUED.has(args[index]) ? 2 : 1;
+  return { globals: args.slice(0, index), name: args[index], rest: args.slice(index + 1) };
+}
+
+function delegated(git, args) {
+  return new Promise((resolve) => {
+    const child = spawn(git, args, { stdio: "inherit" });
+    const relay = (signal) => child.kill(signal);
+    for (const signal of RELAYED) process.on(signal, relay);
+    const settle = (outcome) => {
+      for (const signal of RELAYED) process.off(signal, relay);
+      resolve(outcome);
+    };
+    child.once("error", (error) => {
+      process.stderr.write(`kit_git_unavailable: ${error.message}\n`);
+      settle({ status: 127, signal: null });
+    });
+    child.once("close", (status, signal) => settle({ status, signal }));
+  });
+}
+
+function captured(git, args, env = process.env) {
+  const run = spawnSync(git, args, { stdio: ["ignore", "pipe", "ignore"], maxBuffer: Infinity, env });
+  return run.status === 0 ? run.stdout.toString("utf8") : null;
+}
+
+function indexed(listing) {
+  const entries = new Map();
+  for (const record of listing.split("\0")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0) continue;
+    const [mode, object, stage] = record.slice(0, tab).split(" ");
+    entries.set(record.slice(tab + 1), stage === "0" ? `${mode} ${object}` : null);
+  }
+  return entries;
+}
+
+function renamings(output) {
+  return (output ?? "").split("\n").filter((line) => line.startsWith("Renaming ")).map((line) => line.slice(9));
+}
+
+function movedPaths(renaming, before, after) {
+  for (let at = renaming.indexOf(" to "); at >= 0; at = renaming.indexOf(" to ", at + 1)) {
+    const from = renaming.slice(0, at);
+    const to = renaming.slice(at + 4);
+    if (before.has(from) && !after.has(from) && after.get(to) === before.get(from)) return [{ from, to }];
+  }
+  return [];
+}
+
+async function recorded(cwd, change) {
+  const socket = process.env[BRIDGE_SOCKET_ENVIRONMENT];
+  const nonce = process.env[BRIDGE_NONCE_ENVIRONMENT];
+  if (socket === undefined || nonce === undefined) return;
+  try {
+    const frame = await bridgeCall({ socket, nonce }, { method: WORKING_COPY_INDEX_METHOD, params: { cwd, ...change } });
+    if (frame.error !== undefined) throw new KitRefusal(frame.error.message ?? "kit_house_refused");
+  } catch (refusal) {
+    process.stderr.write(`${formatCommandError(refusal)}: house git push will not see this index change\n`);
+  }
+}
+
+async function observed(git, { globals, name, rest }, args) {
+  const located = captured(git, [...globals, "rev-parse", "--show-toplevel", "--show-cdup", WORKING_COPY_RECEIVED_REF, "HEAD"]);
+  if (located === null) return delegated(git, args);
+  const [top, cdup, , head] = located.split("\n");
+  const listing = [...globals, "ls-files", "--stage", "-z", "--full-name", "--", cdup === "" ? "." : cdup];
+  const before = captured(git, listing);
+  const rehearsal = [...globals, "mv", "--dry-run", ...rest];
+  const planned = name === "mv" ? renamings(captured(git, rehearsal, { ...process.env, LC_ALL: "C" })) : [];
+  const outcome = await delegated(git, args);
+  const after = before === null ? null : captured(git, listing);
+  if (after === null) return outcome;
+  const [prior, next] = [indexed(before), indexed(after)];
+  const moves = outcome.status === 0 ? planned.flatMap((renaming) => movedPaths(renaming, prior, next)) : [];
+  const sources = new Set(moves.map((move) => move.from));
+  const destinations = new Set(moves.map((move) => move.to));
+  const gone = [...prior.keys()].filter((path) => !next.has(path) && !sources.has(path));
+  const arrived = [...next.keys()].filter((path) => !prior.has(path) && !destinations.has(path));
+  const heads = captured(git, [...globals, "rev-parse", "HEAD", ...(name === "rebase" ? ["ORIG_HEAD"] : [])]);
+  const [current, tip = head] = heads?.trim().split("\n") ?? [];
+  const commit = current === undefined || current === head ? [] : [tip, current];
+  if (moves.length > 0 || gone.length > 0 || arrived.length > 0 || commit.length > 0) {
+    await recorded(top, { moves, gone, arrived, commit, command: name });
+  }
+  return outcome;
+}
+
+async function run(args) {
+  const git = nativeGit();
+  if (git === null) {
+    process.stderr.write("kit_git_unavailable\n");
+    return { status: 127, signal: null };
+  }
+  return observed(git, command(args), args);
+}
+
+run(process.argv.slice(2)).then(({ status, signal }) => {
+  if (signal === null) {
+    process.exitCode = status;
+    return;
+  }
+  process.exitCode = 128 + system.signals[signal];
+  process.kill(process.pid, signal);
+});

package/src/git.js

@@ -0,0 +1,62 @@
+import { spawn } from "node:child_process";
+import { KitRefusal } from "./refusal.js";
+
+function cancelledOr(signal, error, code) {
+  return signal?.aborted === true || error?.name === "AbortError"
+    ? new KitRefusal("kit_command_cancelled")
+    : new KitRefusal(code);
+}
+
+function stdio(capture, input) {
+  if (input !== null) return ["pipe", capture ? "pipe" : "inherit", "inherit"];
+  return capture ? ["ignore", "pipe", "inherit"] : "inherit";
+}
+
+export function runGit(cwd, args, options = {}) {
+  const { dependencies = {}, capture = false, input = null, signal, failure } = options;
+  if (signal?.aborted === true) return Promise.reject(new KitRefusal("kit_command_cancelled"));
+  const launcher = dependencies.spawn ?? spawn;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = launcher("git", args, {
+        cwd,
+        env: process.env,
+        stdio: stdio(capture, input),
+        signal,
+        killSignal: "SIGKILL",
+      });
+    } catch (error) {
+      reject(cancelledOr(signal, error, "kit_git_unavailable"));
+      return;
+    }
+    const output = [];
+    let settled = false;
+    const finish = (operation) => {
+      if (settled) return;
+      settled = true;
+      operation();
+    };
+    child.stdout?.on("data", (chunk) => output.push(Buffer.from(chunk)));
+    child.once("error", (error) =>
+      finish(() => reject(cancelledOr(signal, error, "kit_git_unavailable"))),
+    );
+    child.once("close", (status) => {
+      finish(() => {
+        if (signal?.aborted === true) {
+          reject(new KitRefusal("kit_command_cancelled"));
+          return;
+        }
+        if (status !== 0) {
+          reject(new KitRefusal(failure));
+          return;
+        }
+        resolve(Buffer.concat(output));
+      });
+    });
+    if (input !== null) {
+      child.stdin.on("error", () => undefined);
+      child.stdin.end(input);
+    }
+  });
+}

package/src/google/calendar.js

@@ -4,9 +4,10 @@ import { googleJson } from "./gateway.js";
 import { GOOGLE_SCOPES } from "./oauth.js";
 
 const CALENDAR_ORIGIN = "https://www.googleapis.com";
+const CALENDAR = "primary";
 
-function cursorOf(value, calendars) {
-  if (value === null) return { calendar: 0, pageToken: null, syncTokens: {} };
+function cursorOf(value) {
+  if (value === null) return { pageToken: null, syncToken: null };
   let cursor;
   try {
     cursor = JSON.parse(value);
@@ -16,16 +17,8 @@ function cursorOf(value, calendars) {
   if (
     typeof cursor !== "object" ||
     cursor === null ||
-    !Number.isInteger(cursor.calendar) ||
-    cursor.calendar < 0 ||
-    cursor.calendar >= calendars.length ||
     (cursor.pageToken !== null && typeof cursor.pageToken !== "string") ||
-    typeof cursor.syncTokens !== "object" ||
-    cursor.syncTokens === null ||
-    Array.isArray(cursor.syncTokens) ||
-    Object.entries(cursor.syncTokens).some(
-      ([calendar, token]) => !calendars.includes(calendar) || typeof token !== "string",
-    )
+    (cursor.syncToken !== null && typeof cursor.syncToken !== "string")
   ) {
     throw new KitRefusal("google_checkpoint_invalid", "calendar");
   }
@@ -45,7 +38,7 @@ function authorOf(event) {
     : event.organizer.email;
 }
 
-function normalizedEvent(event, calendar) {
+function normalizedEvent(event) {
   if (
     typeof event?.id !== "string" ||
     typeof event.etag !== "string" ||
@@ -71,45 +64,53 @@ function normalizedEvent(event, calendar) {
     author: authorOf(event),
     url: event.htmlLink ?? null,
     attachments: [],
-    container: `google/calendar/${calendar}`,
+    container: `google/calendar/${CALENDAR}`,
   };
 }
 
-function pageUrl(calendar, cursor, limit, backfillFloor) {
-  const url = new URL(
-    `/calendar/v3/calendars/${encodeURIComponent(calendar)}/events`,
-    CALENDAR_ORIGIN,
-  );
+function common(options) {
+  return {
+    directory: options.directory,
+    account: options.account,
+    requiredScopes: [GOOGLE_SCOPES.calendar],
+    signal: options.signal,
+  };
+}
+
+function pageUrl(cursor, limit, backfillFloor) {
+  const url = new URL(`/calendar/v3/calendars/${CALENDAR}/events`, CALENDAR_ORIGIN);
   url.searchParams.set("maxResults", `${limit}`);
   url.searchParams.set("singleEvents", "true");
   url.searchParams.set("showDeleted", "true");
   if (cursor.pageToken !== null) url.searchParams.set("pageToken", cursor.pageToken);
-  const syncToken = cursor.syncTokens[calendar];
-  if (syncToken !== undefined) url.searchParams.set("syncToken", syncToken);
+  if (cursor.syncToken !== null) url.searchParams.set("syncToken", cursor.syncToken);
   else if (backfillFloor !== null && backfillFloor !== undefined) {
     url.searchParams.set("timeMin", backfillFloor);
   }
   return url.toString();
 }
 
+export async function calendarEmail(options, dependencies = {}) {
+  const calendar = await googleJson(
+    { ...common(options), url: `${CALENDAR_ORIGIN}/calendar/v3/calendars/${CALENDAR}` },
+    dependencies,
+  );
+  if (typeof calendar.id !== "string") {
+    throw new KitRefusal("google_provider_response_invalid", "calendar");
+  }
+  return calendar.id;
+}
+
 export async function calendarPage(options, dependencies = {}) {
-  const calendars = options.selection.calendars;
-  let cursor = cursorOf(options.cursor, calendars);
-  const calendar = calendars[cursor.calendar];
-  const common = {
-    directory: options.directory,
-    instance: options.instance,
-    client: options.client,
-    requiredScopes: [GOOGLE_SCOPES.calendar],
-    signal: options.signal,
-  };
+  let cursor = cursorOf(options.cursor);
+  const shared = common(options);
   let answer;
   try {
     answer = await googleJson(
       {
-        ...common,
+        ...shared,
         goneCode: "google_calendar_cursor_expired",
-        url: pageUrl(calendar, cursor, options.limit, options.backfillFloor),
+        url: pageUrl(cursor, options.limit, options.backfillFloor),
       },
       dependencies,
     );
@@ -117,11 +118,9 @@ export async function calendarPage(options, dependencies = {}) {
     if (!(error instanceof KitRefusal) || error.code !== "google_calendar_cursor_expired") {
       throw error;
     }
-    const syncTokens = { ...cursor.syncTokens };
-    delete syncTokens[calendar];
-    cursor = { calendar: cursor.calendar, pageToken: null, syncTokens };
+    cursor = { pageToken: null, syncToken: null };
     answer = await googleJson(
-      { ...common, url: pageUrl(calendar, cursor, options.limit, options.backfillFloor) },
+      { ...shared, url: pageUrl(cursor, options.limit, options.backfillFloor) },
       dependencies,
     );
   }
@@ -135,23 +134,18 @@ export async function calendarPage(options, dependencies = {}) {
   }
   let next;
   if (answer.nextPageToken !== undefined) {
-    next = { calendar: cursor.calendar, pageToken: answer.nextPageToken, syncTokens: cursor.syncTokens };
+    next = { pageToken: answer.nextPageToken, syncToken: cursor.syncToken };
   } else {
     if (typeof answer.nextSyncToken !== "string") {
       throw new KitRefusal("google_provider_response_invalid", "calendar sync token");
     }
-    const syncTokens = { ...cursor.syncTokens, [calendar]: answer.nextSyncToken };
-    next = {
-      calendar: cursor.calendar + 1 === calendars.length ? 0 : cursor.calendar + 1,
-      pageToken: null,
-      syncTokens,
-    };
+    next = { pageToken: null, syncToken: answer.nextSyncToken };
   }
   const normalized = [];
   const dropped = [];
   for (const event of items) {
     try {
-      normalized.push(normalizedEvent(event, calendar));
+      normalized.push(normalizedEvent(event));
     } catch (error) {
       if (
         error instanceof KitRefusal &&
@@ -172,6 +166,6 @@ export async function calendarPage(options, dependencies = {}) {
     items: normalized,
     dropped,
     cursor: JSON.stringify(next),
-    more: answer.nextPageToken !== undefined || cursor.calendar + 1 < calendars.length,
+    more: answer.nextPageToken !== undefined,
   };
 }