@agentshouse/kit 0.2.1-cb345f4157685 → 0.2.1-cb8dc89b78e07

package/README.md

@@ -46,8 +46,8 @@ 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 the text of each Room you chose for it as a
-Git repository in the workspace's `local-copies`, and erases a Room's copy, unpushed commits included, once the Room
-may no longer be copied here. `house fetch` does the same and records House's changes on each copy's
+Git repository in the workspace's `local-copies`, and keeps a Room's copy as it is, no longer refreshing it, once the
+Room may no longer be copied here. `house fetch` does the same and 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.
 

package/dist/agents.js

@@ -10,6 +10,7 @@ import { KIT_WIRE } from './wire.js';
 // Two quiet seconds let a fresh conversation start before background model discovery competes for its CPU.
 const MODEL_PROBE_QUIET_MS = 2_000;
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
+const INSTALLING = { release: null, failure: null, installing: true, ...SIGNED_OUT };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
     return option?.type === 'select' ? option : undefined;
@@ -117,6 +118,7 @@ function reported(kind, reading) {
         release: reading.release,
         ...(reading.minimum === undefined ? {} : { minimum: reading.minimum }),
         failure: reading.failure,
+        ...(reading.installing === undefined ? {} : { installing: reading.installing }),
         signed_in: reading.signed_in,
         models: reading.models,
         modes: reading.modes,
@@ -162,6 +164,7 @@ export class Agents {
     reading = Promise.resolve();
     queues = new Map();
     installing = Promise.resolve();
+    installs = new Map();
     readings = new Map();
     reads = new Map();
     starts = 0;
@@ -217,7 +220,7 @@ export class Agents {
             const { cli, release } = resolved;
             const known = this.readings.get(kind);
             const kept = known?.release === null || known?.minimum !== undefined ? SIGNED_OUT : (known ?? SIGNED_OUT);
-            if (known?.release !== release || known.minimum !== undefined) {
+            if (known?.release !== release || known.minimum !== undefined || this.installs.has(kind)) {
                 this.update(kind, { release, failure: null, signed_in: kept.signed_in, models: kept.models, modes: kept.modes });
             }
             const read = this.nextRead(kind);
@@ -232,7 +235,8 @@ export class Agents {
         });
     }
     located(kind, signal) {
-        return this.queue(kind, () => this.ensure(kind, signal), signal);
+        const owner = {};
+        return this.queue(kind, () => this.ensure(kind, signal, owner).finally(() => this.settle(kind, owner)), signal);
     }
     async reread(kind) {
         await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
@@ -240,7 +244,13 @@ export class Agents {
     }
     async recheck(kind, signal) {
         const known = this.readings.get(kind) ?? SIGNED_OUT;
-        await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal);
+        const owner = {};
+        try {
+            await this.examine(kind, known, async (kind, cli) => ((await signedIn(kind, cli, known, signal)) ? { ...known, signed_in: true } : SIGNED_OUT), signal, owner);
+        }
+        finally {
+            this.settle(kind, owner);
+        }
         if (!signal.aborted)
             await this.report();
     }
@@ -254,8 +264,18 @@ export class Agents {
         this.reads.set(kind, read);
         return read;
     }
-    update(kind, reading) {
+    hold(kind, reading) {
         this.readings.set(kind, reading);
+        this.installs.delete(kind);
+    }
+    update(kind, reading) {
+        this.hold(kind, reading);
+        this.report().catch(logged);
+    }
+    settle(kind, owner) {
+        if (this.installs.get(kind) !== owner)
+            return;
+        this.installs.delete(kind);
         this.report().catch(logged);
     }
     queue(kind, work, signal) {
@@ -266,13 +286,15 @@ export class Agents {
         this.queues.set(kind, queued.catch(() => undefined));
         return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
-    async ensure(kind, signal) {
+    async ensure(kind, signal, owner = {}) {
         const failed = await installAdapter(kind, signal);
         if (failed !== null)
             throw new Error(failed);
         const found = await locate(kind, signal);
         if (found !== null)
             return found;
+        this.installs.set(kind, owner);
+        this.report().catch(logged);
         const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
         this.installing = installing;
         const failure = await installing;
@@ -283,10 +305,10 @@ export class Agents {
             throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
         return installed;
     }
-    async resolve(kind, signal) {
+    async resolve(kind, signal, owner) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind, signal));
+            cli = await realpath(await this.ensure(kind, signal, owner));
         }
         catch (error) {
             const failure = causeOf(error);
@@ -301,12 +323,12 @@ export class Agents {
             return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
-    async examine(kind, known, read, signal) {
+    async examine(kind, known, read, signal, owner) {
         const current = this.nextRead(kind);
-        const resolved = await this.queue(kind, () => this.resolve(kind, signal), signal);
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal, owner), signal);
         const reading = 'cli' in resolved ? { release: resolved.release, failure: null, ...(await read(kind, resolved.cli, known)) } : resolved;
         if (this.reads.get(kind) === current && !signal?.aborted)
-            this.readings.set(kind, reading);
+            this.hold(kind, reading);
     }
     async quietOffer(kind, cli, known) {
         for (let seen = -1; seen !== this.starts;) {
@@ -324,7 +346,7 @@ export class Agents {
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {
-            const reading = this.readings.get(kind);
+            const reading = this.installs.has(kind) ? INSTALLING : this.readings.get(kind);
             return reading === undefined ? [] : [reported(kind, reading)];
         });
         const hostKey = await sshHostKey();

package/dist/api.js

@@ -1,9 +1,9 @@
 import { setTimeout as delay } from 'node:timers/promises';
-import { signInAgain, updateRequired } from './end.js';
+import { signInAgain } 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';
+import { endUnserved, KIT_WIRE, KIT_WIRE_HEADER } from './wire.js';
 export class HouseRefusal extends Error {
     status;
     text;
@@ -45,8 +45,8 @@ export async function post(house, path, body, credential, signal) {
         signal,
     });
     const text = await answer.text();
-    if (!answer.ok && tooOld(text))
-        updateRequired();
+    if (!answer.ok)
+        endUnserved(text);
     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-cb345f4157685",
+  "version": "0.2.1-cb8dc89b78e07",
   "hosts": {
     "macos": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb345f4157685/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb8dc89b78e07/connect-linux.sh"
       }
     },
     "linux": {
       "asset": {
         "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb345f4157685/connect-linux.sh"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb8dc89b78e07/connect-linux.sh"
       }
     },
     "windows": {
       "asset": {
         "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb345f4157685/connect-windows.ps1"
+        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-cb8dc89b78e07/connect-windows.ps1"
       }
     }
   }

package/dist/conversations.js

@@ -31,6 +31,7 @@ const ENDED = {
 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 NOT_SIGNED_IN = "the Agent's CLI is not signed in; sign it in on the Agent's machine";
 const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
 class NotStarted extends Error {
 }
@@ -42,6 +43,14 @@ async function step(reason, work) {
         throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
     }
 }
+function signedOut(error) {
+    return typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
+}
+function unopened(reason) {
+    return (error) => (signedOut(error) ? NOT_SIGNED_IN : reason);
+}
+// A start-up step is shown only once it has lasted a second, so a quick start shows none of them.
+const STARTING_SHOWN_AFTER_MS = 1_000;
 function unbridged(error) {
     return (finalRefusal(error) ? ENDED[refusalOf(error.text)?.code ?? ''] : undefined) ?? NO_CONNECTION;
 }
@@ -58,8 +67,7 @@ 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) };
+    return { failure: signedOut(error) ? 'signed_out' : 'error', cause: causeOf(error) };
 }
 function exitedWith(running, cause) {
     return running.killed ? { failure: 'killed', cause: KILLED } : { failure: 'exited', cause };
@@ -83,10 +91,10 @@ function marker(bridge) {
 class Turn {
     id = randomUUID();
     parts;
-    admitted = false;
     questions = 0;
     secrets = 0;
     prompted = false;
+    taken = null;
     ended = false;
     images = 0;
     uploads = [];
@@ -100,6 +108,8 @@ class Conversation {
     session = null;
     turn = null;
     commands = null;
+    options = null;
+    exitUntold = false;
     context = null;
     leftovers = new Set();
     waiting = [];
@@ -107,6 +117,7 @@ class Conversation {
     subagents = new Map();
     held = [];
     opening = null;
+    launch = null;
     prompted = null;
     kills = 0;
     killed = new AbortController();
@@ -115,6 +126,11 @@ class Conversation {
     open = 0;
     queue = Promise.resolve();
     reports = Promise.resolve();
+    starting = null;
+    preparing = null;
+    told = null;
+    untold = false;
+    shown = null;
     constructor(id) {
         this.id = id;
     }
@@ -187,6 +203,14 @@ export class Conversations {
     }
     opened() {
         this.watched = false;
+        for (const conversation of this.conversations.values()) {
+            if (conversation.running !== null)
+                this.facts(conversation);
+            else if (conversation.exitUntold)
+                this.process(conversation, false);
+            if (conversation.untold || conversation.told !== null)
+                this.retell(conversation);
+        }
     }
     watching(watched) {
         const resend = watched && !this.watched;
@@ -208,9 +232,10 @@ export class Conversations {
     }
     async carry(conversation, input) {
         if (input.kind === 'open')
-            return { ack: Promise.resolve(await this.open(conversation, input)) };
+            return { ack: this.open(conversation, input) };
         if (input.kind === 'message')
             return this.message(conversation, input);
+        await this.launched(conversation);
         if (input.kind === 'interrupt') {
             if (--conversation.interrupts === 0)
                 conversation.interrupted = new AbortController();
@@ -234,22 +259,58 @@ export class Conversations {
         }
         return { ack: Promise.resolve({}) };
     }
-    async open(conversation, input) {
+    open(conversation, input) {
         if (conversation.running !== null)
-            return {};
-        try {
-            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null, true) };
-        }
-        catch (error) {
-            return { refused: refusal(conversation, error) };
-        }
+            return Promise.resolve({});
+        const launch = conversation.launch ?? this.launch(conversation, this.route(conversation, input.agent_id), null, true);
+        return launch.session.then((session) => ({ provider_session_id: session }), (error) => ({ refused: refusal(conversation, error) }));
+    }
+    launch(conversation, route, sessionId, empty) {
+        let opened;
+        let failed;
+        const bridge = new Promise((resolve, reject) => {
+            opened = resolve;
+            failed = reject;
+        });
+        bridge.catch(() => undefined);
+        const session = this.start(conversation, route, sessionId, empty, opened);
+        session.catch(failed);
+        const launch = { bridge, session };
+        conversation.launch = launch;
+        void session
+            .catch(() => undefined)
+            .then(() => {
+            if (conversation.launch !== launch)
+                return;
+            conversation.launch = null;
+            this.next(conversation);
+        });
+        this.next(conversation);
+        return launch;
+    }
+    async launched(conversation) {
+        while (conversation.launch !== null)
+            await conversation.launch.session.catch(() => undefined);
+    }
+    instructed(conversation, route) {
+        const bridge = conversation.running === null ? conversation.launch?.bridge : Promise.resolve(conversation.running.bridge);
+        if (bridge === undefined)
+            return null;
+        const read = Promise.all([bridge, this.kit.copies.mapping()]).then(([opened, copies]) => instructions(opened, route.base_instructions, copies));
+        read.catch(() => undefined);
+        return read;
     }
     async message(conversation, input) {
         const content = [{ type: 'text', text: String(input.text) }];
         let route;
+        let instructing = null;
         try {
             route = await this.route(conversation, input.agent_id);
+            if (input.first === true)
+                instructing = this.instructed(conversation, route);
             const files = input.files;
+            if (files.length > 0)
+                this.prepares(conversation, 'files');
             const paths = await placeFiles(this.kit.house, route.working_directory, files, conversation.killed.signal);
             const lines = await this.transcribed(conversation, files, paths);
             if (lines.length > 0)
@@ -258,11 +319,13 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
+            this.prepares(conversation, null);
             return { ack: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
+        conversation.preparing = null;
         return {
             ack: new Promise((settle) => {
-                conversation.waiting.push({ input, route, content, settle });
+                conversation.waiting.push({ input, route, content, instructing, settle });
                 this.next(conversation);
             }),
         };
@@ -271,8 +334,12 @@ export class Conversations {
         if (conversation.sending !== null || conversation.open > 0)
             return;
         const waiting = conversation.waiting.shift();
-        if (waiting === undefined)
+        if (waiting === undefined) {
+            const step = conversation.preparing ?? (conversation.launch === null ? null : 'session');
+            if (conversation.starting !== step)
+                this.starts(conversation, step);
             return;
+        }
         conversation.sending = this.send(conversation, waiting).finally(() => {
             conversation.sending = null;
             this.next(conversation);
@@ -282,27 +349,33 @@ export class Conversations {
         const { input } = waiting;
         let ack = {};
         let started = false;
+        let instructing = waiting.instructing;
         const prompt = [];
         try {
+            if (conversation.running === null) {
+                this.starts(conversation, 'session');
+                await this.launched(conversation);
+            }
             if (conversation.running === null) {
                 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 launch = this.launch(conversation, Promise.resolve(waiting.route), stored, empty);
+                if (input.first === true)
+                    instructing = this.instructed(conversation, waiting.route);
+                started = (await launch.session) !== 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({
-                    type: 'text',
-                    text: await instructions(conversation.running.bridge, waiting.route.base_instructions, await this.kit.copies.mapping()),
-                });
+                prompt.push({ type: 'text', text: await (instructing ?? this.instructed(conversation, waiting.route)) });
             }
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
         catch (error) {
+            this.starts(conversation, null);
             if (started) {
                 conversation.session = null;
                 await this.kill(conversation);
@@ -310,15 +383,45 @@ export class Conversations {
             waiting.settle({ refused: refusal(conversation, error) });
             return;
         }
-        this.prompt(conversation, [...prompt, ...waiting.content]);
+        this.starts(conversation, null);
+        this.prompt(conversation, [...prompt, ...waiting.content], () => this.kit.inputs.hands(String(input.input_id), ack));
         waiting.settle(ack);
     }
+    starts(conversation, step) {
+        conversation.starting = step;
+        if (conversation.shown !== null)
+            clearTimeout(conversation.shown);
+        conversation.shown = null;
+        if (step === null || conversation.told !== null) {
+            this.tell(conversation, step);
+            return;
+        }
+        conversation.shown = setTimeout(() => {
+            conversation.shown = null;
+            if (conversation.starting === step)
+                this.tell(conversation, step);
+        }, STARTING_SHOWN_AFTER_MS);
+    }
+    prepares(conversation, step) {
+        conversation.preparing = step;
+        this.next(conversation);
+    }
+    tell(conversation, step) {
+        if (conversation.told === step && !conversation.untold)
+            return;
+        conversation.told = step;
+        this.retell(conversation);
+    }
+    retell(conversation) {
+        conversation.untold = !this.kit.send({ type: 'starting', conversation_id: conversation.id, step: conversation.told });
+    }
     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;
+            this.prepares(conversation, 'transcription');
             try {
                 const text = await transcribe(path, AbortSignal.any([conversation.killed.signal, conversation.interrupted.signal]));
                 if (text !== null && text !== '')
@@ -385,7 +488,8 @@ export class Conversations {
         }
         return route;
     }
-    async start(conversation, route, sessionId, empty) {
+    async start(conversation, routed, sessionId, empty, bridged) {
+        const route = await routed;
         const reader = readerFor(route.kind);
         reader.session = sessionId;
         const app = client({ name: '@agentshouse/kit' })
@@ -404,6 +508,7 @@ export class Conversations {
         let adapter = null;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            bridged(bridge);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
             const streamed = await step(NO_CONNECTION, work.open(cli));
             adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
@@ -415,21 +520,19 @@ export class Conversations {
             const cwd = route.working_directory;
             const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
             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 })));
+            const opened = resumed ?? (await step(unopened(NO_SESSION), agent.request('session/new', { cwd, mcpServers: [], _meta })));
             reader.session = opened.sessionId;
             if (opened.sessionId !== sessionId && CLIS[route.kind].renames) {
                 const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
-                await step(NO_SESSION, agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
+                await step(unopened(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 step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
             void work.settled().then(() => scope.record());
             conversation.running = running;
             conversation.session = running.sessionId;
-            this.kit.send({ type: 'process', conversation_id: conversation.id, running: true });
-            if (conversation.commands !== null)
-                this.commands(conversation, conversation.commands);
-            this.options(conversation, options);
+            conversation.options = options;
+            this.facts(conversation);
             void adapter.lost.then((cause) => this.exited(conversation, running, cause));
             return running.sessionId;
         }
@@ -450,7 +553,7 @@ export class Conversations {
         }
         catch (error) {
             if (!empty || conversation.kills > 0 || !CLIS[kind].unknownSession(error)) {
-                throw new NotStarted(NO_RESUME, { cause: error });
+                throw new NotStarted(unopened(NO_RESUME)(error), { cause: error });
             }
             logged(new Error(`conversation ${conversation.id} opens a new session: ${NO_RESUME}: ${causeOf(error)}`));
             return null;
@@ -490,11 +593,22 @@ export class Conversations {
         conversation.leftovers.add(running.scope);
         conversation.running = null;
         conversation.commands = null;
+        conversation.options = null;
         for (const [id, question] of this.questions) {
             if (question.conversation === conversation)
                 this.questions.delete(id);
         }
-        this.kit.send({ type: 'process', conversation_id: conversation.id, running: false });
+        this.process(conversation, false);
+    }
+    process(conversation, running) {
+        conversation.exitUntold = !this.kit.send({ type: 'process', conversation_id: conversation.id, running }) && !running;
+    }
+    facts(conversation) {
+        this.process(conversation, true);
+        if (conversation.commands !== null)
+            this.commands(conversation, conversation.commands);
+        if (conversation.options !== null)
+            this.options(conversation, conversation.options);
     }
     commands(conversation, commands) {
         conversation.commands = commands;
@@ -505,6 +619,7 @@ export class Conversations {
     options(conversation, options) {
         if (conversation.running === null)
             return;
+        conversation.options = options;
         this.kit.send({ type: 'options', conversation_id: conversation.id, options });
     }
     deliver(conversation, turn, event, body) {
@@ -519,7 +634,7 @@ export class Conversations {
         return delivered;
     }
     write(conversation, turn, operation) {
-        if (!turn.admitted || turn.ended || !this.watched)
+        if (turn.ended || !this.watched)
             return;
         this.kit.send({ type: 'turn', conversation_id: conversation.id, turn_id: turn.id, ...operation });
     }
@@ -530,12 +645,7 @@ export class Conversations {
     begin(conversation) {
         const turn = new Turn((operation) => this.write(conversation, turn, operation));
         conversation.open++;
-        void this.deliver(conversation, turn, 'started', {})
-            .then(() => {
-            turn.admitted = true;
-            this.replay(conversation, turn);
-        })
-            .catch(logged);
+        void this.deliver(conversation, turn, 'started', {}).catch(logged);
         conversation.turn = turn;
         if (conversation.context !== null)
             turn.parts.measure(conversation.context);
@@ -568,12 +678,14 @@ export class Conversations {
         this.next(conversation);
         this.kit.changed();
     }
-    prompt(conversation, prompt) {
+    prompt(conversation, prompt, taken) {
         const running = conversation.running;
         const turn = this.begin(conversation);
         turn.prompted = true;
+        turn.taken = taken;
         conversation.prompted = running.sessionId;
         running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
+            this.took(turn);
             const notice = answeredFailure(answer);
             if (notice !== null) {
                 this.end(conversation, turn, { failure: notice.limit ? 'limit' : 'error', cause: notice.title }, notice.title);
@@ -586,6 +698,7 @@ export class Conversations {
                 this.end(conversation, turn, exitedWith(running, await running.adapter.exited));
             }
             else {
+                this.took(turn);
                 if (conversation.open === 1 && conversation.running === running) {
                     running.adapter.retire();
                     this.detach(conversation, running);
@@ -595,7 +708,9 @@ export class Conversations {
         });
     }
     started(conversation) {
-        return conversation.turn ?? this.begin(conversation);
+        const turn = conversation.turn ?? this.begin(conversation);
+        this.took(turn);
+        return turn;
     }
     ended(conversation) {
         const turn = conversation.turn;
@@ -690,6 +805,11 @@ export class Conversations {
         }
         this.apply(conversation, this.started(conversation), event);
     }
+    took(turn) {
+        const taken = turn.taken;
+        turn.taken = null;
+        taken?.();
+    }
     apply(conversation, turn, event) {
         switch (event.kind) {
             case 'text':

package/dist/copies.js

@@ -58,6 +58,9 @@ function expiredAuthority(error) {
         return undefined;
     }
 }
+function grouped(items, size) {
+    return items.flatMap((_, index) => (index % size === 0 ? [items.slice(index, index + size)] : []));
+}
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
 }
@@ -215,7 +218,7 @@ export class LocalCopies {
     async mapping() {
         await this.answering;
         return [...this.copies.values()]
-            .filter((copy) => copy.erasing === undefined)
+            .filter((copy) => copy.unfollowed === undefined)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
@@ -247,30 +250,24 @@ export class LocalCopies {
         return this.holding([...new Set([...held().map((copy) => copy.key), ...synced.keys()])].sort(), async () => {
             const said = [];
             let refused = false;
+            const mark = refreshing ? 'said' : 'unsaid';
             for (const copy of held()) {
-                const returned = synced.has(copy.key);
-                if (returned && copy.erasing === undefined)
+                if (synced.has(copy.key) || copy.unfollowed === 'said' || copy.unfollowed === mark)
                     continue;
-                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)}`);
-                }
+                await this.save({ ...copy, unfollowed: mark });
+                if (refreshing)
+                    said.push(`${rootOf(copy.room_handle)}: no longer followed; kept as it is`);
             }
             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;
                     }
-                    current.push(held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle }));
+                    const { unfollowed, ...followed } = held;
+                    current.push(unfollowed === undefined && held.room_handle === handle ? held : await this.save({ ...followed, room_handle: handle }));
                 }
                 catch (error) {
                     refused = true;
@@ -278,13 +275,12 @@ export class LocalCopies {
                 }
             }
             if (refreshing && current.length > 0) {
-                try {
-                    const refreshed = await this.refreshed(current);
-                    current.forEach((copy, index) => said.push(...moved(copy, refreshed[index])));
-                }
-                catch (error) {
+                const failed = await this.refreshed(current).then(() => null, houseCause);
+                for (const copy of current)
+                    said.push(...moved(copy, this.copies.get(copy.key)));
+                if (failed !== null) {
                     refused = true;
-                    said.push(houseCause(error));
+                    said.push(failed);
                 }
             }
             return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
@@ -296,8 +292,6 @@ 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);
@@ -353,12 +347,6 @@ 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 });
@@ -459,19 +447,24 @@ export class LocalCopies {
         return next;
     }
     async refreshed(copies) {
-        const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: copies.map((copy) => rootOf(copy.room_handle)),
-        });
-        const regranted = new Map();
+        const discover = (group) => this.house.post('/kit/door/discover', { prefixes: group.map((copy) => rootOf(copy.room_handle)) });
+        const [first, ...rest] = copies;
+        const { bounds, authorities } = await discover([first]);
+        for (const group of grouped(rest, bounds.max_prefixes))
+            authorities.push(...(await discover(group)).authorities);
+        const unchanged = [];
         for (const copy of copies) {
-            const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
+            const authority = 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)));
+                await this.save(await this.received(copy));
+            }
+            else {
+                unchanged.push(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));
+        for (const group of grouped(unchanged, bounds.max_prefixes))
+            await this.caughtUp(group, false);
     }
     async caughtUp(copies, whole) {
         const caught = new Map(copies.map((copy) => [copy.key, copy]));
@@ -553,8 +546,6 @@ 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}`]);
@@ -669,8 +660,10 @@ export class LocalCopies {
             }
             if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
-            const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));
+            if (settled.unfollowed !== undefined)
+                return { refused: true, text: outcome.refused.text };
+            const rebased = rebaseFixes(outcome.refused);
             try {
                 settled = (await this.caughtUp([settled], true))[0];
             }

package/dist/end.js

@@ -1,3 +1,4 @@
+import { KIT_VERSION } from './clis.js';
 import { forgetRejected } from './home.js';
 import { installCommand } from './placement.js';
 import { killDescendants } from './scope.js';
@@ -8,7 +9,7 @@ function exit(reason, status) {
     process.exit(status);
 }
 export function end(reason) {
-    exit(reason, 0);
+    exit(reason, process.env.HOUSE_KIT_RESIDENT === String(process.pid) ? 0 : 1);
 }
 export function restart(reason) {
     exit(reason, 1);
@@ -17,6 +18,9 @@ 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 function newerThanHouse(release, command) {
+    end(`Kit ${KIT_VERSION} is newer than this Building supports (Kit ${release}). Install Kit ${release}: ${command}`);
+}
 export async function signInAgain(rejected) {
     await forgetRejected(rejected);
     restart('sign in again');

package/dist/events.js

@@ -2,7 +2,7 @@ const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
 export const RUNNING_JOB = new Set(['running', 'paused']);
-const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
+const MESSAGE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request', send_mail: 'request' };
 function words(line) {
     const found = [];
     let word = null;
@@ -48,7 +48,7 @@ export function houseMessage(line) {
     catch {
         return null;
     }
-    const argument = ROUTINE_TARGETS[call.command];
+    const argument = MESSAGE_TARGETS[call.command];
     if (argument === undefined)
         return null;
     const target = call.arguments?.[argument];

package/dist/inputs.js

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { kitHome } from './home.js';
 function logged(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
@@ -5,17 +8,28 @@ export class Inputs {
     house;
     changed;
     carried = new Map();
+    path = join(kitHome(), 'handed-inputs.json');
+    handed;
+    answered = new Set();
     open = 0;
     constructor(house, changed) {
         this.house = house;
         this.changed = changed;
+        this.handed = new Map(existsSync(this.path) ? Object.entries(JSON.parse(readFileSync(this.path, 'utf8'))) : []);
+    }
+    hands(inputId, ack) {
+        if (this.answered.has(inputId))
+            return;
+        this.handed.set(inputId, ack);
+        this.save();
     }
     idle() {
         return this.open === 0;
     }
     carry(inputId, work) {
         const known = this.carried.get(inputId);
-        const carried = known ?? work();
+        const handed = this.handed.get(inputId);
+        const carried = known ?? (handed === undefined ? work() : Promise.resolve({ ack: handed }));
         if (known === undefined) {
             this.carried.set(inputId, carried);
             carried.catch(() => this.carried.delete(inputId));
@@ -24,7 +38,14 @@ export class Inputs {
         this.changed();
         return carried
             .then(async ({ ack, acknowledged }) => {
-            await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+            try {
+                await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+            }
+            finally {
+                this.answered.add(inputId);
+                if (this.handed.delete(inputId))
+                    this.save();
+            }
             if (known === undefined)
                 await acknowledged?.();
         })
@@ -34,4 +55,9 @@ export class Inputs {
             this.changed();
         });
     }
+    save() {
+        const temporary = `${this.path}.${process.pid}`;
+        writeFileSync(temporary, JSON.stringify(Object.fromEntries(this.handed)), { mode: 0o600 });
+        renameSync(temporary, this.path);
+    }
 }

package/dist/instructions.js

@@ -4,9 +4,9 @@ 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 WAIT_LINE = 'To get what another Agent will write into a Room, `create_trigger` on where it will land with a `conversation` action, then end your turn: this conversation continues when it lands.';
+const REQUEST_LINE = "For another Agent's help, `send_routine_request`; its mail comes back into this conversation. If an Agent of your User has no Routine to call, write one in the Private Room and `create_routine_access` with your User as its only caller.";
 const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
 export async function instructions(bridge, base, copies) {
-    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, WAIT_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
+    const lines = [SOURCE_LINE, HOUSE_LINE, FILE_LINE, READ_LINE, REQUEST_LINE, ...(copies.length === 0 ? [] : [COPIES_LINE, ...copies])];
     return [lines.join('\n'), base, (await readHowWeWork(bridge)).replace(/\n$/, '')].filter((part) => part !== '').join('\n\n');
 }

package/dist/placement.js

@@ -18,9 +18,9 @@ export async function updatesItself() {
     // sudo answers at once, so ten seconds only bounds a stuck sudo.
     return (await run('sudo', ['-n', 'true'], 10_000)).status === 0;
 }
-export function installCommand() {
+function recorded(name) {
     try {
-        return readFileSync(join(kitHome(), 'install-command'), 'utf8').trim();
+        return readFileSync(join(kitHome(), name), 'utf8').trim();
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -28,3 +28,12 @@ export function installCommand() {
         throw error;
     }
 }
+export function installCommand() {
+    return recorded('install-command');
+}
+export function machine() {
+    const placed = recorded('placement');
+    if (placed === 'container' || placed === 'server' || placed === 'windows')
+        return placed;
+    return process.platform === 'darwin' ? 'macos' : 'linux';
+}

package/dist/scope.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 const LISTING_BYTES = 1 << 28;
 const CGROUPS = '/sys/fs/cgroup';
 const GONE = new Set(['ENOENT', 'ESRCH']);
+const EXITED = new Set(['Z', 'X']);
 function failure(error) {
     return error.code ?? '';
 }
@@ -24,6 +25,8 @@ function read(pid) {
     try {
         const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
         const fields = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
+        if (EXITED.has(fields[0]))
+            return null;
         const command = readFileSync(`/proc/${pid}/cmdline`, 'utf8').replaceAll('\0', ' ');
         return { parent: Number(fields[1]), session: fields[3], command };
     }

package/dist/stream.js

@@ -1,9 +1,9 @@
 import { subscribe } from 'node:diagnostics_channel';
 import { HouseRefusal, retryDelay } from './api.js';
-import { end, REPLACED, signInAgain, updateRequired } from './end.js';
+import { end, REPLACED, signInAgain } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
-import { KIT_WIRE, tooOld } from './wire.js';
+import { endUnserved, KIT_WIRE } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
@@ -80,8 +80,8 @@ export function holdStream(handlers) {
                 void signInAgain(credential);
                 return;
             }
-            if (refused !== null && tooOld(refused.text))
-                updateRequired();
+            if (refused !== null)
+                endUnserved(refused.text);
             if (!opened && refused !== null)
                 process.stderr.write(`kit: ${refused.message}\n`);
             // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused or left unanswered backs off on the jittered curve, retryable or not, since a resident outlives a House deploy.

package/dist/translate.js

@@ -3,14 +3,8 @@ function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
 function applied(document, changes) {
-    let current = document;
-    for (const change of changes) {
-        const result = apply(current, change);
-        if (result.outcome !== 'applied')
-            return null;
-        current = result.document;
-    }
-    return serialize(current);
+    const result = apply(document, changes);
+    return result.outcome === 'applied' ? serialize(result.document) : null;
 }
 function components(path, before, after, text) {
     const edits = [];

package/dist/wire.js

@@ -1,6 +1,22 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
 import { refusalOf } from './refusals.js';
 export const KIT_WIRE = 2;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
-export function tooOld(text) {
-    return refusalOf(text)?.code === 'kit_update_required';
+function newer(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    return body?.error?.code === 'kit_newer_than_house' ? body.error : null;
+}
+export function endUnserved(text) {
+    if (refusalOf(text)?.code === 'kit_update_required')
+        updateRequired();
+    const refused = newer(text);
+    if (refused !== null)
+        newerThanHouse(refused.release, refused.commands[machine()]);
 }

package/package.json

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