@agentshouse/kit 0.1.0-alpha.17 → 0.1.0-alpha.19

package/README.md

@@ -10,7 +10,7 @@ On Linux `amd64` or `arm64` with a working Docker Engine, run the published,
 versioned bootstrap once:
 
 ```sh
-bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh)
+bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.19/connect-linux.sh)
 ```
 
 The release asset pins one immutable multi-architecture image digest. It creates
@@ -105,6 +105,14 @@ Forwarding installs no host-native Kit and gives the container no Docker socket
 or further mount; it refuses when no Kit is installed or the installed one
 differs from this bootstrap's.
 
+The owner's working copy push is forwarded the same way: run
+`bash <(curl -fsSL …/connect-linux.sh) house git push [commit] --owner` from a
+directory beneath the workspace root, such as a Room copy under
+`working-copies/rooms/`. The bootstrap runs the container's `house` in the
+matching directory beneath `/agents/house`, through the resident's lease when
+the container runs, and refuses a directory outside the workspace before
+anything reaches House.
+
 ## Building the package
 
 The repository checkout is the development source. Build the package
@@ -829,7 +837,9 @@ nonzero exit status. The CLI holds
 no credential: it calls over its Session's bridge, which attaches the Session
 credential and refuses a caller without that Session's nonce as
 `kit_bridge_unauthorized`. House network calls use only the selected
-`2026-07-28` profile.
+`2026-07-28` profile. `house git push` is the one local verb House does not list;
+[working copies](#working-copies) describe it, and `house --help` and
+`house git push --help` explain it.
 
 Two verbs name files on the Session's own computer: `upload_attachment` takes
 one `path`, and `append_record` takes `attachments` as local paths. The CLI
@@ -1248,14 +1258,54 @@ current grant. Every other file is read-only House content: the generated
 grants anything, and House refuses a change to a read-only path however it is
 committed.
 
-Local edits, staging and commits change nothing in House. `refs/house/received`
-records the House content last received. The per-file manifest, with each
-file's House revision, digest and writability, and the commit it corresponds to
-stay in Kit home under `state/working-copies/`, outside the repository. A local
-commit is a local tree, never a House revision.
+Local edits, staging and commits change nothing in House until a commit is
+pushed. `refs/house/received` records the House content last received; each
+commit Kit wrote there, and each commit it acknowledged for a push, is a House
+state. The House revision of every file content Kit received, keyed by path and
+Git blob, stays in Kit home under `state/working-copies/`, outside the
+repository. A local commit is a local tree, never a House revision.
+
+`house git push [commit]`, run anywhere inside a copy or one of its linked
+worktrees, submits one commit, `HEAD` by default, resolved once. Kit compares
+that commit's tree with the newest House state in its history, so every linked
+worktree keeps its own base, and sends the difference as one ordinary House edit:
+a changed field, section or preamble against its own prior value, any other
+change as the whole file against its exact revision, a new file as a create and
+a committed deletion as a removal. Staged and unstaged work, and files absent
+only from the working tree, are never sent. Native `git push` reaches no House
+remote. Inside an Agent Session the push goes through that Session's bridge,
+under its own authority and provenance; outside one it needs
+`house git push [commit] --owner`, which the resident Kit carries out under its
+control lease when a resident runs, and which otherwise acquires and releases
+its own. A Session refuses `--owner`, and a missing bridge is never replaced by
+owner authority.
+
+House decides before any local Git step. A refusal changes nothing in House;
+after `edit_conflict` Kit records the current content House names for the
+refused paths in `refs/house/received`, reading by revision any content the
+refusal does not carry, so the agent merges or rebases onto it with native Git,
+commits, and pushes again. After acceptance Kit records House's result for the
+pushed paths, the contents an owner push receives or each accepted revision
+read by name, in a commit that covers the pushed one and in
+`refs/house/received`; a read-only path House regenerates, such as the Wiki
+index, stays out of Git. Kit then
+fast-forwards a clean branch still at the pushed commit, or rebases only its
+later commits. A result not yet readable, uncommitted tracked changes,
+a moved branch or a rebase conflict leave the branch as it was, with no stash or
+reset, and the push answers that House accepted it while local integration is
+pending; the next `house git push` finishes that integration without another
+House edit. A push whose answer was lost is recorded in Kit home before it is
+sent, and the next push by the same Session, or by the owner for an owner push,
+resends it under its original operation. Another caller cannot
+recover it: while the pushing Session lives it is refused as
+`kit_working_copy_push_pending`, and once that Session has ended Kit reads House
+again and drops it. When a retained push's operation has expired, Kit reads the
+Room again: if House holds the pushed content the push finishes as accepted,
+otherwise it is dropped and the next push submits it as a new operation.
 
 Deselecting a Room, or losing read access to it, marks its copy inactive:
-launches omit it and nothing local is deleted. Selecting it again reads the Room
+launches omit it, a new push is refused as `kit_working_copy_inactive`, and
+nothing local is deleted; a push already sent still settles and integrates. Selecting it again reads the Room
 again, advances `refs/house/received`, and replaces only the read-only content
 Kit wrote, never the branch, the index or a tracked file. A Room the owner may
 read without sync is refused as `operation_denied` and stays uncopied, while its
@@ -1298,8 +1348,7 @@ Library paths are House metadata, not authored Library documents. `pull` present
 each recorded position with its log epoch, applies each enumerated path's whole
 content or removal, and advances those positions. A position older than House's
 declared retention, or one of a log epoch before House's database was restored,
-is reported as `position_expired` with rematerialization as the remedy; only
-`rebootstrap` rebuilds the directory.
+is reported as `position_expired`; only `rebootstrap` rebuilds the directory.
 
 `submit` sends field, section, and preamble operations with that value's prior
 content as base, and whole-file, rename, and removal operations with the file

package/bin/connect-linux.sh

@@ -9,6 +9,7 @@ MANUAL=0
 WORKSPACE_SELECTED=0
 HOUSE_SELECTED=0
 FORWARDING=0
+FORWARDED=kit
 FORWARD=()
 
 refuse() {
@@ -41,8 +42,9 @@ start_resident() {
   docker run -d --name "$NAME" --restart unless-stopped --user "$(id -u):$(id -g)" --mount "$KIT_HOME_MOUNT" --mount "$WORKSPACE_MOUNT" --label "agentshouse.house=$HOUSE" --env HOME=/kit-home --env HOUSE_KIT_HOME=/kit-home --env HOUSE_KIT_CONTAINER=1 "$IMAGE" resident --house "$HOUSE" >/dev/null
 }
 
-if [[ "${1:-}" == kit ]]; then
+if [[ "${1:-}" == kit || "${1:-}" == house ]]; then
   FORWARDING=1
+  FORWARDED="$1"
   FORWARD=("${@:2}")
   set --
 fi
@@ -129,10 +131,18 @@ if docker container inspect "$NAME" >/dev/null 2>&1; then
   [[ "$(docker inspect --format '{{index .Config.Labels "agentshouse.house"}}' "$NAME")" == "$HOUSE" ]] || refuse 'the installed Kit uses another House origin'
   [[ -f "$KIT_HOME/credential" && -f "$KIT_HOME/environment" && -f "$KIT_HOME/house" ]] || refuse 'the installed Kit has no enrolled authority'
   if ((FORWARDING)); then
-    if [[ "${FORWARD[0]:-}" == login ]]; then
+    if [[ "$FORWARDED" == kit && "${FORWARD[0]:-}" == login ]]; then
       login_kit "${FORWARD[@]:1}"
       exit 0
     fi
+    PLACED=()
+    ENTRY=()
+    if [[ "$FORWARDED" == house ]]; then
+      HERE=$(pwd -P)
+      [[ "$HERE" == "$WORKSPACE" || "$HERE" == "$WORKSPACE"/* ]] || refuse "the current directory is outside the workspace $WORKSPACE"
+      PLACED=(--workdir "/agents/house${HERE#"$WORKSPACE"}")
+      ENTRY=(--entrypoint house)
+    fi
     TERMINAL=()
     if [[ -t 0 && -t 1 ]]; then TERMINAL=(-t); fi
     if [[ -t 0 && ! -t 1 ]]; then
@@ -141,9 +151,9 @@ if docker container inspect "$NAME" >/dev/null 2>&1; then
       stty -echo
     fi
     if [[ "$(docker inspect --format '{{.State.Running}}' "$NAME")" == true ]]; then
-      docker exec -i "${TERMINAL[@]}" "$NAME" kit "${FORWARD[@]}"
+      docker exec -i "${TERMINAL[@]}" "${PLACED[@]}" "$NAME" "$FORWARDED" "${FORWARD[@]}"
     else
-      "${DOCKER_RUN[@]:0:2}" -i "${TERMINAL[@]}" "${DOCKER_RUN[@]:2}" "${FORWARD[@]}"
+      "${DOCKER_RUN[@]:0:2}" -i "${TERMINAL[@]}" "${PLACED[@]}" "${ENTRY[@]}" "${DOCKER_RUN[@]:2}" "${FORWARD[@]}"
     fi
     exit
   fi

package/bootstrap.json

@@ -1,12 +1,12 @@
 {
   "schemaVersion": 1,
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "hosts": {
     "linux": {
-      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh)",
+      "command": "bash <(curl -fsSL https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.19/connect-linux.sh)",
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.17/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.1.0-alpha.19/connect-linux.sh"
       },
       "workspace": {
         "argument": "--workspace",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.1.0-alpha.17",
+  "version": "0.1.0-alpha.19",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,6 +9,7 @@
   "private": false,
   "type": "module",
   "bin": {
+    "house": "src/session-bin/house",
     "kit": "bin/kit.js"
   },
   "exports": {

package/src/bridge.js

@@ -18,7 +18,7 @@ import {
 import { operationId } from "./operation.js";
 import { houseFailed } from "./refusal.js";
 
-function bridgedFrame(request, operation) {
+export function bridgedFrame(request, operation) {
   if (typeof request.method !== "string") return request;
   const params = typeof request.params === "object" && request.params !== null ? request.params : {};
   const declared = typeof params._meta === "object" && params._meta !== null ? params._meta : {};

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-28-first-prompt";
+export const KIT_CONTRACT_VERSION = "1";
 export const KIT_CAPTURE_BATCH_MAX = 100;
 export const COMMAND_INPUT_MAX_BYTES = 4 * 1024;
 export const AUTHORIZATION_OUTPUT_MAX_BYTES = 4 * 1024;
@@ -292,17 +292,21 @@ 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/1";
+export const WORKING_COPY_VERSION = "working-copy-state/2";
 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_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 MIGRATOR_CONTRACT = "kit-migrator/1";
 export const MIGRATOR_CATEGORY = "migrator";

package/src/house-main.js

@@ -1,9 +1,19 @@
-import { resolve } from "node:path";
-import { BRIDGE_NONCE_ENVIRONMENT, BRIDGE_SOCKET_ENVIRONMENT } from "./contract.js";
-import { bridgeCall } from "./mcp.js";
-import { KitRefusal } from "./refusal.js";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import {
+  BRIDGE_NONCE_ENVIRONMENT,
+  BRIDGE_SOCKET_ENVIRONMENT,
+  WORKING_COPY_PUSH_HELP,
+  WORKING_COPY_PUSH_METHOD,
+} from "./contract.js";
+import { storedHouse } from "./login.js";
+import { answerText, bridgeCall } from "./mcp.js";
+import { formatCommandError, KitRefusal } from "./refusal.js";
+import { ownerPush } from "./working-copy.js";
 
 const HELP = ["--help", "-h"];
+const OWNER = "--owner";
+const GIT_PUSH_USAGE = `usage: house git push [commit] [${OWNER}]`;
 const usage = (verb) => `usage: house ${verb} ['<arguments as one JSON object>' | - for standard input]`;
 
 async function answered(method, params) {
@@ -49,10 +59,59 @@ function located(verb, args) {
   return args;
 }
 
+function printed(result) {
+  const text = answerText(result);
+  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+}
+
+async function ownerPushed(request) {
+  const directory = process.env.HOUSE_KIT_HOME ?? join(homedir(), ".house-kit");
+  const cancellation = new AbortController();
+  const cancel = () => cancellation.abort();
+  process.once("SIGINT", cancel);
+  process.once("SIGTERM", cancel);
+  try {
+    const pushed = await ownerPush(
+      { house: await storedHouse(directory), directory, signal: cancellation.signal },
+      request,
+    );
+    return pushed.refused ? { err: pushed.text, status: 1 } : { out: pushed.text };
+  } catch (refusal) {
+    return { err: formatCommandError(refusal), status: 1 };
+  } finally {
+    process.removeListener("SIGINT", cancel);
+    process.removeListener("SIGTERM", cancel);
+  }
+}
+
+async function gitPush([action, ...rest]) {
+  if (action !== "push") throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  if (rest.some((argument) => HELP.includes(argument))) return { out: `${GIT_PUSH_USAGE}\n\n${WORKING_COPY_PUSH_HELP}` };
+  const owner = rest.includes(OWNER);
+  const named = rest.filter((argument) => argument !== OWNER);
+  if (named.length > 1 || named.some((argument) => argument.startsWith("-"))) {
+    throw new KitRefusal("kit_house_arguments_invalid", GIT_PUSH_USAGE);
+  }
+  const request = { cwd: process.cwd(), commit: named[0] ?? "HEAD" };
+  if (process.env[BRIDGE_SOCKET_ENVIRONMENT] === undefined) {
+    if (!owner) throw new KitRefusal("kit_bridge_unavailable");
+    return ownerPushed(request);
+  }
+  if (owner) throw new KitRefusal("kit_house_arguments_invalid", `${OWNER} is only for use outside an Agent Session`);
+  return printed(await answered(WORKING_COPY_PUSH_METHOD, request));
+}
+
 async function house([verb, argument, ...rest]) {
+  if (verb === "git") return gitPush([argument, ...rest].filter((part) => part !== undefined));
   if (verb === undefined || HELP.includes(verb)) {
     const tools = await listed();
-    return { out: [usage("<verb>"), ...tools.map((tool) => `${tool.name}\n${tool.description}`)].join("\n\n") };
+    return {
+      out: [
+        usage("<verb>"),
+        ...tools.map((tool) => `${tool.name}\n${tool.description}`),
+        `git push [commit]\n${WORKING_COPY_PUSH_HELP}`,
+      ].join("\n\n"),
+    };
   }
   if (HELP.includes(argument)) {
     const tool = (await listed()).find((one) => one.name === verb);
@@ -61,9 +120,7 @@ async function house([verb, argument, ...rest]) {
   }
   if (rest.length > 0) throw new KitRefusal("kit_house_arguments_invalid", usage(verb));
   const args = located(verb, await argumentsOf(verb, argument));
-  const result = await answered("tools/call", { name: verb, arguments: args });
-  const text = (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  return result?.isError === true ? { err: text, status: 1 } : { out: text };
+  return printed(await answered("tools/call", { name: verb, arguments: args }));
 }
 
 house(process.argv.slice(2)).then(

package/src/house.js

@@ -172,7 +172,7 @@ async function residentRelay(session, request, signal, draining) {
   }
 }
 
-export async function serveResident(session, directory, signal, drain) {
+export async function serveResident(session, directory, signal, drain, push) {
   const socket = residentSocket(directory);
   await mkdir(dirname(socket), { recursive: true, mode: 0o700 });
   await rm(socket, { force: true });
@@ -229,12 +229,15 @@ export async function serveResident(session, directory, signal, drain) {
         }
         const cancelled = new AbortController();
         relayed.set(request.id, cancelled);
-        void residentRelay(session, request, AbortSignal.any([signal, cancelled.signal]), draining).then(
-          (answer) => {
-            relayed.delete(request.id);
-            if (!connection.destroyed) writeFrame(connection, { id: request.id, ...answer });
-          },
-        );
+        const relaySignal = AbortSignal.any([signal, cancelled.signal]);
+        const answered =
+          request.push === undefined
+            ? residentRelay(session, request, relaySignal, draining)
+            : push(request.push, relaySignal).then((pushed) => ({ pushed }));
+        void answered.then((answer) => {
+          relayed.delete(request.id);
+          if (!connection.destroyed) writeFrame(connection, { id: request.id, ...answer });
+        });
       },
       onRefusal: () => connection.destroy(),
     });
@@ -302,45 +305,54 @@ async function residentDelegation(directory, fetcher) {
   }
   connection.unref();
   let next = 0;
+  function exchange(frame, signal) {
+    signal?.throwIfAborted();
+    if (connection.destroyed) return Promise.resolve(unavailable());
+    return new Promise((resolve, reject) => {
+      const id = (next += 1);
+      const cancel = () => {
+        pending.delete(id);
+        settle(id);
+        if (!connection.destroyed) writeFrame(connection, { id, cancel: true });
+        reject(signal.reason);
+      };
+      signal?.addEventListener("abort", cancel, { once: true });
+      pending.set(id, (answer) => {
+        signal?.removeEventListener("abort", cancel);
+        resolve(answer);
+      });
+      connection.ref();
+      writeFrame(connection, { id, ...frame });
+    });
+  }
+  async function push(request, signal) {
+    const answer = await exchange({ push: request }, signal);
+    if (answer.pushed === undefined) throw new KitRefusal("kit_resident_unavailable");
+    return answer.pushed;
+  }
   async function delegated(url, init = {}) {
     const { authorization, ...headers } = init.headers ?? {};
     if (authorization !== RESIDENT) return fetcher(url, init);
-    init.signal?.throwIfAborted();
     const address = new URL(url);
-    const answer = connection.destroyed
-      ? unavailable()
-      : await new Promise((resolve, reject) => {
-          const id = (next += 1);
-          const cancel = () => {
-            pending.delete(id);
-            settle(id);
-            if (!connection.destroyed) writeFrame(connection, { id, cancel: true });
-            reject(init.signal.reason);
-          };
-          init.signal?.addEventListener("abort", cancel, { once: true });
-          pending.set(id, (answer) => {
-            init.signal?.removeEventListener("abort", cancel);
-            resolve(answer);
-          });
-          connection.ref();
-          writeFrame(connection, {
-            id,
-            method: init.method ?? "GET",
-            path: `${address.pathname}${address.search}`,
-            headers,
-            ...(typeof init.body === "string"
-              ? { text: init.body }
-              : init.body === undefined
-                ? {}
-                : { bytes: Buffer.from(init.body).toString("base64") }),
-          });
-        });
+    const answer = await exchange(
+      {
+        method: init.method ?? "GET",
+        path: `${address.pathname}${address.search}`,
+        headers,
+        ...(typeof init.body === "string"
+          ? { text: init.body }
+          : init.body === undefined
+            ? {}
+            : { bytes: Buffer.from(init.body).toString("base64") }),
+      },
+      init.signal,
+    );
     return new Response(answer.body === null ? null : Buffer.from(answer.body, "base64"), {
       status: answer.status,
       headers: answer.type === null ? {} : { "content-type": answer.type },
     });
   }
-  return { connection, fetch: delegated };
+  return { connection, fetch: delegated, push };
 }
 
 export async function openSession(options, dependencies = {}) {
@@ -359,6 +371,7 @@ export async function openSession(options, dependencies = {}) {
       : await residentDelegation(options.directory, dependencies.fetch ?? fetch);
   if (resident !== null) {
     session.resident = resident.connection;
+    session.push = resident.push;
     session.dependencies = { ...dependencies, fetch: resident.fetch };
     return session;
   }

package/src/local-files.js

@@ -1,6 +1,7 @@
 import { isAbsolute } from "node:path";
-import { parse, stringify } from "yaml";
+import { stringify } from "yaml";
 import { AGENT_OPERATION_META, ATTACHMENT_FILE_META } from "./contract.js";
+import { answerText, answerYaml } from "./mcp.js";
 import { derivedOperationId } from "./operation.js";
 import { localAttachment, sendLocalConversationFile, uploadLocalAttachment } from "./original.js";
 import { KitRefusal } from "./refusal.js";
@@ -12,18 +13,9 @@ class HouseRefused extends Error {
   }
 }
 
-function parsed(text) {
-  try {
-    return parse(text);
-  } catch {
-    return null;
-  }
-}
-
 function answerOf(frame) {
   if (frame.error !== undefined || frame.result?.isError === true) throw new HouseRefused(frame);
-  const text = (frame.result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
-  const answer = parsed(text);
+  const answer = answerYaml(answerText(frame.result));
   if (answer === null || typeof answer !== "object") throw new KitRefusal("kit_house_answer_unreadable");
   return answer;
 }

package/src/mcp.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { parse } from "yaml";
 import { bridgePeer } from "./peer.js";
 import { KitRefusal } from "./refusal.js";
 
@@ -69,3 +70,15 @@ export async function bridgeCall(bridge, request, signal = undefined) {
     await peer.end();
   }
 }
+
+export function answerText(result) {
+  return (result?.content ?? []).filter((item) => item.type === "text").map((item) => item.text).join("\n");
+}
+
+export function answerYaml(text) {
+  try {
+    return parse(text);
+  } catch {
+    return null;
+  }
+}

package/src/sync-library.js

@@ -100,13 +100,12 @@ function recordedMap(authority) {
   return new Map(authority.files.map((file) => [file.path, file]));
 }
 
-function structuredOrReplace(root, relative, recorded, content) {
+export function structuredOrReplace(root, relative, recorded, content) {
   const path = housePath(root, relative);
+  const whole = [{ op: "replace", path, base: recorded.revision, content }];
   const before = parse(recorded.content, relative);
   const after = parse(content, relative);
-  if (!before.ok || !after.ok) {
-    return [{ op: "replace", path, base: recorded.revision, content }];
-  }
+  if (!before.ok || !after.ok) return whole;
   const ops = [];
   if (before.document.preamble !== after.document.preamble) {
     ops.push({
@@ -124,9 +123,7 @@ function structuredOrReplace(root, relative, recorded, content) {
     if (JSON.stringify(before.document.fields[name]) === JSON.stringify(after.document.fields[name])) {
       continue;
     }
-    if (after.document.fields[name] === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (after.document.fields[name] === undefined) return whole;
     const change = { op: "set_field", path, field: name, value: after.document.fields[name] };
     if (before.document.fields[name] !== undefined) change.base = before.document.fields[name];
     ops.push(change);
@@ -139,12 +136,11 @@ function structuredOrReplace(root, relative, recorded, content) {
     const prior = before.document.sections[name];
     const next = after.document.sections[name];
     if (prior === next) continue;
-    if (prior === undefined || next === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (prior === undefined || next === undefined) return whole;
     ops.push({ op: "replace_section", path, section: name, base: prior, content: next });
   }
-  return ops.length === 0 ? [{ op: "replace", path, base: recorded.revision, content }] : ops;
+  if (ops.length === 0) return whole;
+  return applyChanges({ [relative]: recorded.content }, ops, root)[relative] === content ? ops : whole;
 }
 
 export function deriveChanges(state, authority, localFiles) {

package/src/sync.js

@@ -41,7 +41,7 @@ function sessionDependencies(options, dependencies) {
   };
 }
 
-async function withSession(options, dependencies, operation) {
+export async function withSession(options, dependencies, operation) {
   const session = await openSession(options, sessionDependencies(options, dependencies));
   return maintainControl(session, (signal) => operation(session, signal), options.signal);
 }