@agentshouse/kit 0.2.1-alpha.8 → 0.2.1-c031c7457a661

package/dist/copies.js

@@ -2,32 +2,64 @@ import { parse } from '@agentshouse/mdmodel';
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { HouseRefusal } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, revision, run, succeeded, tree, WORKING_COPIES, } from './git.js';
+import { finalRefusal, HouseRefusal, retrying } from './api.js';
+import { blobId, blobText, git, isText, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
+import { refusalOf } from './refusals.js';
 import { changed } from './translate.js';
+import { relayed } from './relay.js';
 const BRANCH = 'main';
-const ROOM_HOMES = ['capture', 'library', 'collaboration'];
 const PROVENANCE = '_provenance';
-const REPLICA_RETRY_MS = 30_000;
-const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
+const IDENTITY = { GIT_COMMITTER_NAME: 'Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function houseCause(error) {
+    return error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
-export function refusalCode(text) {
+const REBASED = new Set([
+    'field_base_stale',
+    'section_base_stale',
+    'preamble_base_stale',
+    'base_revision_stale',
+    'path_exists',
+    'path_absent',
+]);
+function rebaseFixes(refusal) {
+    return refusal.code === 'edit_conflict' && refusal.conflicts.some((code) => REBASED.has(code));
+}
+function textOnly(paths) {
+    const [named, them] = paths.length === 1 ? [`${paths[0]} is`, 'it'] : [`${paths.join(', ')} are`, 'them'];
+    return `${named} not text, and house push sends text only; remove ${them} from the commit and place ${them} with house upload`;
+}
+function outside(path) {
+    return { refused: true, text: `${path} is not a House Local copy; run house push inside one` };
+}
+function short(commit) {
+    return commit.slice(0, 12);
+}
+function moved(before, after) {
+    if (before.house !== after.house)
+        return [`${rootOf(after.room_handle)}: ${HOUSE_REF} is at ${short(after.house)}`];
+    return before.position === after.position ? [] : [`${rootOf(after.room_handle)}: read-only files refreshed`];
+}
+function expiredAuthority(error) {
+    if (!(error instanceof HouseRefusal))
+        return undefined;
     try {
-        return String(JSON.parse(text).error.code);
+        const { error: refused } = JSON.parse(error.text);
+        return refused?.code === 'expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
     }
     catch {
-        return text.split(':')[0].trim();
+        return undefined;
     }
 }
-function short(commit) {
-    return commit.slice(0, 12);
+function grouped(items, size) {
+    return items.flatMap((_, index) => (index % size === 0 ? [items.slice(index, index + size)] : []));
 }
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
@@ -37,14 +69,14 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
-function rootOf(copy) {
-    return copy.private ? '/private' : `/rooms/${copy.room_handle}`;
+function recordOf(key) {
+    return join(kitHome(), 'local-copies', `${key}.json`);
 }
-function relative(path) {
-    return path.replace(/^\/private\//, '').replace(/^\/rooms\/[^/]+\//, '');
+function rootOf(handle) {
+    return `/rooms/${handle}`;
 }
-function prefixesOf(selected) {
-    return selected.private ? ['/private'] : ROOM_HOMES.map((home) => `${rootOf(selected)}/${home}`);
+function relative(path) {
+    return path.replace(/^\/rooms\/[^/]+\//, '');
 }
 function declaredWritable(path, copy) {
     const deepest = (scopes) => Math.max(-1, ...scopes.filter((scope) => covers(path, scope)).map((scope) => scope.length));
@@ -101,7 +133,7 @@ async function ignoreRules(repository, writable, copy) {
     ].map(pattern);
     const granted = readOnly.filter((path) => !protectedPath(path)).map(pattern);
     await ruled(join(repository, '.gitignore'), [
-        '# House Kit writes this file and .ignore. The paths below are read-only House',
+        '# Kit writes this file and .ignore. The paths below are read-only House',
         '# content: Git does not track them, and House refuses a change to them even',
         '# when this file is edited or a path is force-added.',
         '/.gitignore',
@@ -116,7 +148,7 @@ async function ignoreRules(repository, writable, copy) {
         '',
     ].join('\n'));
     await ruled(join(repository, '.ignore'), [
-        '# House Kit writes this file so native search still reads the read-only House',
+        '# Kit writes this file so native search still reads the read-only House',
         '# content that .gitignore keeps out of Git.',
         `!${PROVENANCE}`,
         ...[...house, ...granted].map((rule) => `!${rule}`),
@@ -147,34 +179,35 @@ function movedPaths(moves, before, after) {
         .filter((pair) => pairs.filter((other) => other.from === pair.from || other.to === pair.to).length === 1)
         .map(({ from, to }) => [from, to]));
 }
-export class WorkingCopies {
+export class LocalCopies {
     owner;
     house;
     copies = new Map();
     queues = new Map();
-    delivering = new Set();
-    selecting = Promise.resolve();
+    answering = Promise.resolve();
     constructor(house) {
         this.house = house;
         this.owner = {
             key: 'owner',
             submit: async (operation, changes) => {
                 try {
-                    const outcome = await house.post('/kit/door/batch', { operation_id: operation, changes });
+                    const outcome = await retrying(() => house.post('/kit/door/batch', { operation_id: operation, changes }));
                     return { accepted: outcome.contents };
                 }
                 catch (error) {
-                    if (!(error instanceof HouseRefusal) || error.status >= 500)
+                    if (!finalRefusal(error))
                         throw error;
-                    return { refused: { code: refusalCode(error.text), text: error.message } };
+                    return {
+                        refused: refusalOf(error.text) ?? { code: '', text: `House refused it with ${error.status}`, conflicts: [] },
+                    };
                 }
             },
         };
     }
     async load() {
-        const home = join(kitHome(), 'working-copies');
+        const home = join(kitHome(), 'local-copies');
         const names = (await readdir(join(home, 'rooms')).catch(() => [])).filter((name) => name.endsWith('.json'));
-        for (const path of [...names.map((name) => join(home, 'rooms', name)), join(home, 'private.json')]) {
+        for (const path of names.map((name) => join(home, 'rooms', name))) {
             const text = await readFile(path, 'utf8').catch(() => null);
             if (text === null)
                 continue;
@@ -183,47 +216,75 @@ export class WorkingCopies {
         }
     }
     async mapping() {
-        await this.selecting;
+        await this.answering;
         return [...this.copies.values()]
-            .filter((copy) => copy.active)
-            .map((copy) => `${rootOf(copy)}: ${copy.repository}`)
+            .filter((copy) => copy.unfollowed === undefined)
+            .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    select() {
-        const selected = this.selecting.then(() => this.reselect());
-        this.selecting = selected.catch(() => undefined);
-        return selected;
-    }
-    async reselect() {
-        const { working_copy: chosen } = await this.house.post('/kit/working-copy/selection', {});
-        const selected = [
-            ...(chosen?.rooms ?? [])
-                .filter((room) => room.room_handle !== null)
-                .map((room) => ({ key: `rooms/${room.room_ref}`, private: false, handle: room.room_handle })),
-            ...(chosen?.private === true ? [{ key: 'private', private: true, handle: null }] : []),
-        ];
-        const keys = new Set(selected.map((scope) => scope.key));
-        const work = [];
-        for (const key of this.copies.keys()) {
-            if (keys.has(key))
-                continue;
-            work.push(this.exclusive(key, async () => {
-                const copy = this.copies.get(key);
-                if (copy.active)
-                    await this.save({ ...copy, active: false });
-            }));
-        }
-        for (const scope of selected)
-            work.push(this.exclusive(scope.key, () => this.apply(scope)).catch(logged));
-        await Promise.all(work);
-    }
-    entries(frame) {
-        const copy = [...this.copies.values()].find((held) => held.active && held.room_ref === frame.authority);
-        if (copy === undefined)
-            return;
-        if (copy.log_epoch === frame.log_epoch && BigInt(frame.position) <= BigInt(copy.position))
-            return;
-        this.deliver(copy.key);
+    connected() {
+        return this.selected();
+    }
+    async changed(rooms) {
+        if (rooms.length > 0)
+            await this.selected(rooms);
+    }
+    fetch() {
+        return this.answered(() => this.fetched(true));
+    }
+    async selected(rooms) {
+        const copied = await this.answered(() => this.fetched(false, rooms));
+        if (copied.refused)
+            logged(copied.text);
+    }
+    answered(work) {
+        const answered = this.answering.then(work);
+        this.answering = answered.catch(() => undefined);
+        return answered;
+    }
+    async fetched(refreshing, rooms) {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', rooms === undefined ? {} : { rooms });
+        const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
+        const named = rooms === undefined ? null : new Set(rooms.map((room) => `rooms/${room}`));
+        const held = () => [...this.copies.values()].filter((copy) => named === null || named.has(copy.key));
+        return this.holding([...new Set([...held().map((copy) => copy.key), ...synced.keys()])].sort(), async () => {
+            const said = [];
+            let refused = false;
+            const mark = refreshing ? 'said' : 'unsaid';
+            for (const copy of held()) {
+                if (synced.has(copy.key) || copy.unfollowed === 'said' || copy.unfollowed === mark)
+                    continue;
+                await this.save({ ...copy, unfollowed: mark });
+                if (refreshing)
+                    said.push(`${rootOf(copy.room_handle)}: no longer followed; kept as it is`);
+            }
+            const current = [];
+            for (const [key, handle] of synced) {
+                try {
+                    const held = this.copies.get(key);
+                    if (held === undefined || !(await exists(held.repository))) {
+                        said.push(await this.materialize(key, handle));
+                        continue;
+                    }
+                    const { unfollowed, ...followed } = held;
+                    current.push(unfollowed === undefined && held.room_handle === handle ? held : await this.save({ ...followed, room_handle: handle }));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(`${rootOf(handle)}: ${causeOf(error)}`);
+                }
+            }
+            if (refreshing && current.length > 0) {
+                const failed = await this.refreshed(current).then(() => null, houseCause);
+                for (const copy of current)
+                    said.push(...moved(copy, this.copies.get(copy.key)));
+                if (failed !== null) {
+                    refused = true;
+                    said.push(failed);
+                }
+            }
+            return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
+        });
     }
     async observed(report) {
         const key = await this.keyAt(dirname(report.common));
@@ -253,11 +314,11 @@ export class WorkingCopies {
     async push(cwd, selector, caller) {
         const located = await run(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
         if (located.status !== 0)
-            return { refused: true, text: `${cwd} is not in a Git repository` };
+            return outside(cwd);
         const [common, worktree] = located.stdout.toString('utf8').split('\n');
         const key = await this.keyAt(dirname(common));
         if (key === undefined)
-            return { refused: true, text: `${worktree} is not a House working copy` };
+            return outside(worktree);
         return this.exclusive(key, () => this.pushed(key, worktree, selector, caller));
     }
     async keyAt(repository) {
@@ -273,19 +334,12 @@ export class WorkingCopies {
         this.queues.set(key, queued.catch(() => undefined));
         return queued;
     }
-    deliver(key) {
-        if (this.delivering.has(key))
-            return;
-        this.delivering.add(key);
-        void this.exclusive(key, async () => {
-            this.delivering.delete(key);
-            const copy = this.copies.get(key);
-            if (copy.active)
-                await this.save(await this.caughtUp(copy));
-        }).catch(logged);
+    holding(keys, work) {
+        const [key, ...rest] = keys;
+        return key === undefined ? work() : this.exclusive(key, () => this.holding(rest, work));
     }
     async save(copy) {
-        const path = join(kitHome(), 'working-copies', copy.private ? 'private.json' : `${copy.key}.json`);
+        const path = recordOf(copy.key);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -293,12 +347,12 @@ export class WorkingCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
-    async read(selected) {
-        const prefixes = prefixesOf(selected);
+    async read(handle) {
+        const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
         let bundle = await this.house.post('/kit/door/bootstrap', { prefixes });
         if ('transfer' in bundle)
-            bundle = (await (await fetch(bundle.transfer.url)).json());
+            bundle = (await (await fetch(relayed(bundle.transfer.url))).json());
         const [view] = bundle.scopes;
         if (view === undefined)
             return null;
@@ -328,46 +382,13 @@ export class WorkingCopies {
         }
         return read;
     }
-    async apply(scope) {
-        let copy = this.copies.get(scope.key);
-        if (copy === undefined || !(await exists(copy.repository))) {
-            await this.materialize(scope);
-            return;
-        }
-        if (copy.room_handle !== scope.handle)
-            copy = await this.save({ ...copy, room_handle: scope.handle });
-        if (!copy.active) {
-            await this.save(await this.received({ ...copy, active: true }));
-            return;
-        }
-        const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: prefixesOf(copy),
-        });
-        const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
-        if (authority === undefined)
-            return;
-        if (authority.managed_replication !== 'admitted') {
-            logged(`operation_denied: ${rootOf(copy)} is not synchronized to this Environment`);
-            return;
-        }
-        if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
-            JSON.stringify([copy.write, copy.protected])) {
-            await this.save(await this.received(copy));
-            return;
-        }
-        await this.save(await this.caughtUp(copy));
-    }
-    async materialize(scope) {
-        const read = await this.read({ private: scope.private, room_handle: scope.handle });
-        if (read === null) {
-            logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
-            return;
-        }
-        const repository = scope.private ? join(WORKING_COPIES, 'private') : join(WORKING_COPIES, 'rooms', read.anchor);
-        if (await exists(repository)) {
-            logged(`${repository} already exists and House Kit leaves it as it is`);
-            return;
-        }
+    async materialize(key, handle) {
+        const read = await this.read(handle);
+        if (read === null)
+            throw new Error('House serves nothing of it to copy');
+        const repository = join(localCopies(), 'rooms', read.anchor);
+        if (await exists(repository))
+            throw new Error(`${repository} already exists and Kit leaves it as it is`);
         const staging = join(dirname(repository), `.${randomUUID()}`);
         await mkdir(staging, { recursive: true });
         let house;
@@ -375,7 +396,7 @@ export class WorkingCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf({ private: scope.private, room_handle: scope.handle })}`, from: null, files: read.writable },
+                { message: `House ${rootOf(handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -388,12 +409,10 @@ export class WorkingCopies {
             throw error;
         }
         await this.save({
-            key: scope.key,
-            private: scope.private,
+            key,
             room_ref: read.anchor,
-            room_handle: scope.handle,
+            room_handle: handle,
             repository,
-            active: true,
             house,
             position: read.position,
             log_epoch: read.log_epoch,
@@ -403,13 +422,14 @@ export class WorkingCopies {
             manifests: { [house]: { parent: null, files: read.revisions } },
             moves: [],
         });
+        return `${rootOf(handle)}: copied to ${repository}`;
     }
     async received(copy) {
-        const read = await this.read(copy);
+        const read = await this.read(copy.room_handle);
         if (read === null)
             return copy;
         const house = await importCommits(copy.repository, [
-            { message: `House ${rootOf(copy)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
+            { message: `House ${rootOf(copy.room_handle)} at position ${read.position}`, from: copy.house, replaces: true, files: read.writable },
         ]);
         const removed = copy.read_only.filter((path) => !read.readOnly.has(path));
         const readOnly = await readOnlyPlaced(copy.repository, copy.read_only, read.readOnly, removed);
@@ -426,30 +446,57 @@ export class WorkingCopies {
         await ignoreRules(copy.repository, [...read.writable.keys()], next);
         return next;
     }
-    async caughtUp(start) {
-        let copy = start;
-        for (;;) {
+    async refreshed(copies) {
+        const discover = (group) => this.house.post('/kit/door/discover', { prefixes: group.map((copy) => rootOf(copy.room_handle)) });
+        const [first, ...rest] = copies;
+        const { bounds, authorities } = await discover([first]);
+        for (const group of grouped(rest, bounds.max_prefixes))
+            authorities.push(...(await discover(group)).authorities);
+        const unchanged = [];
+        for (const copy of copies) {
+            const authority = authorities.find((entry) => entry.room_ref === copy.room_ref);
+            if (authority !== undefined &&
+                JSON.stringify([authority.operations.write, authority.protected_paths]) !== JSON.stringify([copy.write, copy.protected])) {
+                await this.save(await this.received(copy));
+            }
+            else {
+                unchanged.push(copy);
+            }
+        }
+        for (const group of grouped(unchanged, bounds.max_prefixes))
+            await this.caughtUp(group, false);
+    }
+    async caughtUp(copies, whole) {
+        const caught = new Map(copies.map((copy) => [copy.key, copy]));
+        let asking = [...copies];
+        while (asking.length > 0) {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: prefixesOf(copy),
-                    positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
+                    prefixes: asking.map((copy) => rootOf(copy.room_handle)),
+                    positions: asking.map((copy) => ({ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch })),
                 });
             }
             catch (error) {
-                const code = error instanceof HouseRefusal ? refusalCode(error.text) : null;
-                if (code === 'position_expired')
-                    return this.received(copy);
-                if (code !== 'replica_behind')
+                const expired = asking.find((copy) => copy.room_ref === expiredAuthority(error));
+                if (expired === undefined)
                     throw error;
-                setTimeout(() => this.deliver(copy.key), REPLICA_RETRY_MS).unref();
-                return copy;
+                caught.set(expired.key, await this.save(await this.received(expired)));
+                asking = asking.filter((copy) => copy !== expired);
+                continue;
             }
-            const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
-            if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
-                return copy;
-            copy = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+            const advanced = [];
+            for (const copy of asking) {
+                const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
+                if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
+                    continue;
+                const next = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+                caught.set(copy.key, next);
+                advanced.push(next);
+            }
+            asking = whole ? advanced : [];
         }
+        return copies.map((copy) => caught.get(copy.key));
     }
     async incorporated(copy, changes, position, logEpoch) {
         const houseTree = await tree(copy.repository, copy.house);
@@ -482,7 +529,7 @@ export class WorkingCopies {
         let { house, manifests } = copy;
         if (files.size > 0) {
             house = await importCommits(copy.repository, [
-                { message: `House ${rootOf(copy)} at position ${position}`, from: copy.house, files },
+                { message: `House ${rootOf(copy.room_handle)} at position ${position}`, from: copy.house, files },
             ]);
             manifests = { ...manifests, [house]: { parent: copy.house, files: revisions } };
         }
@@ -512,8 +559,6 @@ export class WorkingCopies {
             }
             copy = await this.save(without(copy));
         }
-        if (!copy.active)
-            return { refused: true, text: `${rootOf(copy)} is no longer kept in this Environment` };
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
         if (base === undefined) {
@@ -524,7 +569,7 @@ export class WorkingCopies {
             changes = await this.derived(copy, base, commit);
         }
         catch (error) {
-            return { refused: true, text: causeOf(error) };
+            return { refused: true, text: houseCause(error) };
         }
         if (changes.length === 0)
             return { refused: false, text: `Nothing to submit: ${short(commit)} matches House.` };
@@ -546,12 +591,23 @@ export class WorkingCopies {
         return this.settle(submitted, caller);
     }
     async derived(copy, base, commit) {
-        const root = rootOf(copy);
+        const root = rootOf(copy.room_handle);
         const before = await tree(copy.repository, base);
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
         const arrived = new Set(moved.values());
-        const text = (entry, path) => blobText(copy.repository, entry, path);
+        const arriving = [...after].filter(([path, entry]) => before.get(path) !== entry);
+        if (arriving.length > 0) {
+            const { bounds } = await this.house.post('/kit/door/discover', { prefixes: [root] });
+            const binary = [];
+            for (const [path, entry] of arriving) {
+                if (!(await isText(copy.repository, entry, bounds.max_authored_file_bytes)))
+                    binary.push(path);
+            }
+            if (binary.length > 0)
+                throw new Error(textOnly(binary));
+        }
+        const text = (entry) => blobText(copy.repository, entry);
         const changes = [];
         for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {
             if (arrived.has(path))
@@ -564,7 +620,7 @@ export class WorkingCopies {
                 changes.push({ op: 'rename', path: `${root}/${path}`, to: `${root}/${to}`, base: known });
                 const moving = after.get(to);
                 if (moving !== prior) {
-                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving, to) });
+                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving) });
                 }
                 continue;
             }
@@ -573,18 +629,17 @@ export class WorkingCopies {
             if (next === undefined)
                 changes.push({ op: 'remove', path: `${root}/${path}`, base: known });
             else if (prior === undefined)
-                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next, path) });
+                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next) });
             else
-                changes.push(...changed(`${root}/${path}`, path, known, await text(prior, path), await text(next, path)));
+                changes.push(...changed(`${root}/${path}`, path, known, await text(prior), await text(next)));
         }
         return changes;
     }
     async settle(start, caller, restaged = false) {
         let copy = start;
         const push = copy.push;
-        if (push.caller !== caller.key) {
-            return this.recovered(copy, `${short(push.commit)} was pushed by another caller and awaited its outcome`);
-        }
+        if (push.caller !== caller.key)
+            return this.recovered(copy);
         let outcome;
         try {
             outcome = await caller.submit(push.operation_id, push.changes, push.upload, async (upload) => {
@@ -592,9 +647,10 @@ export class WorkingCopies {
             });
         }
         catch (error) {
+            const refusal = error instanceof HouseRefusal ? refusalOf(error.text) : null;
             return {
                 refused: true,
-                text: `House's answer to ${short(push.commit)} did not arrive (${causeOf(error)}); run house git push again to recover its outcome.`,
+                text: refusal?.text ?? `House's answer to ${short(push.commit)} did not arrive; run house push again`,
             };
         }
         if ('refused' in outcome) {
@@ -602,32 +658,40 @@ export class WorkingCopies {
                 const { upload, ...unstaged } = copy.push;
                 return this.settle(await this.save({ ...copy, push: unstaged }), caller, true);
             }
-            if (outcome.refused.code === 'operation_expired')
-                return this.recovered(copy, outcome.refused.text);
+            if (outcome.refused.code === 'expired')
+                return this.recovered(copy);
             let settled = await this.save(without(copy));
+            if (settled.unfollowed !== undefined)
+                return { refused: true, text: outcome.refused.text };
+            const rebased = rebaseFixes(outcome.refused);
             try {
-                settled = await this.save(await this.caughtUp(settled));
+                settled = (await this.caughtUp([settled], true))[0];
             }
-            catch (error) {
-                return { refused: true, text: `${outcome.refused.text}\n${HOUSE_REF} is unchanged: ${causeOf(error)}` };
+            catch {
+                return {
+                    refused: true,
+                    text: rebased ? `${outcome.refused.text}\nHouse's current state did not arrive; push again later` : outcome.refused.text,
+                };
             }
             return {
                 refused: true,
-                text: `${outcome.refused.text}\n${HOUSE_REF} holds House's current state; merge or rebase onto it, commit and push again.`,
+                text: rebased
+                    ? `${outcome.refused.text}\n${HOUSE_REF} holds House's current state; rebase onto it and push again`
+                    : outcome.refused.text,
             };
         }
         return this.finished(await this.save({ ...copy, push: { ...copy.push, state: 'accepted', written: outcome.accepted } }));
     }
-    async recovered(copy, reason) {
+    async recovered(copy) {
         const push = copy.push;
-        const current = await this.save(await this.caughtUp(copy));
+        const current = (await this.caughtUp([copy], true))[0];
         const house = await tree(copy.repository, current.house);
-        const root = rootOf(current);
+        const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
             await this.save(without(current));
             return {
                 refused: true,
-                text: `${reason}; House does not hold ${short(push.commit)}; run house git push again to submit it as a new operation.`,
+                text: `House does not hold ${short(push.commit)}; run house push again`,
             };
         }
         const written = [];
@@ -636,7 +700,7 @@ export class WorkingCopies {
             written.push({
                 path: `${root}/${path}`,
                 revision: entry === undefined ? null : (revisionAt(current, current.house, path) ?? null),
-                content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                content: entry === undefined ? null : await blobText(copy.repository, entry),
             });
         }
         return this.finished(await this.save({ ...current, push: { ...push, state: 'accepted', written } }));
@@ -652,10 +716,10 @@ export class WorkingCopies {
                 await this.save(without(copy));
             return { refused: false, text: integrated.text };
         }
-        catch (error) {
+        catch {
             return {
                 refused: false,
-                text: `House accepted ${short(commit)}; local integration is pending (${causeOf(error)}); run house git push again to finish it.`,
+                text: `House accepted ${short(commit)}; run house push again to finish integrating it here`,
             };
         }
     }
@@ -664,7 +728,7 @@ export class WorkingCopies {
         const push = copy.push;
         let written = push.written;
         if (push.changes.some((change) => change.op === 'rename')) {
-            copy = await this.save(await this.caughtUp(copy));
+            copy = (await this.caughtUp([copy], true))[0];
             const house = await tree(copy.repository, copy.house);
             const sent = await tree(copy.repository, push.house);
             if (push.changes.some((change) => change.op === 'rename' && !house.has(relative(change.to)))) {
@@ -678,9 +742,9 @@ export class WorkingCopies {
                 written = [
                     ...written,
                     {
-                        path: `${rootOf(copy)}/${path}`,
+                        path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
-                        content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                        content: entry === undefined ? null : await blobText(copy.repository, entry),
                     },
                 ];
             }
@@ -698,7 +762,7 @@ export class WorkingCopies {
         }
         const edits = new Map([...files].filter(([path, content]) => (content === null ? selected.has(path) : selected.get(path) !== blobId(content))));
         const received = [...files.keys()].filter((path) => revisionAt(copy, copy.house, path) === revisionAt(copy, push.house, path));
-        const accepted = `House ${rootOf(copy)} with ${push.commit} accepted`;
+        const accepted = `House ${rootOf(copy.room_handle)} with ${push.commit} accepted`;
         const house = await importCommits(copy.repository, [
             ...(edits.size === 0 ? [] : [{ message: accepted, from: push.commit, files: edits }]),
             {
@@ -725,7 +789,7 @@ export class WorkingCopies {
     async landed(repository, changes, house, selected) {
         const text = async (path) => {
             const entry = house.get(relative(path));
-            return entry === undefined ? undefined : blobText(repository, entry, path);
+            return entry === undefined ? undefined : blobText(repository, entry);
         };
         for (const change of changes) {
             const current = await text(change.path);