@agentshouse/kit 0.2.1-c681dfca497a8 → 0.2.1-c70284f7a7466

package/dist/conversations.js

@@ -1,4 +1,4 @@
-import { client, } from '@agentclientprotocol/sdk';
+import { client, RequestError, } from '@agentclientprotocol/sdk';
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
@@ -6,7 +6,7 @@ import { unlessAborted } from './abort.js';
 import { startAdapter } from './acp.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
-import { readerFor } from './events.js';
+import { answeredFailure, readerFor } from './events.js';
 import { placeFiles, uploadBytes } from './files.js';
 import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
@@ -16,17 +16,56 @@ import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
 import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
+const SIGNED_OUT = RequestError.authRequired().code;
 const KILLED = 'the conversation was killed';
+const REFUSED = 'the CLI refused the prompt';
+const NO_CONNECTION = "the Kit could not open this conversation's connection";
+const NO_START = "the Agent's CLI did not start";
+const NO_SESSION = "the Agent's CLI did not open a session";
+const NO_RESUME = "the Agent's CLI could not resume this conversation";
+const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
+class NotStarted extends Error {
+}
+async function step(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new NotStarted(reason, { cause: error });
+    }
+}
+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);
 }
+function answeredWith(error) {
+    const signedOut = typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
+    return { failure: signedOut ? 'signed_out' : 'error', cause: causeOf(error) };
+}
+function exitedWith(running, cause) {
+    return running.killed ? { failure: 'killed', cause: KILLED } : { failure: 'exited', cause };
+}
 function answerMessage(request, response) {
     return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
 }
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
+function refusal(conversation, error) {
+    if (conversation.kills > 0)
+        return KILLED;
+    const cause = error instanceof NotStarted ? `${error.message}: ${causeOf(error.cause)}` : causeOf(error);
+    logged(new Error(`conversation ${conversation.id} did not start: ${cause}`));
+    return causeOf(error);
+}
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
@@ -57,6 +96,7 @@ class Conversation {
     subagents = new Map();
     held = [];
     opening = null;
+    prompted = null;
     kills = 0;
     killed = new AbortController();
     interrupts = 0;
@@ -200,10 +240,10 @@ export class Conversations {
         if (conversation.running !== null)
             return {};
         try {
-            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null) };
+            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null, true) };
         }
         catch (error) {
-            return { refused: causeOf(error) };
+            return { refused: refusal(conversation, error) };
         }
     }
     async message(conversation, input) {
@@ -220,7 +260,7 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
-            return { ack: Promise.resolve({ refused: conversation.kills > 0 ? KILLED : causeOf(error) }) };
+            return { ack: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
         return {
             ack: new Promise((settle) => {
@@ -243,13 +283,17 @@ export class Conversations {
     async send(conversation, waiting) {
         const { input } = waiting;
         let ack = {};
+        let started = false;
         const prompt = [];
         try {
             if (conversation.running === null) {
-                const resumed = input.provider_session_id ?? conversation.session;
-                const opened = await this.start(conversation, waiting.route, resumed);
-                if (resumed === null)
-                    ack = { provider_session_id: opened };
+                const stored = conversation.session ?? input.provider_session_id;
+                const empty = input.first === true && conversation.prompted !== stored;
+                started = (await this.start(conversation, waiting.route, stored, empty)) !== stored;
+            }
+            const session = conversation.running.sessionId;
+            if (started || (input.first === true && session !== input.provider_session_id)) {
+                ack = { provider_session_id: session };
             }
             if (input.first === true) {
                 prompt.push({
@@ -261,11 +305,11 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
-            if ('provider_session_id' in ack) {
+            if (started) {
                 conversation.session = null;
                 await this.kill(conversation);
             }
-            waiting.settle({ refused: conversation.kills > 0 ? KILLED : causeOf(error) });
+            waiting.settle({ refused: refusal(conversation, error) });
             return;
         }
         this.prompt(conversation, [...prompt, ...waiting.content]);
@@ -343,14 +387,15 @@ export class Conversations {
         }
         return route;
     }
-    async start(conversation, route, sessionId) {
+    async start(conversation, route, sessionId, empty) {
         const reader = readerFor(route.kind);
         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);
+        const bridge = await step(NO_CONNECTION, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
@@ -361,24 +406,24 @@ export class Conversations {
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
-            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+            const streamed = await step(NO_CONNECTION, work.open(cli));
+            const adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
                 work.read(message);
                 this.read(conversation, reader, message);
-            }, { ...bridge.env, ...(await work.open(cli)) }, undefined, scope);
+            }, { ...bridge.env, ...streamed }, undefined, scope));
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
             const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
-            const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
+            const resumed = sessionId === null ? null : await this.resume(conversation, route.kind, adapter, { sessionId, cwd, mcpServers: [], _meta }, empty);
+            const opened = resumed ?? (await step(NO_SESSION, agent.request('session/new', { cwd, mcpServers: [], _meta })));
             reader.session = opened.sessionId;
-            if (sessionId === null && CLIS[route.kind].renames) {
+            if (opened.sessionId !== sessionId && CLIS[route.kind].renames) {
                 const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
-                await agent.request('session/prompt', { sessionId: opened.sessionId, prompt });
+                await step(NO_SESSION, agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
             }
             const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
-            const options = await this.launchSettings(running, route, opened.configOptions ?? []);
+            const options = await step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
             void work.settled().then(() => scope.record());
             conversation.running = running;
             conversation.session = running.sessionId;
@@ -400,6 +445,18 @@ export class Conversations {
             conversation.opening = null;
         }
     }
+    async resume(conversation, kind, adapter, request, empty) {
+        try {
+            return { ...(await adapter.connection.agent.request('session/resume', request)), sessionId: request.sessionId };
+        }
+        catch (error) {
+            if (!empty || conversation.kills > 0 || !CLIS[kind].unknownSession(error)) {
+                throw new NotStarted(NO_RESUME, { cause: error });
+            }
+            logged(new Error(`conversation ${conversation.id} opens a new session: ${NO_RESUME}: ${causeOf(error)}`));
+            return null;
+        }
+    }
     async launchSettings(running, route, offered) {
         let options = offered;
         const settings = [
@@ -427,7 +484,7 @@ export class Conversations {
             return;
         this.detach(conversation, running);
         if (conversation.turn !== null) {
-            this.end(conversation, conversation.turn, { failed: running.killed ? KILLED : cause });
+            this.end(conversation, conversation.turn, exitedWith(running, cause));
         }
         this.next(conversation);
         this.kit.changed();
@@ -491,13 +548,17 @@ export class Conversations {
         this.kit.changed();
         return turn;
     }
-    end(conversation, turn, failed) {
+    end(conversation, turn, failed, notice = null) {
         if (turn.ended)
             return;
+        if (failed !== null)
+            logged(new Error(`conversation ${conversation.id} turn ${turn.id} failed: ${failed.cause}`));
         if (conversation.turn === turn) {
             for (const event of conversation.running?.reader.closeTurn() ?? [])
                 this.apply(conversation, turn, event);
         }
+        if (notice !== null)
+            turn.parts.start({ type: 'marker', marker: 'retry', text: notice });
         turn.ended = true;
         conversation.open--;
         if (conversation.turn === turn)
@@ -505,7 +566,7 @@ export class Conversations {
         const body = Promise.allSettled(turn.uploads).then(() => ({
             parts: turn.parts.saved(),
             context: turn.parts.context,
-            ...failed,
+            ...(failed === null ? {} : { failed: failed.failure }),
         }));
         void this.deliver(conversation, turn, 'ended', body).catch(logged);
         this.next(conversation);
@@ -515,16 +576,25 @@ export class Conversations {
         const running = conversation.running;
         const turn = this.begin(conversation);
         turn.prompted = true;
-        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then(() => this.end(conversation, turn, null), async (error) => {
+        conversation.prompted = running.sessionId;
+        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
+            const notice = answeredFailure(answer);
+            if (notice !== null) {
+                this.end(conversation, turn, { failure: notice.limit ? 'limit' : 'error', cause: notice.title }, notice.title);
+            }
+            else {
+                this.end(conversation, turn, answer.stopReason === 'refusal' ? { failure: 'refused', cause: REFUSED } : null);
+            }
+        }, async (error) => {
             if (running.adapter.connection.signal.aborted) {
-                this.end(conversation, turn, { failed: running.killed ? KILLED : await running.adapter.exited });
+                this.end(conversation, turn, exitedWith(running, await running.adapter.exited));
             }
             else {
                 if (conversation.open === 1 && conversation.running === running) {
                     running.scope.kill();
                     this.detach(conversation, running);
                 }
-                this.end(conversation, turn, { failed: causeOf(error) });
+                this.end(conversation, turn, answeredWith(error));
             }
         });
     }

package/dist/copies.js

@@ -15,6 +15,9 @@ const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function houseCause(error) {
+    return error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
@@ -33,6 +36,9 @@ function textOnly(paths) {
     const [named, them] = paths.length === 1 ? [`${paths[0]} is`, 'it'] : [`${paths.join(', ')} are`, 'them'];
     return `${named} not text, and house push sends text only; remove ${them} from the commit and place ${them} with house upload`;
 }
+function outside(path) {
+    return { refused: true, text: `${path} is not a House Local copy; run house push inside one` };
+}
 function short(commit) {
     return commit.slice(0, 12);
 }
@@ -60,6 +66,9 @@ function sidecar(path) {
     segments.splice(-1, 0, PROVENANCE);
     return segments.join('/');
 }
+function recordOf(key) {
+    return join(kitHome(), 'local-copies', `${key}.json`);
+}
 function rootOf(handle) {
     return `/rooms/${handle}`;
 }
@@ -206,7 +215,7 @@ export class LocalCopies {
     async mapping() {
         await this.answering;
         return [...this.copies.values()]
-            .filter((copy) => copy.active)
+            .filter((copy) => copy.erasing === undefined)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
@@ -229,25 +238,30 @@ export class LocalCopies {
         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)
+            for (const copy of [...this.copies.values()]) {
+                const returned = synced.has(copy.key);
+                if (returned && copy.erasing === undefined)
                     continue;
-                await this.save({ ...copy, active: false });
-                said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
+                try {
+                    await this.erase(copy);
+                    said.push(`${rootOf(copy.room_handle)}: ${returned ? '' : 'no longer synced to this Environment; '}erased from the Local copy`);
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(`${rootOf(copy.room_handle)}: ${causeOf(error)}`);
+                }
             }
             const current = [];
             for (const [key, handle] of synced) {
                 try {
                     const held = this.copies.get(key);
+                    if (held?.erasing)
+                        continue;
                     if (held === undefined || !(await exists(held.repository))) {
                         said.push(await this.materialize(key, handle));
                         continue;
                     }
-                    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 }))));
+                    current.push(held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle }));
                 }
                 catch (error) {
                     refused = true;
@@ -261,7 +275,7 @@ export class LocalCopies {
                 }
                 catch (error) {
                     refused = true;
-                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                    said.push(houseCause(error));
                 }
             }
             return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
@@ -273,6 +287,8 @@ export class LocalCopies {
             return;
         await this.exclusive(key, async () => {
             const copy = this.copies.get(key);
+            if (copy === undefined || copy.erasing)
+                return;
             let moves = copy.moves;
             for (const { from, to } of report.moves) {
                 const held = moves.find((move) => move.worktree === report.worktree && move.to === from);
@@ -295,11 +311,11 @@ export class LocalCopies {
     async push(cwd, selector, caller) {
         const located = await run(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
         if (located.status !== 0)
-            return { refused: true, text: `${cwd} is not a House Local copy; run house push inside one` };
+            return outside(cwd);
         const [common, worktree] = located.stdout.toString('utf8').split('\n');
         const key = await this.keyAt(dirname(common));
         if (key === undefined)
-            return { refused: true, text: `${worktree} is not a House Local copy; run house push inside one` };
+            return outside(worktree);
         return this.exclusive(key, () => this.pushed(key, worktree, selector, caller));
     }
     async keyAt(repository) {
@@ -320,7 +336,7 @@ export class LocalCopies {
         return key === undefined ? work() : this.exclusive(key, () => this.holding(rest, work));
     }
     async save(copy) {
-        const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
+        const path = recordOf(copy.key);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -328,6 +344,12 @@ export class LocalCopies {
         this.copies.set(copy.key, copy);
         return copy;
     }
+    async erase(copy) {
+        await this.save({ ...copy, erasing: true });
+        await rm(copy.repository, { recursive: true, force: true });
+        await rm(recordOf(copy.key), { force: true });
+        this.copies.delete(copy.key);
+    }
     async read(handle) {
         const prefixes = [rootOf(handle)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
@@ -394,7 +416,6 @@ export class LocalCopies {
             room_ref: read.anchor,
             room_handle: handle,
             repository,
-            active: true,
             house,
             position: read.position,
             log_epoch: read.log_epoch,
@@ -523,6 +544,8 @@ export class LocalCopies {
     }
     async pushed(key, worktree, selector, caller) {
         let copy = this.copies.get(key);
+        if (copy === undefined || copy.erasing)
+            return outside(worktree);
         if (copy.push?.state === 'submitted')
             return this.settle(copy, caller);
         const selected = await run(worktree, ['rev-parse', '--verify', '--quiet', '--end-of-options', `${selector}^{commit}`]);
@@ -536,9 +559,6 @@ export class LocalCopies {
             }
             copy = await this.save(without(copy));
         }
-        if (!copy.active) {
-            return { refused: true, text: `${rootOf(copy.room_handle)} is no longer synced to this Environment, so House takes no push from it` };
-        }
         const listed = (await git(copy.repository, ['rev-list', '--topo-order', commit])).split('\n');
         const base = listed.find((ancestor) => ancestor in copy.manifests);
         if (base === undefined) {
@@ -549,7 +569,7 @@ export class LocalCopies {
             changes = await this.derived(copy, base, commit);
         }
         catch (error) {
-            return { refused: true, text: causeOf(error) };
+            return { refused: true, text: houseCause(error) };
         }
         if (changes.length === 0)
             return { refused: false, text: `Nothing to submit: ${short(commit)} matches House.` };
@@ -576,12 +596,17 @@ export class LocalCopies {
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
         const arrived = new Set(moved.values());
-        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 arriving = [...after].filter(([path, entry]) => before.get(path) !== entry);
+        if (arriving.length > 0) {
+            const { bounds } = await this.house.post('/kit/door/discover', { prefixes: [root] });
+            const binary = [];
+            for (const [path, entry] of arriving) {
+                if (!(await isText(copy.repository, entry, bounds.max_authored_file_bytes)))
+                    binary.push(path);
+            }
+            if (binary.length > 0)
+                throw new Error(textOnly(binary));
+        }
         const text = (entry) => blobText(copy.repository, entry);
         const changes = [];
         for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {

package/dist/end.js

@@ -13,8 +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 function updateRequired() {
+    const command = installCommand();
+    end(command === null ? 'This Kit is too old for House; install it again.' : `This Kit is too old for House. Update it: ${command}`);
 }
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);

package/dist/events.js

@@ -512,6 +512,10 @@ class GrokReader extends Reader {
         return [];
     }
 }
+export function answeredFailure(answer) {
+    const failure = answer._meta?.jetbrains?.air?.sessionFailure;
+    return typeof failure?.title === 'string' ? { title: failure.title, limit: failure.category === 'limit' } : null;
+}
 export function readerFor(kind) {
     if (kind === 'claude-agent-acp')
         return new ClaudeReader();

package/dist/git.js

@@ -49,16 +49,15 @@ export async function tree(repository, commit) {
     }
     return entries;
 }
-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) {
+export async function isText(repository, object, maxBytes) {
     const bytes = await blob(repository, object);
-    return bytes.length <= TEXT_MAX_BYTES && isUtf8(bytes) && !bytes.includes(0);
+    return bytes.length <= maxBytes && isUtf8(bytes) && !bytes.includes(0);
 }
 export function blobId(content) {
     const bytes = Buffer.from(content, 'utf8');

package/dist/home.js

@@ -1,7 +1,8 @@
-import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { accessSync, chmodSync, constants, existsSync, linkSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync } from 'node:fs';
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import { selectRelay } from './relay.js';
 const ENROLMENT = 'credential.json';
 const DISCONNECTED = 'disconnected.json';
@@ -18,24 +19,26 @@ function writable(directory) {
         return false;
     }
 }
-function ownTemporaryHome() {
-    const home = join(tmpdir(), `house-kit-${process.getuid()}`);
+function privateDirectory(path) {
     try {
-        mkdirSync(home, { mode: 0o700 });
+        mkdirSync(path, { mode: 0o700 });
     }
     catch (error) {
         if (error.code !== 'EEXIST')
             throw error;
     }
-    const found = lstatSync(home);
+    const found = lstatSync(path);
     if (found.isSymbolicLink())
-        throw new Error(`${home} is a symbolic link`);
+        throw new Error(`${path} 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;
+        throw new Error(`${path} is not a directory`);
+    if (found.uid !== process.geteuid())
+        throw new Error(`${path} is not owned by this User`);
+    chmodSync(path, 0o700);
+    return path;
+}
+function ownTemporaryHome() {
+    return privateDirectory(join(tmpdir(), `house-kit-${process.getuid()}`));
 }
 function defaultHome() {
     const home = join(homedir(), '.house-kit');
@@ -44,6 +47,18 @@ function defaultHome() {
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME || (defaulted ??= defaultHome());
 }
+export function socketDirectory() {
+    const sockets = privateDirectory(join(realpathSync('/tmp'), `hk-${process.geteuid()}`));
+    const home = kitHome();
+    const physical = existsSync(home) ? realpathSync(home) : resolve(home);
+    return privateDirectory(join(sockets, createHash('sha256').update(physical).digest('hex').slice(0, 12)));
+}
+export function ownerSocket() {
+    return join(socketDirectory(), 'owner.sock');
+}
+export function ownerLock() {
+    return join(socketDirectory(), 'owner.lock');
+}
 export function workspaceRoot() {
     return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
 }
@@ -63,7 +78,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));
 }
@@ -80,6 +95,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 });