@agentshouse/kit 0.2.1-c96543a4c8b15 → 0.2.1-ca18b01951c3b

package/README.md

@@ -33,26 +33,27 @@ 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.
+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. Codex sessions started after a
 login run a lone `house` command outside their sandbox. `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.
+longer act as you here; a later `kit login` reconnects the same Environment, or connects
+this computer as a new one when House no longer holds it.
+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

@@ -3,8 +3,10 @@ import { readFile, realpath } from 'node:fs/promises';
 import { startAdapter } from './acp.js';
 import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
+import { updatesItself } from './placement.js';
 import { killTree } from './scope.js';
 import { holdTranscription, transcriptionReport } from './transcription.js';
+import { KIT_WIRE } from './wire.js';
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
@@ -22,6 +24,22 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+const LAPTOP_CHASSIS = new Set(['8', '9', '10', '14', '30', '31', '32']);
+const DESKTOP_CHASSIS = new Set(['3', '4', '5', '6', '7', '15', '16']);
+const SERVER_CHASSIS = new Set(['17', '18', '19', '20', '21', '22', '23', '24']);
+export function chassisForm(value) {
+    const chassis = value.trim();
+    if (LAPTOP_CHASSIS.has(chassis))
+        return 'laptop';
+    if (DESKTOP_CHASSIS.has(chassis))
+        return 'desktop';
+    if (SERVER_CHASSIS.has(chassis))
+        return 'server';
+    return undefined;
+}
+export function hostVm(version) {
+    return /docker desktop|microsoft|wsl|linuxkit/i.test(version);
+}
 async function models(kind, adapter, known) {
     const agent = adapter.connection.agent;
     const opened = await agent.request('session/new', { cwd: kitHome(), mcpServers: [] });
@@ -120,6 +138,22 @@ async function operatingSystem() {
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
+async function hostForm() {
+    if (process.platform === 'darwin') {
+        const battery = await run('pmset', ['-g', 'batt'], 10_000);
+        return battery.status === 0 && battery.output.includes('InternalBattery') ? 'laptop' : 'desktop';
+    }
+    if (process.platform !== 'linux')
+        return undefined;
+    const [container, version, chassis] = await Promise.all([
+        readFile('/.dockerenv', 'utf8').then(() => true).catch(() => false),
+        readFile('/proc/version', 'utf8').catch(() => ''),
+        readFile('/sys/class/dmi/id/chassis_type', 'utf8').catch(() => ''),
+    ]);
+    if (container && hostVm(version))
+        return undefined;
+    return chassisForm(chassis);
+}
 export class Agents {
     desired = { agents: [], routes: [], transcribe: false };
     house;
@@ -130,8 +164,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);
@@ -140,19 +180,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 () => {
@@ -260,6 +309,7 @@ export class Agents {
         if (known !== undefined && known.failure === null && known.minimum === undefined)
             return;
         await this.examine(kind, SIGNED_OUT, offer);
+        await this.report();
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {
@@ -267,9 +317,13 @@ export class Agents {
             return reading === undefined ? [] : [reported(kind, reading)];
         });
         const hostKey = await sshHostKey();
+        const form = await hostForm();
         const body = {
             os: await operatingSystem(),
+            ...(form === undefined ? {} : { form }),
             kit_version: KIT_VERSION,
+            wire: KIT_WIRE,
+            updates_itself: await updatesItself(),
             agent_base: agentBase(),
             agents,
             transcription: transcriptionReport(),

package/dist/api.js

@@ -1,8 +1,9 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { signInAgain } from './end.js';
+import { signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
 import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
+import { KIT_WIRE, KIT_WIRE_HEADER, tooOld } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -37,12 +38,15 @@ export async function post(house, path, body, credential, signal) {
         method: 'POST',
         headers: {
             'content-type': 'application/json',
+            [KIT_WIRE_HEADER]: String(KIT_WIRE),
             ...(credential === undefined ? {} : { authorization: `Bearer ${credential}` }),
         },
         body: JSON.stringify(body),
         signal,
     });
     const text = await answer.text();
+    if (!answer.ok && tooOld(text))
+        updateRequired(house);
     if (!answer.ok)
         throw new HouseRefusal(path, answer.status, text);
     return JSON.parse(text);

package/dist/bootstrap.json

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

package/dist/chatgpt.js

@@ -0,0 +1,29 @@
+import { parseArgs } from 'node:util';
+import { placeAppGit } from './app-git.js';
+import { kitHome, readOwnAgent, writeOwnAgent } from './home.js';
+import { accepted, DEFAULT_HOUSE } from './login.js';
+const KEY_SOURCE = 'New key for a script on Connections';
+const USAGE = `usage: kit chatgpt --key <key> [--house <origin>]
+  --key <key>       a key from ${KEY_SOURCE}
+  --house <origin>  the House of the key, ${DEFAULT_HOUSE} unless one is stored
+`;
+export async function chatgpt(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { key: { type: 'string' }, house: { type: 'string' }, help: { type: 'boolean', default: false } },
+    });
+    if (values.help) {
+        process.stdout.write(USAGE);
+        return;
+    }
+    if (values.key === undefined)
+        throw new Error(`pass --key with a key from ${KEY_SOURCE}`);
+    const before = await readOwnAgent();
+    const house = values.house ?? before?.house ?? DEFAULT_HOUSE;
+    if (!(await accepted(house, values.key)))
+        throw new Error(`${house} does not accept this key; pass one from ${KEY_SOURCE}`);
+    const relay = process.env.HOUSE_KIT_RELAY || undefined;
+    await writeOwnAgent({ house, ...(relay === undefined ? {} : { relay }), credential: values.key });
+    await placeAppGit(before, await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    process.stdout.write(`house now calls ${house} as you, with the key kept in ${kitHome()}.\n`);
+}

package/dist/clis.js

@@ -1,8 +1,9 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { constants, readFileSync } from 'node:fs';
 import { access, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import { homedir, userInfo } from 'node:os';
-import { delimiter, isAbsolute, join } from 'node:path';
+import { delimiter, dirname, isAbsolute, join } from 'node:path';
 import { kitHome } from './home.js';
 const HOUSE_EXECUTABLES = /^host_executable\(name = "house", paths = (\[.*\])\)$/m;
 function houseRule(houses) {
@@ -54,7 +55,7 @@ export async function allowHouseInCodex(path) {
             houses.push(house);
     }
     await mkdir(rules, { recursive: true });
-    const temporary = `${file}.${process.pid}`;
+    const temporary = `${file}.${randomUUID()}`;
     await writeFile(temporary, houseRule(houses));
     await rename(temporary, file);
 }
@@ -199,7 +200,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) {
@@ -224,6 +225,12 @@ export async function loginPath() {
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
+export async function writeCodexRule() {
+    const shell = await loginPath().catch(() => '');
+    await allowHouseInCodex([dirname(process.execPath), process.env.PATH ?? '', shell].join(delimiter)).catch((error) => {
+        throw new Error(`Codex's rule for house could not be written: ${error.message}`);
+    });
+}
 export async function versionOf(path, signal) {
     return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }

package/dist/conversations.js

@@ -17,6 +17,15 @@ import { createHowWeWork } from './skills.js';
 import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
 const KILLED = 'the conversation was killed';
+const EXIT_PLAN_MODE = {
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error('_x.ai/exit_plan_mode needs an object');
+        }
+        return value;
+    },
+};
+export const CONVERSATION_INPUTS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -347,7 +356,8 @@ export class Conversations {
         reader.session = sessionId;
         const app = client({ name: '@agentshouse/kit' })
             .onRequest('session/request_permission', ({ params, signal }) => this.ask(conversation, 'session/request_permission', params, false, signal))
-            .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal));
+            .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal))
+            .onRequest('_x.ai/exit_plan_mode', EXIT_PLAN_MODE, ({ params, signal }) => this.ask(conversation, '_x.ai/exit_plan_mode', params, false, signal));
         const cli = await unlessAborted(this.kit.agents.cli(route.kind), conversation.killed.signal);
         const bridge = await openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
         if (conversation.kills > 0) {

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/end.js

@@ -1,4 +1,5 @@
 import { forgetRejected } from './home.js';
+import { installCommand } from './placement.js';
 import { killDescendants } from './scope.js';
 export const REPLACED = 'another Kit started for this Environment';
 function exit(reason, status) {
@@ -12,6 +13,9 @@ export function end(reason) {
 export function restart(reason) {
     exit(reason, 1);
 }
+export function updateRequired(house) {
+    end(`This Kit is too old for House. Update it: ${installCommand(house)}`);
+}
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);
     restart('sign in again');

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,7 @@
-import { existsSync, linkSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+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 +9,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';
@@ -30,7 +64,7 @@ export async function readHome(name) {
 export async function writeHome(name, value) {
     const home = kitHome();
     await mkdir(home, { recursive: true, mode: 0o700 });
-    const temporary = join(home, `${name}.${process.pid}`);
+    const temporary = join(home, `${name}.${randomUUID()}`);
     await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600 });
     await rename(temporary, join(home, name));
 }
@@ -47,6 +81,9 @@ export async function writeEnrolment(enrolment) {
 export function readDisconnected() {
     return readHome(DISCONNECTED);
 }
+export function forgetDisconnected() {
+    return rm(join(kitHome(), DISCONNECTED), { force: true });
+}
 export async function forgetEnrolment({ house, environment }) {
     await writeHome(DISCONNECTED, { house, environment });
     await rm(join(kitHome(), ENROLMENT), { force: true });