@agentshouse/kit 0.2.1-cbabe8ad337ff → 0.2.1-cca496635583e

package/README.md

@@ -1,14 +1,12 @@
 # House Kit
 
-House Kit connects an Environment, a Linux computer or server, to
-[agents.house](https://agents.house). It runs your Agents' conversations
-through the agent CLIs you chose and gives each Agent the `house` command.
+House Kit connects an Environment, a Linux computer or server, to [agents.house](https://agents.house). It runs
+your Agents' conversations through the agent CLIs you chose and gives each Agent the `house` command.
 
 ## Install
 
-Run `curl -fsSL agents.house/kit | sh`, or `irm agents.house/kit.ps1 | iex` on
-Windows, and again to update; options follow `sh -s --`. On macOS and Linux it
-installs House Kit natively under your own account, without an admin password,
+Run `curl -fsSL agents.house/kit | sh`, or `irm agents.house/kit.ps1 | iex` on Windows, and again to update;
+options follow `sh -s --`. On macOS and Linux it installs House Kit natively under your own account, without an admin password,
 as a service that runs while you are logged in. `kit` and `house` are then on
 your login shell's `PATH`, and your workspace is `~/AgentsHouse` unless you
 pass `--workspace <path>`.
@@ -20,7 +18,7 @@ workspace. On Windows 11 the container is the one choice. Append a `kit` or
 Running the command for the other choice on a connected computer asks you to
 confirm, then replaces its Environment, whose Agents end, with a new one.
 
-On your own Ubuntu 26.04 server, run the Linux command with `--linux` to
+On your own Linux server, run the Linux command with `--linux` to
 install House Kit natively, with its workspace at `/agents/house`; `kit` and
 `house` are then on the server's `PATH`.
 
@@ -33,22 +31,24 @@ them out; running it again without the flag brings them back.
 
 ## Commands
 
-`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. Pass
-`--environment <id>` to reconnect an Environment you already have. It also
-connects your own agent: outside an Agent conversation, `house <tool>` calls
+`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>`
+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
 House as you and `git` clones and pushes your Apps at `<house>/app/` as you,
 until you revoke that connection on Connections. `house help` lists the Tools.
 `kit logout` disconnects this computer, stops House Kit and ends your own
 agent's connection, so `house` and `git` no longer act as you here; a later
 `kit login` reconnects the same Environment.
 
-`kit resident` keeps the Environment connected, and keeps the Rooms you chose
-for this Environment as Git repositories under `local-copies` in the
-workspace. Commit in one and run `house push --owner` there to send the
-commit to House; in the container, run it through the install command from the
-copy's directory. Inside an Agent conversation the Agent runs `house push`.
+`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`.
 
 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

package/dist/agents.js

@@ -257,7 +257,7 @@ export class Agents {
     }
     async load(kind) {
         const known = this.readings.get(kind);
-        if (known !== undefined && known.failure === null)
+        if (known !== undefined && known.failure === null && known.minimum === undefined)
             return;
         await this.examine(kind, SIGNED_OUT, offer);
     }

package/dist/api.js

@@ -1,5 +1,5 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { end, SIGN_IN_AGAIN } from './end.js';
+import { signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
@@ -54,7 +54,7 @@ async function enrolledPost(path, body, signal) {
     }
     catch (error) {
         if (error instanceof HouseRefusal && error.status === 401)
-            end(SIGN_IN_AGAIN);
+            await signInAgain(credential);
         throw error;
     }
 }

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -97,7 +97,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             const after = resendAfter(forwarded, attempt);
             if (after === null)
                 return forwarded;
-            // A write House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
+            // A Tool call House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
             await delay(after, undefined, { signal: closed.signal });
         }
     };
@@ -135,23 +135,9 @@ export async function openBridge(house, copies, conversationId, signal) {
         const held = JSON.parse(text).transfer;
         return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
     };
-    let mutations = null;
-    const writes = async (tool) => {
-        mutations ??= house
-            .post('/kit/tools/mutations', {}, closed.signal)
-            .then(({ tools }) => new Set(tools.filter((listed) => listed.writes).map((listed) => listed.name)));
-        try {
-            return (await mutations).has(tool);
-        }
-        catch (error) {
-            mutations = null;
-            throw error;
-        }
-    };
-    const forward = async (text) => {
+    const forward = (text) => {
         const message = JSON.parse(text);
-        const tool = message.method === 'tools/call' ? String(message.params.name) : null;
-        return send(message, tool !== null && (await writes(tool)) ? operationId() : null);
+        return send(message, message.method === 'tools/call' ? operationId() : null);
     };
     const caller = {
         key: `conversation:${conversationId}`,
@@ -173,6 +159,8 @@ export async function openBridge(house, copies, conversationId, signal) {
             const { cwd, commit } = JSON.parse(text);
             return { status: 200, text: JSON.stringify(await copies.push(cwd, commit, caller)) };
         }
+        if (path === '/git/fetch')
+            return { status: 200, text: JSON.stringify(await copies.fetch()) };
         if (path === '/git/observed') {
             await copies.observed(JSON.parse(text));
             return { status: 200, text: '{}' };
@@ -197,7 +185,8 @@ export async function openBridge(house, copies, conversationId, signal) {
                 response.writeHead(error.status, { 'content-type': 'application/json' }).end(error.text);
                 return;
             }
-            response.writeHead(502).end(request.url === '/git/push' && error instanceof Error ? error.message : UNREACHABLE);
+            const verb = request.url === '/git/push' || request.url === '/git/fetch';
+            response.writeHead(502).end(verb && error instanceof Error ? error.message : UNREACHABLE);
         }
     });
     bridge.listen(socketPath);

package/dist/conversations.js

@@ -132,6 +132,9 @@ export class Conversations {
             return false;
         return !conversations.some((conversation) => conversation.running?.scope.working() || [...conversation.leftovers].some((scope) => scope.working()));
     }
+    quiet() {
+        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.open === 0);
+    }
     look() {
         for (const conversation of this.conversations.values()) {
             for (const scope of conversation.leftovers) {

package/dist/copies.js

@@ -32,6 +32,22 @@ function rebaseFixes(refusal) {
 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 {
+        const { error: refused } = JSON.parse(error.text);
+        return refused?.code === 'expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
 }
@@ -152,8 +168,7 @@ export class LocalCopies {
     house;
     copies = new Map();
     queues = new Map();
-    delivering = new Set();
-    selecting = Promise.resolve();
+    answering = Promise.resolve();
     constructor(house) {
         this.house = house;
         this.owner = {
@@ -185,42 +200,68 @@ export class LocalCopies {
         }
     }
     async mapping() {
-        await this.selecting;
+        await this.answering;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
             .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 { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = (chosen?.rooms ?? []).flatMap((room) => room.room_handle === null ? [] : [{ key: `rooms/${room.room_ref}`, handle: room.room_handle }]);
-        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);
+    async connected() {
+        const copied = await this.answered(() => this.fetched(false));
+        if (copied.refused)
+            logged(copied.text);
     }
-    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);
+    fetch() {
+        return this.answered(() => this.fetched(true));
+    }
+    answered(work) {
+        const answered = this.answering.then(work);
+        this.answering = answered.catch(() => undefined);
+        return answered;
+    }
+    async fetched(refreshing) {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', {});
+        const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
+        return this.holding([...new Set([...this.copies.keys(), ...synced.keys()])].sort(), async () => {
+            const said = [];
+            let refused = false;
+            for (const copy of this.copies.values()) {
+                if (synced.has(copy.key) || !copy.active)
+                    continue;
+                await this.save({ ...copy, active: false });
+                said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
+            }
+            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 copy = held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle });
+                    if (copy.active)
+                        current.push(copy);
+                    else
+                        said.push(...moved(copy, await this.save(await this.received({ ...copy, active: true }))));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(`${rootOf(handle)}: ${causeOf(error)}`);
+                }
+            }
+            if (refreshing && current.length > 0) {
+                try {
+                    const refreshed = await this.refreshed(current);
+                    current.forEach((copy, index) => said.push(...moved(copy, refreshed[index])));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                }
+            }
+            return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
+        });
     }
     async observed(report) {
         const key = await this.keyAt(dirname(report.common));
@@ -270,16 +311,9 @@ export class LocalCopies {
         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(), 'local-copies', `${copy.key}.json`);
@@ -325,46 +359,13 @@ export class LocalCopies {
         }
         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: [rootOf(copy.room_handle)],
-        });
-        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.room_handle)} 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(scope.handle);
-        if (read === null) {
-            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
-            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)) {
-            logged(`${repository} already exists and House Kit leaves it as it is`);
-            return;
-        }
+        if (await exists(repository))
+            throw new Error(`${repository} already exists and House Kit leaves it as it is`);
         const staging = join(dirname(repository), `.${randomUUID()}`);
         await mkdir(staging, { recursive: true });
         let house;
@@ -372,7 +373,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf(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']);
@@ -385,9 +386,9 @@ export class LocalCopies {
             throw error;
         }
         await this.save({
-            key: scope.key,
+            key,
             room_ref: read.anchor,
-            room_handle: scope.handle,
+            room_handle: handle,
             repository,
             active: true,
             house,
@@ -399,6 +400,7 @@ export class LocalCopies {
             manifests: { [house]: { parent: null, files: read.revisions } },
             moves: [],
         });
+        return `${rootOf(handle)}: copied to ${repository}`;
     }
     async received(copy) {
         const read = await this.read(copy.room_handle);
@@ -422,29 +424,52 @@ export class LocalCopies {
         await ignoreRules(copy.repository, [...read.writable.keys()], next);
         return next;
     }
-    async caughtUp(start) {
-        let copy = start;
-        for (;;) {
+    async refreshed(copies) {
+        const discovery = await this.house.post('/kit/door/discover', {
+            prefixes: copies.map((copy) => rootOf(copy.room_handle)),
+        });
+        const regranted = new Map();
+        for (const copy of copies) {
+            const authority = discovery.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])) {
+                regranted.set(copy.key, await this.save(await this.received(copy)));
+            }
+        }
+        const caught = await this.caughtUp(copies.filter((copy) => !regranted.has(copy.key)), false);
+        return copies.map((copy) => regranted.get(copy.key) ?? caught.find((held) => held.key === copy.key));
+    }
+    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: [rootOf(copy.room_handle)],
-                    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 ? (refusalOf(error.text)?.code ?? null) : 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;
-                return copy;
+                caught.set(expired.key, await this.save(await this.received(expired)));
+                asking = asking.filter((copy) => copy !== expired);
+                continue;
+            }
+            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);
             }
-            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));
+            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);
@@ -598,12 +623,12 @@ export class LocalCopies {
                 const { upload, ...unstaged } = copy.push;
                 return this.settle(await this.save({ ...copy, push: unstaged }), caller, true);
             }
-            if (outcome.refused.code === 'operation_expired')
+            if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
             const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));
             try {
-                settled = await this.save(await this.caughtUp(settled));
+                settled = (await this.caughtUp([settled], true))[0];
             }
             catch {
                 return {
@@ -622,7 +647,7 @@ export class LocalCopies {
     }
     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.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
@@ -666,7 +691,7 @@ export class LocalCopies {
         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)))) {

package/dist/end.js

@@ -1,8 +1,18 @@
+import { forgetRejected } from './home.js';
 import { killDescendants } from './scope.js';
 export const REPLACED = 'another Kit started for this Environment';
-export const SIGN_IN_AGAIN = 'sign in again';
-export function end(reason) {
+function exit(reason, status) {
     process.stderr.write(`kit: ${reason}\n`);
     killDescendants();
-    process.exit(0);
+    process.exit(status);
+}
+export function end(reason) {
+    exit(reason, 0);
+}
+export function restart(reason) {
+    exit(reason, 1);
+}
+export async function signInAgain(rejected) {
+    await forgetRejected(rejected);
+    restart('sign in again');
 }

package/dist/enrol-main.js

@@ -1,4 +1,10 @@
 import { readFileSync } from 'node:fs';
 import { writeEnrolment } from './home.js';
 const [house, environment] = process.argv.slice(2);
-await writeEnrolment({ house: house, environment: environment, credential: readFileSync(0, 'utf8').trim() });
+const relay = process.env.HOUSE_KIT_RELAY || undefined;
+await writeEnrolment({
+    house: house,
+    ...(relay === undefined ? {} : { relay }),
+    environment: environment,
+    credential: readFileSync(0, 'utf8').trim(),
+});

package/dist/home.js

@@ -1,11 +1,13 @@
-import { existsSync } from 'node:fs';
+import { existsSync, linkSync, readFileSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
 const OWN_AGENT = 'own-agent.json';
+const RESTART = 'restart';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
@@ -32,8 +34,11 @@ export async function writeHome(name, value) {
     await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
     await rename(temporary, join(home, name));
 }
-export function readEnrolment() {
-    return readHome(ENROLMENT);
+export async function readEnrolment() {
+    const enrolment = await readHome(ENROLMENT);
+    if (enrolment !== null)
+        selectRelay(process.env.HOUSE_KIT_RELAY || enrolment.relay);
+    return enrolment;
 }
 export async function writeEnrolment(enrolment) {
     await writeHome(ENROLMENT, enrolment);
@@ -46,9 +51,42 @@ export async function forgetEnrolment({ house, environment }) {
     await writeHome(DISCONNECTED, { house, environment });
     await rm(join(kitHome(), ENROLMENT), { force: true });
 }
+export async function forgetRejected(rejected) {
+    const held = await readHome(ENROLMENT);
+    if (held?.credential !== rejected)
+        return;
+    await writeHome(DISCONNECTED, { house: held.house, environment: held.environment });
+    const enrolment = join(kitHome(), ENROLMENT);
+    const taken = `${enrolment}.${process.pid}`;
+    try {
+        renameSync(enrolment, taken);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (JSON.parse(readFileSync(taken, 'utf8')).credential !== rejected) {
+        try {
+            linkSync(taken, enrolment);
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        rmSync(join(kitHome(), DISCONNECTED), { force: true });
+    }
+    rmSync(taken);
+}
 export function enrolled() {
     return existsSync(join(kitHome(), ENROLMENT));
 }
+export function restartAsked() {
+    return existsSync(join(kitHome(), RESTART));
+}
+export function forgetRestart() {
+    return rm(join(kitHome(), RESTART), { force: true });
+}
 export function readOwnAgent() {
     return readHome(OWN_AGENT);
 }

package/dist/house-main.js

@@ -3,7 +3,8 @@ import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, join } from 'node:path';
-import { kitHome, readOwnAgent } from './home.js';
+import { HOUSE_REF } from './git.js';
+import { kitHome, readEnrolment, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
 import { relayed } from './relay.js';
@@ -11,6 +12,8 @@ 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";
+const FETCH_USAGE = 'usage: house fetch';
+const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
 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";
@@ -53,6 +56,7 @@ async function direct(message) {
     const ownAgent = await readOwnAgent();
     if (ownAgent === null)
         throw new Error(UNCONNECTED);
+    await readEnrolment();
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
         throw new Error(UNREACHABLE);
@@ -125,6 +129,14 @@ async function push(args) {
         throw new Error(pushed.text);
     return pushed.text;
 }
+async function fetched(args) {
+    if (args.includes('--help'))
+        return FETCH_USAGE;
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
+    if (answer.refused)
+        throw new Error(answer.text);
+    return answer.text;
+}
 function argumentsOf(argument) {
     if (argument === undefined)
         return {};
@@ -141,7 +153,7 @@ function argumentsOf(argument) {
 }
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help' || verb === 'help') {
-        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
+        return [USAGE, 'help', PUSH, FETCH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
@@ -170,7 +182,7 @@ async function called(name, args) {
     return text;
 }
 const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
+(argv[0] === 'push' ? push(argv.slice(1)) : argv[0] === 'fetch' ? fetched(argv.slice(1)) : 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/instructions.js

@@ -1,8 +1,10 @@
+import { HOUSE_REF } from './git.js';
 import { HOW_WE_WORK } from './skills.js';
-const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
-const FILE_LINE = 'To give the User a file or a page, upload it with `house upload` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house push`:';
+const SOURCE_LINE = "From House:";
+const HOUSE_LINE = "Work with House through the `house` CLI: run `house --help`, and `house find_command` for House's guides and formats.";
+const FILE_LINE = 'To give the User a file, upload it with `house upload` and link it; for an App, a Site or a website, follow `house find_command \'{"query":"app"}\'`. Never start a server.';
+const READ_LINE = "Optional per-Room instructions: `/rooms/private/rooms/<handle>/AGENTS.md`.";
+const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
 const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
 const FAILED = /^exit: [1-9]\d*$/;
 const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
@@ -29,6 +31,6 @@ async function howWeWork(bridge) {
     return document.replace(/\n$/, '');
 }
 export async function instructions(bridge, base, copies) {
-    const lines = [HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
     return [lines.join('\n'), base, await howWeWork(bridge)].filter((part) => part !== '').join('\n\n');
 }

package/dist/login.js

@@ -6,6 +6,8 @@ import { post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
 import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
 import { callHouse, rpc } from './mcp.js';
+import { selectRelay } from './relay.js';
+import { startService } from './service.js';
 const DEFAULT_HOUSE = 'https://agents.house';
 const OPENER = process.platform === 'darwin' ? 'open' : 'xdg-open';
 // Polling every two seconds brings the User's confirmation to the waiting Kit moments after they give it.
@@ -23,39 +25,93 @@ async function accepted(house, credential) {
         return false;
     throw new Error(`House answered ${checked.status} when Kit checked this computer's own agent's connection: ${checked.text}`);
 }
+const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms <ref>[,<ref>...] | --no-private] [--code <code>]
+  --house <origin>          the House to connect to, ${DEFAULT_HOUSE} unless one is stored
+  --environment <id>        reconnect this Environment
+  --rooms <ref>[,<ref>...]  give this Environment only these Rooms
+  --no-private              give this Environment every Room but your Private Room
+  --code <code>             connect this machine with a login code
+`;
+function chosenRooms(rooms, noPrivate) {
+    if (rooms !== undefined && noPrivate)
+        throw new Error('--rooms and --no-private are two choices of Rooms; pass one');
+    if (rooms !== undefined)
+        return { rooms: { reach: 'selected', refs: rooms.split(',') } };
+    return noPrivate ? { rooms: { reach: 'all_but_private' } } : {};
+}
 export async function login(argv) {
     const { values } = parseArgs({
         args: argv,
         options: {
             house: { type: 'string' },
             environment: { type: 'string' },
+            rooms: { type: 'string' },
+            'no-private': { type: 'boolean', default: false },
+            code: { type: 'string' },
+            help: { type: 'boolean', default: false },
         },
     });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.code !== undefined && values.rooms !== undefined)
+        throw new Error('--code cannot be used with --rooms');
+    if (values.code !== undefined && values['no-private'])
+        throw new Error('--code cannot be used with --no-private');
+    if (values.code !== undefined && values.environment !== undefined)
+        throw new Error('--code cannot be used with --environment');
+    const rooms = chosenRooms(values.rooms, values['no-private']);
     const enrolled = (await readEnrolment()) ?? (await readDisconnected());
+    if (values.code !== undefined && enrolled !== null) {
+        throw new Error(`--code connects a new machine; this Kit home records Environment ${enrolled.environment}, so run kit login to reconnect it`);
+    }
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    selectRelay(relay);
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
     const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
     const ownAgent = await readOwnAgent();
-    const held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
-    const verifier = randomBytes(32).toString('base64url');
-    const started = await retrying(() => post(house, '/kit', {
-        ...(environment === undefined
-            ? { act: 'new_environment', label: hostname(), ...(replaces === undefined ? {} : { replaces }) }
-            : { act: 'existing_environment', environment_id: environment }),
-        code_challenge: createHash('sha256').update(verifier).digest('base64url'),
-        ...(held ? {} : { headless: true }),
-    }));
-    process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
-    open(started.start_url);
-    const exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
-    await writeEnrolment({ house, environment: exchanged.environment, credential: exchanged.credential });
+    let held = false;
+    let exchanged;
+    if (values.code !== undefined) {
+        exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
+    }
+    else {
+        held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
+        const verifier = randomBytes(32).toString('base64url');
+        const started = await retrying(() => post(house, '/kit', {
+            label: hostname(),
+            ...(environment === undefined
+                ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
+                : { act: 'existing_environment', environment_id: environment }),
+            ...rooms,
+            code_challenge: createHash('sha256').update(verifier).digest('base64url'),
+            ...(held ? {} : { headless: true }),
+        }));
+        process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
+        open(started.start_url);
+        exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
+    }
+    await writeEnrolment({
+        house,
+        ...(relay === undefined ? {} : { relay }),
+        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 });
     }
-    else if (held && ownAgent.user !== exchanged.user) {
+    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());
+    try {
+        startService();
+    }
+    catch (error) {
+        process.stderr.write(`kit: ${error.message}\n`);
+    }
 }

package/dist/relay.js

@@ -1,7 +1,17 @@
+let selected;
+export function selectRelay(relay) {
+    selected = relay === undefined || relay === '' ? null : relay;
+}
+function relayOrigin() {
+    if (selected !== undefined)
+        return selected ?? undefined;
+    const ambient = process.env.HOUSE_KIT_RELAY;
+    return ambient === undefined || ambient === '' ? undefined : ambient;
+}
 export function relayed(target) {
     const url = new URL(target);
-    const relay = process.env.HOUSE_KIT_RELAY;
-    if (relay === undefined || relay === '')
+    const relay = relayOrigin();
+    if (relay === undefined)
         return url;
     const through = new URL(`${url.host}${url.pathname}${url.search}`, `${relay}/`);
     if (url.protocol === 'wss:' || url.protocol === 'ws:')

package/dist/resident.js

@@ -9,7 +9,8 @@ import { house } from './api.js';
 import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
-import { agentBase, enrolled, kitHome } from './home.js';
+import { restart } from './end.js';
+import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
@@ -33,13 +34,20 @@ async function serveOwner(copies) {
     await rm(socketPath, { force: true });
     const server = createServer(async (request, response) => {
         try {
-            if (request.url !== '/git/push') {
+            const text = await received(request);
+            let answered;
+            if (request.url === '/git/fetch') {
+                answered = await copies.fetch();
+            }
+            else if (request.url === '/git/push') {
+                const { cwd, commit } = JSON.parse(text);
+                answered = await copies.push(cwd, commit, copies.owner);
+            }
+            else {
                 response.writeHead(404).end();
                 return;
             }
-            const { cwd, commit } = JSON.parse(await received(request));
-            const pushed = await copies.push(cwd, commit, copies.owner);
-            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(pushed));
+            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(answered));
         }
         catch (error) {
             response.writeHead(502).end(error instanceof Error ? error.message : String(error));
@@ -66,6 +74,7 @@ function connected() {
 }
 export async function resident() {
     await connected();
+    await forgetRestart();
     watch(kitHome(), () => {
         if (enrolled())
             return;
@@ -88,6 +97,9 @@ export async function resident() {
         if (!idle()) {
             reported = false;
         }
+        else if (restartAsked() && conversations.quiet()) {
+            restart('restarting for an updated CLI');
+        }
         else if (!reported) {
             reported = true;
             logged(house.deliver('/kit/idle', {}, idle));
@@ -115,18 +127,13 @@ export async function resident() {
         opened: () => {
             conversations.opened();
             changed();
-            logged(copies.select());
+            logged(copies.connected());
         },
         frame: (arrived) => {
             if (arrived.type === 'watching')
                 conversations.watching(arrived.watching === true);
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
-            if (arrived.type === 'work_available' && arrived.subject === 'local_copy')
-                logged(copies.select());
-            if (arrived.type === 'entries') {
-                copies.entries(arrived);
-            }
             if (arrived.type === 'input') {
                 reported = false;
                 if (arrived.kind === 'sign_in')

package/dist/service-main.js

@@ -0,0 +1,9 @@
+import { startService } from './service.js';
+try {
+    if (startService())
+        process.stdout.write('started\n');
+}
+catch (error) {
+    process.stderr.write(`kit: ${error.message}\n`);
+    process.exitCode = 1;
+}

package/dist/service.js

@@ -0,0 +1,33 @@
+import { spawnSync } from 'node:child_process';
+const UNIT = 'house-kit.service';
+// launchctl and systemctl answer at once, so ten seconds only bounds a stuck service manager.
+const MANAGER_MS = 10_000;
+function manage(command, args) {
+    return spawnSync(command, args, { encoding: 'utf8', timeout: MANAGER_MS });
+}
+function start(command, args) {
+    const started = manage(command, args);
+    if (started.status === 0)
+        return;
+    const cause = started.error?.message ?? (started.stderr.trim() || `${command} exited with ${started.status ?? 'a signal'}`);
+    throw new Error(`the House Kit service could not be started: ${cause}`);
+}
+export function startService() {
+    if (process.platform === 'darwin') {
+        const service = `gui/${process.getuid()}/house-kit`;
+        const printed = manage('launchctl', ['print', service]);
+        if (printed.status !== 0 || /^\tstate = running$/m.test(printed.stdout))
+            return false;
+        start('launchctl', ['kickstart', service]);
+        return true;
+    }
+    for (const scope of [['--user'], []]) {
+        if (manage('systemctl', [...scope, 'is-enabled', '--quiet', UNIT]).status !== 0)
+            continue;
+        if (manage('systemctl', [...scope, 'is-active', '--quiet', UNIT]).status === 0)
+            return false;
+        start('systemctl', [...scope, 'start', UNIT]);
+        return true;
+    }
+    return false;
+}

package/dist/stream.js

@@ -1,6 +1,6 @@
 import { subscribe } from 'node:diagnostics_channel';
 import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, SIGN_IN_AGAIN } from './end.js';
+import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
 const PATH = '/kit/stream';
@@ -52,8 +52,10 @@ export function holdStream(handlers) {
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
             if (event.reason === 'replaced')
                 end(REPLACED);
-            if (event.reason === 'credential_rejected' || refused?.status === 401)
-                end(SIGN_IN_AGAIN);
+            if (event.reason === 'credential_rejected' || refused?.status === 401) {
+                void signInAgain(credential);
+                return;
+            }
             if (finalRefusal(refused))
                 end(refused.message);
             // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-cbabe8ad337ff",
+  "version": "0.2.1-cca496635583e",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.19",
+    "@agentshouse/mdmodel": "0.1.0-c68e2039f1ca8",
     "yaml": "2.9.1"
   },
   "peerDependencies": {