@agentshouse/kit 0.2.1-c87bb54c0a0ce → 0.2.1-c8add15efc1ec

package/README.md

@@ -33,7 +33,7 @@ them out; running it again without the flag brings them back.
 
 `kit login` opens or prints a link you confirm in any browser, on this computer
 or another, continues on its own and keeps the Environment's credential in
-`~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is set. `--environment <id>`
+`$HOUSE_KIT_HOME` when it is set, else in `~/.house-kit`, or in `house-kit-<uid>` under the temporary directory when your home is read-only. `--environment <id>`
 reconnects an Environment you already have; `--rooms <ref>[,<ref>...]` gives it
 only those Rooms and `--no-private` every Room but your Private Room; `--code <code>` connects immediately without a link.
 A login also connects your own agent: outside an Agent conversation, `house <tool>` calls
@@ -44,15 +44,15 @@ computer, stops House Kit and ends your own agent's connection, so `house` and `
 longer act as you here; a later `kit login` reconnects the same Environment.
 In a container you do not control, such as ChatGPT's, `npm i -g @agentshouse/kit` and `kit chatgpt --key <key>` with a key made on Connections let `house <tool>` act as you, starting and configuring nothing else.
 
-`kit resident` keeps the Environment connected and, as it connects, copies each
-Room you chose for it as a Git repository in the workspace's `local-copies`.
-`house fetch` records House's changes on each copy's `refs/house/received`;
-rebase onto it, commit and run `house push --owner` in the copy, through the
-install command in the container. An Agent runs both, without `--owner`.
+`kit resident` keeps the Environment connected and, as it connects, copies the text of each Room
+you chose for it as a Git repository in the workspace's `local-copies`. `house fetch` records
+House's changes on each copy's `refs/house/received`; rebase onto it, commit and run
+`house push --owner` in the copy, through the install command in the container. An Agent runs
+both, without `--owner`. `house upload` and `house download` move a Room's other files.
 
 House Kit turns each audio file of your message to an Agent into text on this
 computer before the Agent reads it. While transcription is on, the speech
-engine and model use about 425 MB in `~/.house-kit`; turning it off deletes them.
+engine and model use about 425 MB beside the Environment's credential; turning it off deletes them.
 
 ## License
 

package/dist/agents.js

@@ -132,8 +132,14 @@ export class Agents {
     reads = new Map();
     sending = Promise.resolve();
     sent = null;
-    constructor(house) {
+    refreshing = 0;
+    changed;
+    constructor(house, changed = () => undefined) {
         this.house = house;
+        this.changed = changed;
+    }
+    idle() {
+        return this.refreshing === 0;
     }
     read() {
         return this.reading.then(() => undefined, () => undefined);
@@ -142,19 +148,28 @@ export class Agents {
         return this.desired.routes.find((route) => route.agent_id === agentId);
     }
     refresh() {
+        this.refreshing++;
+        this.changed();
         const reading = this.read().then(async () => {
             this.desired = await this.house.deliver('/kit/agents/desired', {});
             return this.desired;
         });
         this.reading = reading;
-        return reading.then(({ agents, transcribe }) => {
+        reading
+            .then(({ agents, transcribe }) => Promise.all([
             holdTranscription(transcribe)
                 .then((changed) => (changed ? this.report() : undefined))
-                .catch(logged);
+                .catch(logged),
             Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
-                .catch(logged);
+                .catch(logged),
+        ]))
+            .catch(() => undefined)
+            .finally(() => {
+            this.refreshing--;
+            this.changed();
         });
+        return reading.then(() => undefined);
     }
     cli(kind) {
         return this.queue(kind, async () => {

package/dist/bootstrap.json

@@ -1,23 +1,23 @@
 {
   "schemaVersion": 2,
-  "version": "0.2.1-c87bb54c0a0ce",
+  "version": "0.2.1-c8add15efc1ec",
   "hosts": {
     "macos": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c87bb54c0a0ce/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8add15efc1ec/connect-linux.sh"
       }
     },
     "linux": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c87bb54c0a0ce/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8add15efc1ec/connect-linux.sh"
       }
     },
     "windows": {
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c87bb54c0a0ce/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-c8add15efc1ec/connect-windows.ps1"
       }
     }
   }

package/dist/chatgpt.js

@@ -20,6 +20,7 @@ export async function chatgpt(argv) {
     const house = values.house ?? (await readOwnAgent())?.house ?? DEFAULT_HOUSE;
     if (!(await accepted(house, values.key)))
         throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
-    await writeOwnAgent({ house, credential: values.key });
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    await writeOwnAgent({ house, ...(relay === undefined ? {} : { relay }), credential: values.key });
     process.stdout.write(`house now calls ${house} as you, with the key kept in ${kitHome()}.\n`);
 }

package/dist/clis.js

@@ -199,7 +199,7 @@ export async function installAdapter(kind, signal) {
     const release = KIT_PACKAGE.peerDependencies[adapter.package];
     if ((await installedAdapter(kind)) === release)
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--cache', join(kitHome(), 'npm-cache'), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'npm');
 }
 export async function installCli(kind, signal) {

package/dist/copies.js

@@ -3,7 +3,7 @@ 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 { finalRefusal, HouseRefusal, retrying } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.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';
@@ -29,6 +29,10 @@ const REBASED = new Set([
 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 short(commit) {
     return commit.slice(0, 12);
 }
@@ -572,7 +576,13 @@ export class LocalCopies {
         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 binary = [];
+        for (const [path, entry] of after)
+            if (before.get(path) !== entry && !(await isText(copy.repository, entry)))
+                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))
@@ -585,7 +595,7 @@ export class LocalCopies {
                 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;
             }
@@ -594,9 +604,9 @@ export class LocalCopies {
             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;
     }
@@ -663,7 +673,7 @@ export class LocalCopies {
             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 } }));
@@ -707,7 +717,7 @@ export class LocalCopies {
                     {
                         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),
                     },
                 ];
             }
@@ -752,7 +762,7 @@ export class LocalCopies {
     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);

package/dist/files.js

@@ -1,7 +1,13 @@
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { HouseRefusal, retrying } from './api.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) {
@@ -16,7 +22,7 @@ export async function placeFiles(house, directory, files, signal) {
         });
         await mkdir(folder, { recursive: true });
         const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
+        await writeFile(path, verified(Buffer.from(await answer.arrayBuffer()), file.sha256, file.name));
         paths.push(path);
     }
     return paths;

package/dist/git.js

@@ -1,4 +1,5 @@
 import { spawn } from 'node:child_process';
+import { isUtf8 } from 'node:buffer';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { withoutProxy } from './clis.js';
@@ -48,14 +49,16 @@ export async function tree(repository, commit) {
     }
     return entries;
 }
-export async function blobText(repository, object, path) {
-    const bytes = (await run(repository, ['cat-file', 'blob', object])).stdout;
-    try {
-        return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
-    }
-    catch {
-        throw new Error(`${path} is binary and House stores only text; remove it from the commit`);
-    }
+const TEXT_MAX_BYTES = 16 * 1024 * 1024;
+async function blob(repository, object) {
+    return (await run(repository, ['cat-file', 'blob', object])).stdout;
+}
+export async function blobText(repository, object) {
+    return (await blob(repository, object)).toString('utf8');
+}
+export async function isText(repository, object) {
+    const bytes = await blob(repository, object);
+    return bytes.length <= TEXT_MAX_BYTES && isUtf8(bytes) && !bytes.includes(0);
 }
 export function blobId(content) {
     const bytes = Buffer.from(content, 'utf8');

package/dist/home.js

@@ -1,6 +1,6 @@
-import { existsSync, linkSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
+import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
@@ -8,8 +8,41 @@ const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
 const RESTART = 'restart';
+let defaulted;
+function writable(directory) {
+    try {
+        accessSync(directory, constants.W_OK | constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ownTemporaryHome() {
+    const home = join(tmpdir(), `house-kit-${process.getuid()}`);
+    try {
+        mkdirSync(home, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+    const found = lstatSync(home);
+    if (found.isSymbolicLink())
+        throw new Error(`${home} is a symbolic link`);
+    if (!found.isDirectory())
+        throw new Error(`${home} is not a directory`);
+    if (found.uid !== process.getuid())
+        throw new Error(`${home} is not owned by this User`);
+    chmodSync(home, 0o700);
+    return home;
+}
+function defaultHome() {
+    const home = join(homedir(), '.house-kit');
+    return existsSync(home) || writable(homedir()) ? home : ownTemporaryHome();
+}
 export function kitHome() {
-    return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
+    return process.env.HOUSE_KIT_HOME || (defaulted ??= defaultHome());
 }
 export function workspaceRoot() {
     return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';

package/dist/house-main.js

@@ -1,25 +1,29 @@
 #!/usr/bin/env node
 import { createHash } from 'node:crypto';
-import { readFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
-import { extname, join } from 'node:path';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { verified } from './files.js';
 import { HOUSE_REF } from './git.js';
-import { kitHome, readEnrolment, readOwnAgent } from './home.js';
+import { kitHome, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
-import { relayed } from './relay.js';
+import { relayed, selectRelay } from './relay.js';
 import { parse, stringify } 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";
 const FETCH_USAGE = 'usage: house fetch';
 const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
+const DOWNLOAD_USAGE = `usage: house download '{"path":"/rooms/<handle>/<path>","file":"<local file>"}', adding "ref" for a revision`;
+const DOWNLOAD = 'download: writes a binary file of a Room to the local file named by file';
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
 const SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
 const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
 const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
+const UNCONFIRMED = 'with no result; a write may or may not have taken effect, so read before you repeat it';
 const socketPath = process.env.HOUSE_BRIDGE;
 const MEDIA_TYPES = new Map([
     ['avif', 'image/avif'],
@@ -48,49 +52,54 @@ const MEDIA_TYPES = new Map([
     ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
     ['zip', 'application/zip'],
 ]);
-function refused(path, status, text) {
+function refused(path, method, 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 upload answered ${status}; upload the file again`;
-    if (status === 502 && /^[A-Za-z]/.test(text))
+        return `the ${act} answered ${status}; ${act} the file again`;
+    if (status === 502 && local)
         return text;
-    return `${path} answered ${status}`;
+    return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
 }
-function bridged(path, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
+function unconfirmed(status) {
+    return `House answered ${status} ${UNCONFIRMED}`;
+}
+function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method: 'POST', headers }, (answer) => {
-            let text = '';
-            answer.setEncoding('utf8');
-            answer.on('data', (chunk) => {
-                text += chunk;
-            });
+        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
+            const chunks = [];
+            answer.on('data', (chunk) => chunks.push(chunk));
             answer.on('end', () => {
+                const bytes = Buffer.concat(chunks);
                 if (answer.statusCode === 200)
-                    resolve(text);
+                    resolve(bytes);
                 else
-                    reject(new Error(refused(path, answer.statusCode, text)));
+                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
             });
         });
         sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
-        sent.end(body instanceof Buffer ? body : JSON.stringify(body));
+        sent.end(body === undefined ? undefined : body instanceof Buffer ? body : 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)
         throw new Error(UNCONNECTED);
-    await readEnrolment();
+    selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
         throw new Error(UNREACHABLE);
     });
     if (answer.status === 200)
         return answer.text;
-    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? `House answered ${answer.status}`));
+    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? unconfirmed(answer.status)));
 }
 async function mcp(method, params) {
     const message = rpc(method, params);
@@ -112,36 +121,82 @@ async function localFile(path) {
             : `${path} is not a readable file`);
     }
 }
-async function sent(url, bytes, operation) {
-    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
+async function transferred(url, method, bytes, headers) {
     if (socketPath !== undefined)
-        return bridged(url, bytes, headers);
+        return exchanged(url, method, bytes, headers);
     setGlobalProxyFromEnv();
-    const answer = await fetch(relayed(url), { method: 'POST', headers, body: bytes }).catch(() => {
+    const answer = await fetch(relayed(url), { method, ...(headers === undefined ? {} : { headers }), ...(bytes === undefined ? {} : { body: bytes }) }).catch(() => {
         throw new Error(UNREACHABLE);
     });
-    const text = await answer.text();
+    const received = Buffer.from(await answer.arrayBuffer());
     if (answer.status === 200)
-        return text;
-    throw new Error(refused(url, answer.status, text));
+        return received;
+    throw new Error(refused(url, method, answer.status, received.toString('utf8'), false));
 }
-async function upload({ file, ...destination }) {
+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 download(args) {
+    const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
+    if (flags.has('--help'))
+        return DOWNLOAD_USAGE;
+    const { file, ...selected } = argumentsOf(argument);
     if (typeof file !== 'string' || file === '')
-        throw new Error('upload needs "file", a local 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);
+    return written;
+}
+async function described(file) {
     const bytes = await localFile(file);
     const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
-    const answer = await called('upload', {
-        ...destination,
-        bytes: bytes.length,
-        sha256: createHash('sha256').update(bytes).digest('hex'),
-        ...(mediaType === undefined ? {} : { media_type: mediaType }),
-    });
+    return {
+        bytes,
+        description: {
+            bytes: bytes.length,
+            sha256: createHash('sha256').update(bytes).digest('hex'),
+            ...(mediaType === undefined ? {} : { media_type: mediaType }),
+        },
+    };
+}
+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 answer = await called('upload', { ...destination, ...description });
     const declared = parse(answer);
     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);
+    }
+}
 function unexpected(argument, usage) {
     return new Error(`unexpected argument ${argument}; ${usage}`);
 }
@@ -200,7 +255,7 @@ async function house(args) {
     if (flags.has('--help') && argument !== undefined)
         throw unexpected('--help', USAGE);
     if (verb === undefined || verb === 'help') {
-        return [USAGE, 'help', PUSH, FETCH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
+        return [USAGE, 'help', PUSH, FETCH, DOWNLOAD, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
     }
     if (flags.has('--help')) {
         const tool = (await tools()).find((listed) => listed.name === verb);
@@ -209,7 +264,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) : called(verb, parsed);
+    return verb === 'upload' ? upload(parsed) : verb === 'append_record' ? appendRecord(parsed) : called(verb, parsed);
 }
 async function called(name, args) {
     const result = await mcp('tools/call', { name, arguments: args });
@@ -221,7 +276,13 @@ async function called(name, args) {
 const argv = process.argv.slice(2);
 const named = argv.findIndex((arg) => !arg.startsWith('-'));
 const rest = argv.filter((_arg, index) => index !== named);
-(argv[named] === 'push' ? push(rest) : argv[named] === 'fetch' ? fetched(rest) : house(argv)).then((text) => {
+(argv[named] === 'push'
+    ? push(rest)
+    : argv[named] === 'fetch'
+        ? fetched(rest)
+        : argv[named] === 'download'
+            ? download(rest)
+            : house(argv)).then((text) => {
     process.stdout.write(`${text}\n`);
     if (argv[0] === 'shell')
         process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);

package/dist/login.js

@@ -96,28 +96,27 @@ export async function login(argv) {
         open(started.start_url);
         exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
     }
-    try {
-        await placeSkillSet();
-    }
-    catch (error) {
-        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
-    }
+    await placeSkillSet();
     await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    const relayRecord = relay === undefined ? {} : { relay };
     await writeEnrolment({
         house,
-        ...(relay === undefined ? {} : { relay }),
+        ...relayRecord,
         environment: exchanged.environment,
         credential: exchanged.credential,
     });
     process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
     if (exchanged.headless_credential !== undefined) {
-        await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        await writeOwnAgent({ house, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
     else if (held && ownAgent !== null && ownAgent.user !== exchanged.user) {
         await forgetOwnAgent();
         process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
     }
-    await placeAppGit(ownAgent, await readOwnAgent());
+    else if (held && ownAgent !== null) {
+        await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
+    }
+    await placeAppGit(ownAgent, await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     try {
         startService();
     }

package/dist/resident.js

@@ -84,7 +84,7 @@ export async function resident() {
     await placeSkillSet();
     await mkdir(agentBase(), { recursive: true });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
-    const agents = new Agents(house);
+    const agents = new Agents(house, () => changed());
     const copies = new LocalCopies(house);
     await copies.load();
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
@@ -92,7 +92,7 @@ export async function resident() {
     await serveOwner(copies);
     let stream = null;
     let reported = false;
-    const idle = () => conversations.idle() && signIns.idle();
+    const idle = () => conversations.idle() && signIns.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;

package/dist/skills.js

@@ -49,6 +49,14 @@ async function install() {
     await writeHome(RECORD, { version: KIT_VERSION, names });
 }
 export async function placeSkillSet() {
+    try {
+        await replaceSkillSet();
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
+}
+async function replaceSkillSet() {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
     if (accepted && installed?.version === KIT_VERSION)
@@ -63,7 +71,9 @@ export async function placeSkillSet() {
         await rm(join(kitHome(), RECORD), { force: true });
 }
 export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
+    if (!(await readConfiguration()).skills || (await readHome(RECORD))?.version === undefined)
+        return;
+    if (await present(join(kitHome(), CREATED)))
         return;
     const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
     if (created.isError === true) {