@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c5262a8cc063d

package/dist/conversations.js

@@ -2,15 +2,17 @@ import { client, } from '@agentclientprotocol/sdk';
 import { randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { unlessAborted } from './abort.js';
 import { killMarked, startAdapter, TURN_ENDED, TURN_STARTED } from './acp.js';
 import { blocksOf, firstChange } from './blocks.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { placeFiles } from './files.js';
+import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
-const LAUNCH_BASE = '/agents/house';
+import { transcribe } from './transcription.js';
 const KILLED = 'the conversation was killed';
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -21,21 +23,15 @@ function answerMessage(request, response) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
-function unlessKilled(work, signal) {
-    return new Promise((resolve, reject) => {
-        const killed = () => reject(signal.reason);
-        signal.addEventListener('abort', killed, { once: true });
-        if (signal.aborted)
-            killed();
-        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', killed));
-    });
-}
 function stop(bridge) {
     killMarked(`HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`);
 }
 class Turn {
     id = randomUUID();
     text = '';
+    segment = null;
+    admitted = false;
+    notes = [];
     sent = [];
     unsentFrom = null;
     draftSequence = 0;
@@ -57,6 +53,8 @@ class Conversation {
     opening = null;
     kills = 0;
     killed = new AbortController();
+    interrupts = 0;
+    interrupted = new AbortController();
     open = 0;
     queue = Promise.resolve();
     reports = Promise.resolve();
@@ -92,6 +90,10 @@ export class Conversations {
                     conversation.killed.abort(new Error(KILLED));
                     this.halt(conversation);
                 }
+                if (input.kind === 'interrupt') {
+                    conversation.interrupts++;
+                    conversation.interrupted.abort();
+                }
                 const work = conversation.queue.then(() => this.carry(conversation, input));
                 conversation.queue = work.catch(() => undefined);
                 this.acks.set(input.input_id, work);
@@ -135,8 +137,11 @@ export class Conversations {
             return this.open(conversation, input);
         if (input.kind === 'message')
             return this.message(conversation, input);
-        if (input.kind === 'interrupt')
+        if (input.kind === 'interrupt') {
+            if (--conversation.interrupts === 0)
+                conversation.interrupted = new AbortController();
             await this.interrupt(conversation, String(input.turn_id));
+        }
         if (input.kind === 'kill') {
             await this.kill(conversation);
             if (--conversation.kills === 0)
@@ -168,7 +173,9 @@ export class Conversations {
         const prompt = [];
         try {
             const route = await this.route(conversation, input.agent_id);
-            const paths = await placeFiles(this.kit.house, route.working_directory, input.files, conversation.killed.signal);
+            const files = input.files;
+            const paths = await placeFiles(this.kit.house, route.working_directory, files, conversation.killed.signal);
+            const lines = await this.transcribed(conversation, files, paths);
             if (conversation.running === null) {
                 const opened = await this.start(conversation, route, input.provider_session_id);
                 if (input.provider_session_id === null)
@@ -181,8 +188,8 @@ export class Conversations {
                 });
             }
             prompt.push({ type: 'text', text: String(input.text) });
-            if (paths.length > 0)
-                prompt.push({ type: 'text', text: paths.join('\n') });
+            if (lines.length > 0)
+                prompt.push({ type: 'text', text: lines.join('\n') });
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
@@ -194,6 +201,25 @@ export class Conversations {
         this.prompt(conversation, prompt);
         return ack;
     }
+    async transcribed(conversation, files, paths) {
+        const lines = [];
+        for (const [index, path] of paths.entries()) {
+            lines.push(path);
+            if (files[index].media_type?.startsWith('audio/') !== true)
+                continue;
+            try {
+                const text = await transcribe(path, AbortSignal.any([conversation.killed.signal, conversation.interrupted.signal]));
+                if (text !== '')
+                    lines.push(`Transcript: ${text}`);
+            }
+            catch (error) {
+                if (conversation.kills > 0)
+                    throw error;
+                logged(new Error(`${files[index].name} was not transcribed: ${causeOf(error)}`));
+            }
+        }
+        return lines;
+    }
     async interrupt(conversation, turnId) {
         if (conversation.running === null || conversation.turn?.id !== turnId)
             return;
@@ -232,13 +258,13 @@ export class Conversations {
     }
     async route(conversation, agentId) {
         const signal = conversation.killed.signal;
-        await unlessKilled(this.kit.agents.read(), signal);
+        await unlessAborted(this.kit.agents.read(), signal);
         if (this.kit.agents.route(agentId) === undefined)
-            await unlessKilled(this.kit.agents.refresh(), signal);
+            await unlessAborted(this.kit.agents.refresh(), signal);
         const route = this.kit.agents.route(agentId);
         if (route === undefined)
             throw new Error(`this Environment hosts no Agent ${agentId}`);
-        if (route.working_directory === join(LAUNCH_BASE, route.agent_id)) {
+        if (route.working_directory === join(agentBase(), route.agent_id)) {
             await mkdir(route.working_directory, { recursive: true });
         }
         return route;
@@ -250,7 +276,7 @@ export class Conversations {
             .onNotification(TURN_ENDED, (params) => params, () => this.ended(conversation))
             .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));
-        await unlessKilled(this.kit.agents.installed(), conversation.killed.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) {
             bridge.close();
@@ -258,8 +284,8 @@ export class Conversations {
         }
         conversation.opening = bridge;
         try {
-            await unlessKilled(createHowWeWork(bridge), conversation.killed.signal);
-            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
+            await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
@@ -272,6 +298,7 @@ export class Conversations {
                 sessionId: opened.sessionId,
                 killed: false,
                 queues: CLIS[route.kind].queues,
+                phase: CLIS[route.kind].phase,
             };
             const options = await this.launchSettings(running, route, opened.configOptions ?? []);
             conversation.running = running;
@@ -359,6 +386,9 @@ export class Conversations {
         return turn;
     }
     admitted(conversation, turn) {
+        turn.admitted = true;
+        for (const note of turn.notes.splice(0))
+            this.kit.send(note);
         if (turn.text !== '') {
             turn.unsentFrom = 0;
             this.draft(conversation, turn);
@@ -372,6 +402,17 @@ export class Conversations {
         this.kit.changed();
         return turn;
     }
+    finish(conversation, turn) {
+        if (turn.ended)
+            return;
+        const segment = turn.segment;
+        turn.segment = null;
+        if (segment?.phase === 'note')
+            this.note(conversation, turn, segment.text);
+        else if (segment !== null)
+            this.answer(conversation, turn, segment.text);
+        this.end(conversation, turn, { text: turn.text });
+    }
     end(conversation, turn, outcome) {
         if (turn.ended)
             return;
@@ -429,7 +470,7 @@ export class Conversations {
                 this.end(conversation, turn, { failed });
         }
         else if (turn.prompt === sent) {
-            this.end(conversation, turn, { text: turn.text });
+            this.finish(conversation, turn);
         }
     }
     started(conversation) {
@@ -446,7 +487,7 @@ export class Conversations {
         if (turn === null)
             return;
         if (turn.prompt === null) {
-            this.end(conversation, turn, { text: turn.text });
+            this.finish(conversation, turn);
         }
         else {
             conversation.turn = null;
@@ -500,17 +541,21 @@ export class Conversations {
     update(conversation, notification) {
         const update = notification.update;
         if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
-            const turn = this.started(conversation);
-            turn.text += update.content.text;
-            this.draft(conversation, turn);
+            this.chunk(conversation, this.started(conversation), update, update.content.text);
         }
         else if (update.sessionUpdate === 'plan') {
             const turn = this.started(conversation);
+            this.close(conversation, turn);
             turn.entries = update.entries;
             this.plan(conversation, turn);
         }
-        else if (update.sessionUpdate === 'agent_thought_chunk' || update.sessionUpdate === 'tool_call') {
-            this.started(conversation);
+        else if (update.sessionUpdate === 'tool_call') {
+            this.close(conversation, this.started(conversation));
+        }
+        else if (update.sessionUpdate === 'agent_thought_chunk') {
+            const turn = this.started(conversation);
+            if (turn.segment?.messageId !== (update.messageId ?? null))
+                this.close(conversation, turn);
         }
         else if (update.sessionUpdate === 'available_commands_update') {
             this.commands(conversation, update.availableCommands);
@@ -526,6 +571,38 @@ export class Conversations {
             conversation.jobs.delete(job.id);
         this.kit.changed();
     }
+    chunk(conversation, turn, chunk, text) {
+        const phase = conversation.running?.phase(chunk) ?? null;
+        const messageId = chunk.messageId ?? null;
+        if (turn.segment?.messageId !== messageId || turn.segment.phase !== phase)
+            this.close(conversation, turn);
+        if (phase === 'answer') {
+            this.answer(conversation, turn, text);
+            return;
+        }
+        turn.segment ??= { messageId, phase, text: '' };
+        turn.segment.text += text;
+    }
+    close(conversation, turn) {
+        const segment = turn.segment;
+        if (segment === null)
+            return;
+        turn.segment = null;
+        this.note(conversation, turn, segment.text);
+    }
+    note(conversation, turn, text) {
+        if (text.trim() === '')
+            return;
+        const note = { type: 'working-note', conversation_id: conversation.id, note_id: randomUUID(), text };
+        if (turn.admitted)
+            this.kit.send(note);
+        else
+            turn.notes.push(note);
+    }
+    answer(conversation, turn, text) {
+        turn.text += text;
+        this.draft(conversation, turn);
+    }
     draft(conversation, turn) {
         const blocks = blocksOf(turn.text);
         const from = Math.min(firstChange(turn.sent, blocks), turn.unsentFrom ?? Infinity);

package/dist/copies.js

@@ -3,12 +3,12 @@ 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 { HouseRefusal } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, revision, run, succeeded, tree, WORKING_COPIES, } from './git.js';
+import { blobId, blobText, git, 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';
 import { changed } from './translate.js';
 const BRANCH = 'main';
-const ROOM_HOMES = ['capture', 'library', 'collaboration'];
 const PROVENANCE = '_provenance';
 const REPLICA_RETRY_MS = 30_000;
 const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
@@ -18,13 +18,16 @@ function causeOf(error) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
-export function refusalCode(text) {
-    try {
-        return String(JSON.parse(text).error.code);
-    }
-    catch {
-        return text.split(':')[0].trim();
-    }
+const REBASED = new Set([
+    'field_base_stale',
+    'section_base_stale',
+    'preamble_base_stale',
+    'base_revision_stale',
+    'path_exists',
+    'path_absent',
+]);
+function rebaseFixes(refusal) {
+    return refusal.code === 'edit_conflict' && refusal.conflicts.some((code) => REBASED.has(code));
 }
 function short(commit) {
     return commit.slice(0, 12);
@@ -43,9 +46,6 @@ function rootOf(copy) {
 function relative(path) {
     return path.replace(/^\/private\//, '').replace(/^\/rooms\/[^/]+\//, '');
 }
-function prefixesOf(selected) {
-    return selected.private ? ['/private'] : ROOM_HOMES.map((home) => `${rootOf(selected)}/${home}`);
-}
 function declaredWritable(path, copy) {
     const deepest = (scopes) => Math.max(-1, ...scopes.filter((scope) => covers(path, scope)).map((scope) => scope.length));
     return deepest(copy.write) > deepest(copy.protected);
@@ -147,7 +147,7 @@ function movedPaths(moves, before, after) {
         .filter((pair) => pairs.filter((other) => other.from === pair.from || other.to === pair.to).length === 1)
         .map(({ from, to }) => [from, to]));
 }
-export class WorkingCopies {
+export class LocalCopies {
     owner;
     house;
     copies = new Map();
@@ -166,13 +166,15 @@ export class WorkingCopies {
                 catch (error) {
                     if (!(error instanceof HouseRefusal) || error.status >= 500)
                         throw error;
-                    return { refused: { code: refusalCode(error.text), text: error.message } };
+                    return {
+                        refused: refusalOf(error.text) ?? { code: '', text: `House refused it with ${error.status}`, conflicts: [] },
+                    };
                 }
             },
         };
     }
     async load() {
-        const home = join(kitHome(), 'working-copies');
+        const home = join(kitHome(), 'local-copies');
         const names = (await readdir(join(home, 'rooms')).catch(() => [])).filter((name) => name.endsWith('.json'));
         for (const path of [...names.map((name) => join(home, 'rooms', name)), join(home, 'private.json')]) {
             const text = await readFile(path, 'utf8').catch(() => null);
@@ -195,7 +197,7 @@ export class WorkingCopies {
         return selected;
     }
     async reselect() {
-        const { working_copy: chosen } = await this.house.post('/kit/working-copy/selection', {});
+        const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
         const selected = [
             ...(chosen?.rooms ?? [])
                 .filter((room) => room.room_handle !== null)
@@ -253,11 +255,11 @@ export class WorkingCopies {
     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 in a Git repository` };
+            return { refused: true, text: `${cwd} is not a House Local copy; run house push inside one` };
         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 working copy` };
+            return { refused: true, text: `${worktree} is not a House Local copy; run house push inside one` };
         return this.exclusive(key, () => this.pushed(key, worktree, selector, caller));
     }
     async keyAt(repository) {
@@ -285,7 +287,7 @@ export class WorkingCopies {
         }).catch(logged);
     }
     async save(copy) {
-        const path = join(kitHome(), 'working-copies', copy.private ? 'private.json' : `${copy.key}.json`);
+        const path = join(kitHome(), 'local-copies', copy.private ? 'private.json' : `${copy.key}.json`);
         await mkdir(dirname(path), { recursive: true, mode: 0o700 });
         const temporary = `${path}.${process.pid}`;
         await writeFile(temporary, JSON.stringify(copy), { mode: 0o600 });
@@ -294,7 +296,7 @@ export class WorkingCopies {
         return copy;
     }
     async read(selected) {
-        const prefixes = prefixesOf(selected);
+        const prefixes = [rootOf(selected)];
         const discovery = await this.house.post('/kit/door/discover', { prefixes });
         let bundle = await this.house.post('/kit/door/bootstrap', { prefixes });
         if ('transfer' in bundle)
@@ -341,7 +343,7 @@ export class WorkingCopies {
             return;
         }
         const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: prefixesOf(copy),
+            prefixes: [rootOf(copy)],
         });
         const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
         if (authority === undefined)
@@ -363,7 +365,7 @@ export class WorkingCopies {
             logged(`House serves nothing of ${rootOf({ private: scope.private, room_handle: scope.handle })} to copy`);
             return;
         }
-        const repository = scope.private ? join(WORKING_COPIES, 'private') : join(WORKING_COPIES, 'rooms', read.anchor);
+        const repository = scope.private ? join(localCopies(), 'private') : join(localCopies(), 'rooms', read.anchor);
         if (await exists(repository)) {
             logged(`${repository} already exists and House Kit leaves it as it is`);
             return;
@@ -432,12 +434,12 @@ export class WorkingCopies {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: prefixesOf(copy),
+                    prefixes: [rootOf(copy)],
                     positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
                 });
             }
             catch (error) {
-                const code = error instanceof HouseRefusal ? refusalCode(error.text) : null;
+                const code = error instanceof HouseRefusal ? (refusalOf(error.text)?.code ?? null) : null;
                 if (code === 'position_expired')
                     return this.received(copy);
                 if (code !== 'replica_behind')
@@ -512,8 +514,9 @@ export class WorkingCopies {
             }
             copy = await this.save(without(copy));
         }
-        if (!copy.active)
-            return { refused: true, text: `${rootOf(copy)} is no longer kept in this Environment` };
+        if (!copy.active) {
+            return { refused: true, text: `${rootOf(copy)} 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) {
@@ -582,9 +585,8 @@ export class WorkingCopies {
     async settle(start, caller, restaged = false) {
         let copy = start;
         const push = copy.push;
-        if (push.caller !== caller.key) {
-            return this.recovered(copy, `${short(push.commit)} was pushed by another caller and awaited its outcome`);
-        }
+        if (push.caller !== caller.key)
+            return this.recovered(copy);
         let outcome;
         try {
             outcome = await caller.submit(push.operation_id, push.changes, push.upload, async (upload) => {
@@ -592,9 +594,10 @@ export class WorkingCopies {
             });
         }
         catch (error) {
+            const refusal = error instanceof HouseRefusal ? refusalOf(error.text) : null;
             return {
                 refused: true,
-                text: `House's answer to ${short(push.commit)} did not arrive (${causeOf(error)}); run house git push again to recover its outcome.`,
+                text: refusal?.text ?? `House's answer to ${short(push.commit)} did not arrive; run house push again`,
             };
         }
         if ('refused' in outcome) {
@@ -603,22 +606,28 @@ export class WorkingCopies {
                 return this.settle(await this.save({ ...copy, push: unstaged }), caller, true);
             }
             if (outcome.refused.code === 'operation_expired')
-                return this.recovered(copy, outcome.refused.text);
+                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));
             }
-            catch (error) {
-                return { refused: true, text: `${outcome.refused.text}\n${HOUSE_REF} is unchanged: ${causeOf(error)}` };
+            catch {
+                return {
+                    refused: true,
+                    text: rebased ? `${outcome.refused.text}\nHouse's current state did not arrive; push again later` : outcome.refused.text,
+                };
             }
             return {
                 refused: true,
-                text: `${outcome.refused.text}\n${HOUSE_REF} holds House's current state; merge or rebase onto it, commit and push again.`,
+                text: rebased
+                    ? `${outcome.refused.text}\n${HOUSE_REF} holds House's current state; rebase onto it and push again`
+                    : outcome.refused.text,
             };
         }
         return this.finished(await this.save({ ...copy, push: { ...copy.push, state: 'accepted', written: outcome.accepted } }));
     }
-    async recovered(copy, reason) {
+    async recovered(copy) {
         const push = copy.push;
         const current = await this.save(await this.caughtUp(copy));
         const house = await tree(copy.repository, current.house);
@@ -627,7 +636,7 @@ export class WorkingCopies {
             await this.save(without(current));
             return {
                 refused: true,
-                text: `${reason}; House does not hold ${short(push.commit)}; run house git push again to submit it as a new operation.`,
+                text: `House does not hold ${short(push.commit)}; run house push again`,
             };
         }
         const written = [];
@@ -652,10 +661,10 @@ export class WorkingCopies {
                 await this.save(without(copy));
             return { refused: false, text: integrated.text };
         }
-        catch (error) {
+        catch {
             return {
                 refused: false,
-                text: `House accepted ${short(commit)}; local integration is pending (${causeOf(error)}); run house git push again to finish it.`,
+                text: `House accepted ${short(commit)}; run house push again to finish integrating it here`,
             };
         }
     }

package/dist/git-main.js

@@ -4,7 +4,7 @@ import { accessSync, constants, realpathSync, statSync } from 'node:fs';
 import { request } from 'node:http';
 import { constants as system } from 'node:os';
 import { delimiter, dirname, join } from 'node:path';
-import { WORKING_COPIES } from './git.js';
+import { localCopies } from './git.js';
 import { kitHome } from './home.js';
 const VALUED = new Set(['-C', '-c', '--git-dir', '--work-tree', '--namespace', '--config-env', '--attr-source', '--super-prefix']);
 const READS = new Set([
@@ -125,7 +125,7 @@ async function observed(git, args) {
         return delegated(git, args);
     const located = captured(git, [...globals, 'rev-parse', '--path-format=absolute', '--git-common-dir', '--show-toplevel']);
     const [common, worktree] = located?.split('\n') ?? [];
-    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${WORKING_COPIES}/`)) {
+    if (common === undefined || worktree === undefined || !dirname(common).startsWith(`${localCopies()}/`)) {
         return delegated(git, args);
     }
     const listing = [...globals, '-C', worktree, 'ls-files', '--stage', '-z'];

package/dist/git.js

@@ -1,7 +1,11 @@
 import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
+import { join } from 'node:path';
 import { withoutProxy } from './clis.js';
-export const WORKING_COPIES = '/agents/house/working-copies';
+import { workspaceRoot } from './home.js';
+export function localCopies() {
+    return join(workspaceRoot(), 'local-copies');
+}
 export const HOUSE_REF = 'refs/house/received';
 const COMMITTER = 'House Kit <house-kit@localhost>';
 export function run(cwd, args, input, env = {}) {
@@ -50,7 +54,7 @@ export async function blobText(repository, object, path) {
         return new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes);
     }
     catch {
-        throw new Error(`${path} is not UTF-8 text`);
+        throw new Error(`${path} is binary and House stores only text; remove it from the commit`);
     }
 }
 export function blobId(content) {

package/dist/home.js

@@ -1,11 +1,20 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 const ENROLMENT = 'credential.json';
+const DISCONNECTED = 'disconnected.json';
 const CONFIGURATION = 'kit.json';
+const OWN_AGENT = 'own-agent.json';
 export function kitHome() {
     return process.env.HOUSE_KIT_HOME ?? join(homedir(), '.house-kit');
 }
+export function workspaceRoot() {
+    return process.env.HOUSE_KIT_WORKSPACE ?? '/agents/house';
+}
+export function agentBase() {
+    return join(workspaceRoot(), 'agents');
+}
 export async function readHome(name) {
     try {
         return JSON.parse(await readFile(join(kitHome(), name), 'utf8'));
@@ -26,8 +35,28 @@ export async function writeHome(name, value) {
 export function readEnrolment() {
     return readHome(ENROLMENT);
 }
-export function writeEnrolment(enrolment) {
-    return writeHome(ENROLMENT, enrolment);
+export async function writeEnrolment(enrolment) {
+    await writeHome(ENROLMENT, enrolment);
+    await rm(join(kitHome(), DISCONNECTED), { force: true });
+}
+export function readDisconnected() {
+    return readHome(DISCONNECTED);
+}
+export async function forgetEnrolment({ house, environment }) {
+    await writeHome(DISCONNECTED, { house, environment });
+    await rm(join(kitHome(), ENROLMENT), { force: true });
+}
+export function enrolled() {
+    return existsSync(join(kitHome(), ENROLMENT));
+}
+export function readOwnAgent() {
+    return readHome(OWN_AGENT);
+}
+export function writeOwnAgent(ownAgent) {
+    return writeHome(OWN_AGENT, ownAgent);
+}
+export function forgetOwnAgent() {
+    return rm(join(kitHome(), OWN_AGENT), { force: true });
 }
 export async function readConfiguration() {
     return { skills: (await readHome(CONFIGURATION))?.skills !== false };