@agentshouse/kit 0.2.1-cf6326dfa5c3e → 0.2.1-cf6a92e13f031

package/dist/copies.js

@@ -11,7 +11,7 @@ import { changed } from './translate.js';
 import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
-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);
 }
@@ -133,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',
@@ -148,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}`),
@@ -218,7 +218,7 @@ export class LocalCopies {
     async mapping() {
         await this.answering;
         return [...this.copies.values()]
-            .filter((copy) => copy.erasing === undefined)
+            .filter((copy) => copy.unfollowed === undefined)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
@@ -250,30 +250,24 @@ export class LocalCopies {
         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()) {
-                const returned = synced.has(copy.key);
-                if (returned && copy.erasing === undefined)
+                if (synced.has(copy.key) || copy.unfollowed === 'said' || copy.unfollowed === mark)
                     continue;
-                try {
-                    await this.erase(copy);
-                    said.push(`${rootOf(copy.room_handle)}: ${returned ? '' : 'no longer synced to this Environment; '}erased from the Local copy`);
-                }
-                catch (error) {
-                    refused = true;
-                    said.push(`${rootOf(copy.room_handle)}: ${causeOf(error)}`);
-                }
+                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?.erasing)
-                        continue;
                     if (held === undefined || !(await exists(held.repository))) {
                         said.push(await this.materialize(key, handle));
                         continue;
                     }
-                    current.push(held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle }));
+                    const { unfollowed, ...followed } = held;
+                    current.push(unfollowed === undefined && held.room_handle === handle ? held : await this.save({ ...followed, room_handle: handle }));
                 }
                 catch (error) {
                     refused = true;
@@ -298,8 +292,6 @@ export class LocalCopies {
             return;
         await this.exclusive(key, async () => {
             const copy = this.copies.get(key);
-            if (copy === undefined || copy.erasing)
-                return;
             let moves = copy.moves;
             for (const { from, to } of report.moves) {
                 const held = moves.find((move) => move.worktree === report.worktree && move.to === from);
@@ -355,12 +347,6 @@ export class LocalCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
-    async erase(copy) {
-        await this.save({ ...copy, erasing: true });
-        await rm(copy.repository, { recursive: true, force: true });
-        await rm(recordOf(copy.key), { force: true });
-        this.copies.delete(copy.key);
-    }
     async read(handle) {
         const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
@@ -402,7 +388,7 @@ export class LocalCopies {
             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 House Kit leaves it as it is`);
+            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;
@@ -560,8 +546,6 @@ export class LocalCopies {
     }
     async pushed(key, worktree, selector, caller) {
         let copy = this.copies.get(key);
-        if (copy === undefined || copy.erasing)
-            return outside(worktree);
         if (copy.push?.state === 'submitted')
             return this.settle(copy, caller);
         const selected = await run(worktree, ['rev-parse', '--verify', '--quiet', '--end-of-options', `${selector}^{commit}`]);
@@ -676,8 +660,10 @@ export class LocalCopies {
             }
             if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
-            const rebased = rebaseFixes(outcome.refused);
             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.caughtUp([settled], true))[0];
             }

package/dist/end.js

@@ -1,14 +1,15 @@
+import { KIT_RELEASE } from './clis.js';
 import { forgetRejected } from './home.js';
 import { installCommand } from './placement.js';
 import { killDescendants } from './scope.js';
-export const REPLACED = 'another Kit started for this Environment';
+export const REPLACED = 'another Kit process started for this Environment';
 function exit(reason, status) {
     process.stderr.write(`kit: ${reason}\n`);
     killDescendants();
     process.exit(status);
 }
 export function end(reason) {
-    exit(reason, 0);
+    exit(reason, process.env.HOUSE_KIT_RESIDENT === String(process.pid) ? 0 : 1);
 }
 export function restart(reason) {
     exit(reason, 1);
@@ -17,6 +18,9 @@ export function updateRequired() {
     const command = installCommand();
     end(command === null ? 'This Kit is too old for House; install it again.' : `This Kit is too old for House. Update it: ${command}`);
 }
+export function newerThanHouse(release, command) {
+    end(`Kit ${KIT_RELEASE} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);
+}
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);
     restart('sign in again');

package/dist/events.js

@@ -2,7 +2,7 @@ const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
 export const RUNNING_JOB = new Set(['running', 'paused']);
-const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
+const MESSAGE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request', send_mail: 'request' };
 function words(line) {
     const found = [];
     let word = null;
@@ -48,7 +48,7 @@ export function houseMessage(line) {
     catch {
         return null;
     }
-    const argument = ROUTINE_TARGETS[call.command];
+    const argument = MESSAGE_TARGETS[call.command];
     if (argument === undefined)
         return null;
     const target = call.arguments?.[argument];

package/dist/files.js

@@ -1,42 +1,128 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { HouseRefusal, retrying } from './api.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir, rename, rm } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { Readable, Transform } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { parseDocument } from 'yaml';
+import { retryDelay } from './api.js';
+import { Unsettled } from './mcp.js';
 import { relayed } from './relay.js';
-export function verified(bytes, sha256, name) {
-    if (createHash('sha256').update(bytes).digest('hex') !== sha256)
-        throw new Error(`${name} did not arrive whole; download it again`);
-    return bytes;
-}
-export async function placeFiles(house, directory, files, signal) {
-    const paths = [];
-    for (const file of files) {
-        const original = await retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
-        const answer = await fetch(relayed(original.download.url), { signal });
-        if (!answer.ok)
-            throw new Error(`${file.name} did not download: ${answer.status}`);
-        const folder = join(directory, '.house', 'files', original.message, file.version);
-        await mkdir(join(directory, '.house')).catch((error) => {
-            if (error.code !== 'EEXIST')
+const STALLED_ROUNDS = 8;
+const LINK = /\]\((\/rooms\/[^/)\s]+\/[^)\s]+)\)/gu;
+export function linkedPaths(text) {
+    return [...new Set(Array.from(text.matchAll(LINK), (link) => link[1]))];
+}
+export function inspectedFile(answer) {
+    const document = parseDocument(answer);
+    if (document.errors.length > 0)
+        return null;
+    const inspected = document.toJS();
+    if (typeof inspected?.download !== 'string')
+        return null;
+    return {
+        download: inspected.download,
+        sha256: String(inspected.sha256),
+        media_type: typeof inspected.media_type === 'string' ? inspected.media_type : null,
+    };
+}
+function paused(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+export function storeRefusal(act, status) {
+    return new Error(`the ${act} answered ${status}; ${act} the file again`);
+}
+export async function uploaded(declared, uploading) {
+    let upload = declared;
+    let idle = 0;
+    let stalled = 0;
+    for (;;) {
+        let sent = 0;
+        let failure = null;
+        for (const { part, url } of upload.parts) {
+            const start = (part - 1) * upload.part_bytes;
+            try {
+                await uploading.send(url, start, Math.min(start + upload.part_bytes, uploading.bytes));
+                sent++;
+            }
+            catch (error) {
+                failure = error;
+                break;
+            }
+        }
+        if (sent > 0) {
+            idle = 0;
+            stalled = 0;
+        }
+        else {
+            if (failure !== null && ++stalled >= STALLED_ROUNDS)
+                throw failure;
+            // A round that sent no part, its store unreachable or not yet started, is followed by the next finishing call on the jittered curve.
+            await paused(retryDelay(idle++));
+        }
+        let answer = await finishing(uploading, upload.id);
+        while ('checking' in answer) {
+            // A finishing call that finds House still checking the stored bytes is sent again after five seconds, the cadence at which House takes up a check it handed over.
+            await paused(5_000);
+            answer = await finishing(uploading, upload.id);
+        }
+        if (!('upload' in answer))
+            return answer;
+        upload = answer.upload;
+    }
+}
+async function finishing(uploading, upload) {
+    for (let unsettled = 1;; unsettled++) {
+        try {
+            return await uploading.finish(upload);
+        }
+        catch (error) {
+            if (!(error instanceof Unsettled) || unsettled === STALLED_ROUNDS)
                 throw error;
-        });
-        await mkdir(folder, { recursive: true });
-        const path = join(folder, file.name);
-        await writeFile(path, verified(Buffer.from(await answer.arrayBuffer()), file.sha256, file.name));
-        paths.push(path);
+        }
+        // A finishing call House did not settle, unreached or refused short of final, is sent again on the jittered curve as a conversation resends it, so a dropped connection or a House restart resumes the upload instead of ending it.
+        await paused(retryDelay(unsettled - 1));
     }
-    return paths;
-}
-export function uploadBytes(upload, bytes) {
-    return retrying(async () => {
-        const answer = await fetch(relayed(upload.url), {
-            method: 'POST',
-            headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': upload.operation },
-            body: bytes,
+}
+async function drained(body) {
+    for await (const _chunk of body)
+        ;
+}
+export async function downloaded(address, fetching, destination, name) {
+    for (let asked = 1;; asked++) {
+        const { download, sha256 } = await address();
+        const answer = await fetching(download);
+        if (answer.status === 403 && asked === 1) {
+            await drained(answer.body);
+            continue;
+        }
+        if (answer.status !== 200) {
+            await drained(answer.body);
+            throw storeRefusal('download', answer.status);
+        }
+        await mkdir(dirname(destination), { recursive: true });
+        const partial = join(dirname(destination), `.${basename(destination)}.${randomUUID()}`);
+        const digest = createHash('sha256');
+        const hashed = new Transform({
+            transform(chunk, _encoding, done) {
+                digest.update(chunk);
+                done(null, chunk);
+            },
         });
-        const text = await answer.text();
-        if (!answer.ok)
-            throw new HouseRefusal(upload.url, answer.status, text);
-        return JSON.parse(text);
-    });
+        try {
+            await pipeline(answer.body, hashed, createWriteStream(partial, { flags: 'wx' }));
+            if (digest.digest('hex') !== sha256)
+                throw new Error(`${name} did not arrive whole; download it again`);
+            await rename(partial, destination);
+        }
+        catch (error) {
+            await rm(partial, { force: true });
+            throw error;
+        }
+        return;
+    }
+}
+export async function fetched(url, signal) {
+    const answer = await fetch(relayed(url), { signal });
+    return { status: answer.status, body: answer.body ?? Readable.from([]) };
 }

package/dist/git.js

@@ -8,7 +8,7 @@ export function localCopies() {
     return join(workspaceRoot(), 'local-copies');
 }
 export const HOUSE_REF = 'refs/house/received';
-const COMMITTER = 'House Kit <house-kit@localhost>';
+const COMMITTER = 'Kit <house-kit@localhost>';
 export function run(cwd, args, input, env = {}) {
     return new Promise((resolve, reject) => {
         const child = spawn('git', args, { cwd, env: { ...withoutProxy(), ...env } });

package/dist/house-cli.js

@@ -1,14 +1,17 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
 import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, dirname, extname, join, resolve } from 'node:path';
-import { verified } from './files.js';
+import { request as httpsRequest } from 'node:https';
+import { extname, join, resolve } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { downloaded, inspectedFile, storeRefusal, uploaded } from './files.js';
 import { HOUSE_REF } from './git.js';
 import { ownerSocket, readOwnAgent } from './home.js';
-import { callHouse, rpc, UNREACHABLE } from './mcp.js';
-import { refusalOf } from './refusals.js';
+import { callHouse, rpc, UNREACHABLE, Unsettled } from './mcp.js';
+import { refusalOf, retryable } from './refusals.js';
 import { relayed, selectRelay } from './relay.js';
-import { parse, stringify } from 'yaml';
+import { parse } from 'yaml';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const PUSH_USAGE = 'usage: house push [commit] [--owner]';
 const PUSH = "push [commit]: sends the Local copy's committed changes to House";
@@ -51,15 +54,12 @@ const MEDIA_TYPES = new Map([
     ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
     ['zip', 'application/zip'],
 ]);
-function refused(path, method, status, text, local) {
+function refused(path, status, text, local) {
     const refusal = refusalOf(text);
     if (refusal !== null)
         return refusal.text;
     if (status === 401)
         return REVOKED;
-    const act = method === 'GET' ? 'download' : 'upload';
-    if (URL.canParse(path))
-        return `the ${act} answered ${status}; ${act} the file again`;
     if (status === 502 && local)
         return text;
     return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
@@ -67,26 +67,23 @@ function refused(path, method, status, text, local) {
 function unconfirmed(status) {
     return `House answered ${status} ${UNCONFIRMED}`;
 }
-function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
+function bridged(path, body, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers: { 'content-type': 'application/json' } }, (answer) => {
             const chunks = [];
             answer.on('data', (chunk) => chunks.push(chunk));
             answer.on('end', () => {
-                const bytes = Buffer.concat(chunks);
+                const text = Buffer.concat(chunks).toString('utf8');
                 if (answer.statusCode === 200)
-                    resolve(bytes);
+                    resolve(text);
                 else
-                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
+                    reject(new Error(refused(path, answer.statusCode, text, answer.headers['content-type'] === undefined)));
             });
         });
         sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
-        sent.end(body === undefined ? undefined : body instanceof Buffer ? body : JSON.stringify(body));
+        sent.end(JSON.stringify(body));
     });
 }
-async function bridged(path, body, headers, to = socketPath) {
-    return (await exchanged(path, 'POST', body, headers, to)).toString('utf8');
-}
 async function direct(message) {
     const ownAgent = await readOwnAgent();
     if (ownAgent === null)
@@ -94,11 +91,14 @@ async function direct(message) {
     selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
-        throw new Error(UNREACHABLE);
+        throw new Unsettled(UNREACHABLE);
     });
     if (answer.status === 200)
         return answer.text;
-    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? unconfirmed(answer.status)));
+    if (answer.status === 401)
+        throw new Error(DISCONNECTED);
+    const refusal = refusalOf(answer.text)?.text ?? unconfirmed(answer.status);
+    throw retryable(answer.text) === false ? new Error(refusal) : new Unsettled(refusal);
 }
 async function mcp(method, params) {
     const message = rpc(method, params);
@@ -110,31 +110,32 @@ async function mcp(method, params) {
 async function tools() {
     return (await mcp('tools/list', {})).tools;
 }
-async function localFile(path) {
-    try {
-        return await readFile(path);
-    }
-    catch (error) {
-        throw new Error(error.code === 'EISDIR'
-            ? `${path} is a folder; upload one file at a time`
-            : `${path} is not a readable file`);
-    }
+function unreadable(path, error) {
+    return new Error(error.code === 'EISDIR'
+        ? `${path} is a folder; upload one file at a time`
+        : `${path} is not a readable file`);
 }
-async function transferred(url, method, bytes, headers) {
-    if (socketPath !== undefined)
-        return exchanged(url, method, bytes, headers);
-    setGlobalProxyFromEnv();
-    const answer = await fetch(relayed(url), { method, ...(headers === undefined ? {} : { headers }), ...(bytes === undefined ? {} : { body: bytes }) }).catch(() => {
-        throw new Error(UNREACHABLE);
+function opened(url, method, headers, body) {
+    return new Promise((answered, failed) => {
+        const local = socketPath !== undefined;
+        const target = local ? null : relayed(url);
+        if (!local)
+            setGlobalProxyFromEnv();
+        const sent = target === null
+            ? request({ socketPath, path: url, method, headers }, answered)
+            : (target.protocol === 'https:' ? httpsRequest : request)(target, { method, headers }, answered);
+        sent.on('error', (error) => failed(new Error(!local ? UNREACHABLE : error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        if (body === undefined)
+            sent.end();
+        else
+            pipeline(body, sent).catch(() => undefined);
     });
-    const received = Buffer.from(await answer.arrayBuffer());
-    if (answer.status === 200)
-        return received;
-    throw new Error(refused(url, method, answer.status, received.toString('utf8'), false));
 }
-async function sent(url, bytes, operation) {
-    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
-    return (await transferred(url, 'POST', bytes, headers)).toString('utf8');
+async function sentPart(url, file, start, end) {
+    const answer = await opened(url, 'PUT', { 'content-length': String(end - start) }, end === start ? undefined : createReadStream(file, { start, end: end - 1 }));
+    await answer.toArray();
+    if (answer.statusCode !== 200)
+        throw storeRefusal('upload', answer.statusCode);
 }
 async function download(args) {
     const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
@@ -143,58 +144,52 @@ async function download(args) {
     const { file, ...selected } = argumentsOf(argument);
     if (typeof file !== 'string' || file === '')
         throw new Error('download needs "file", the local file to write');
-    const inspected = parse(await called('inspect', selected));
-    if (typeof inspected?.download !== 'string')
-        throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
-    const bytes = verified(await transferred(inspected.download, 'GET'), String(inspected.sha256), String(selected.path));
     const written = resolve(file);
-    await mkdir(dirname(written), { recursive: true });
-    await writeFile(written, bytes);
+    await downloaded(async () => {
+        const file = inspectedFile(await called('inspect', selected));
+        if (file === null)
+            throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
+        return file;
+    }, async (url) => {
+        const answer = await opened(url, 'GET', {});
+        return { status: answer.statusCode, body: answer };
+    }, written, String(selected.path));
     return written;
 }
 async function described(file) {
-    const bytes = await localFile(file);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    try {
+        for await (const chunk of createReadStream(file)) {
+            digest.update(chunk);
+            bytes += chunk.length;
+        }
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
     const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
-    return {
-        bytes,
-        description: {
-            bytes: bytes.length,
-            sha256: createHash('sha256').update(bytes).digest('hex'),
-            ...(mediaType === undefined ? {} : { media_type: mediaType }),
-        },
-    };
+    return { bytes, sha256: digest.digest('hex'), ...(mediaType === undefined ? {} : { media_type: mediaType }) };
+}
+async function finished(upload, room) {
+    const text = await called('upload', { upload, room_ref: room });
+    const answer = parse(text);
+    return answer !== null && ('upload' in answer || 'checking' in answer) ? answer : { text };
 }
 async function upload({ file, ...destination }) {
     if (typeof file !== 'string' || file === '')
         throw new Error('upload needs "file", a local file');
-    const { bytes, description } = await described(file);
+    const description = await described(file);
     const answer = await called('upload', { ...destination, ...description });
     const declared = parse(answer);
-    if (declared.upload === undefined)
+    if (declared?.upload === undefined)
         return answer;
-    const written = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
-    return stringify(written, { lineWidth: 0 }).trimEnd();
-}
-async function appendRecord(args) {
-    const held = new Map();
-    const attachments = Array.isArray(args.attachments)
-        ? await Promise.all(args.attachments.map(async (attachment) => {
-            if (typeof attachment !== 'string')
-                return attachment;
-            const { bytes, description } = await described(attachment);
-            held.set(description.sha256, bytes);
-            return { name: basename(attachment), ...description };
-        }))
-        : args.attachments;
-    const record = { ...args, attachments };
-    for (;;) {
-        const answer = await called('append_record', record);
-        const { upload } = parse(answer);
-        if (upload === undefined)
-            return answer;
-        for (const grant of upload)
-            await sent(grant.url, held.get(grant.sha256), grant.operation);
-    }
+    const accepted = await uploaded(declared.upload, {
+        bytes: description.bytes,
+        send: (url, start, end) => sentPart(url, file, start, end),
+        finish: (id) => finished(id, destination.room_ref),
+    });
+    return accepted.text;
 }
 function unexpected(argument, usage) {
     return new Error(`unexpected argument ${argument}; ${usage}`);
@@ -220,7 +215,7 @@ async function push(args) {
         throw new Error('--owner is not for Agent conversations; run house push without it');
     if (!owner && socketPath === undefined)
         throw new Error('outside an Agent conversation, house push needs --owner');
-    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? ownerSocket() : socketPath));
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, owner ? ownerSocket() : socketPath));
     if (pushed.refused)
         throw new Error(pushed.text);
     return pushed.text;
@@ -228,7 +223,7 @@ async function push(args) {
 async function fetched(args) {
     if (accepted(args, ['--help'], 0, FETCH_USAGE).flags.has('--help'))
         return FETCH_USAGE;
-    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? ownerSocket()));
+    const answer = JSON.parse(await bridged('/git/fetch', {}, socketPath ?? ownerSocket()));
     if (answer.refused)
         throw new Error(answer.text);
     return answer.text;
@@ -263,7 +258,7 @@ async function house(args) {
         return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
     }
     const parsed = argumentsOf(argument);
-    return verb === 'upload' ? upload(parsed) : verb === 'append_record' ? appendRecord(parsed) : called(verb, parsed);
+    return verb === 'upload' ? upload(parsed) : called(verb, parsed);
 }
 async function called(name, args) {
     const result = await mcp('tools/call', { name, arguments: args });