@agentshouse/kit 0.2.1-caf8b8e5a324f → 0.2.1-cb345f4157685

package/dist/acp.js

@@ -3,6 +3,7 @@ import { spawn } from 'node:child_process';
 import { Readable, Writable } from 'node:stream';
 import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
 import { killTree } from './scope.js';
+const RETIRED = 'the CLI was retired';
 export async function startAdapter(kind, cli, cwd, app, events = () => undefined, added = {}, signal, scope = null) {
     const adapter = CLIS[kind].adapter;
     const started = [adapter === null ? cli : adapterCommand(kind), CLIS[kind].args];
@@ -13,34 +14,53 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
         stdio: ['pipe', 'pipe', 'pipe'],
         detached: true,
     });
-    const stop = () => killTree(child);
-    signal?.addEventListener('abort', stop, { once: true });
-    child.on('exit', () => signal?.removeEventListener('abort', stop));
+    let owned = true;
+    let retired = false;
     let stderr = '';
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);
     });
-    const exited = new Promise((resolve) => {
-        child.on('error', (error) => resolve(`the CLI did not start: ${error.message}`));
-        child.on('exit', (code, signal) => {
-            const last = stderr.trim().split('\n').at(-1);
-            resolve(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
-        });
-    });
     const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
     const connection = app.connect({
         writable: stream.writable,
         readable: stream.readable.pipeThrough(new TransformStream({
             transform(message, controller) {
                 const read = message;
-                events(read);
+                if (owned)
+                    events(read);
                 if (read.id !== undefined || (read.method !== 'session/update' && !read.method.startsWith('_'))) {
                     controller.enqueue(message);
                 }
             },
         })),
     });
-    void exited.then((cause) => connection.close(new Error(cause)));
+    const { promise: lost, resolve: lose } = Promise.withResolvers();
+    const exited = new Promise((resolve) => {
+        const end = (cause) => {
+            if (owned)
+                lose(cause);
+            owned = false;
+            connection.close(new Error(cause));
+            resolve(cause);
+        };
+        child.on('error', (error) => end(`the CLI did not start: ${error.message}`));
+        child.on('exit', (code, signal) => {
+            const last = stderr.trim().split('\n').at(-1);
+            end(`the CLI exited with ${code ?? signal}${last ? `: ${last}` : ''}`);
+        });
+    });
+    const retire = () => {
+        owned = false;
+        if (retired)
+            return;
+        retired = true;
+        if (child.pid !== undefined)
+            killTree(child);
+        scope?.kill();
+        connection.close(new Error(RETIRED));
+    };
+    signal?.addEventListener('abort', retire, { once: true });
+    child.on('exit', () => signal?.removeEventListener('abort', retire));
     try {
         const initialized = await connection.agent.request('initialize', {
             protocolVersion: PROTOCOL_VERSION,
@@ -54,10 +74,10 @@ export async function startAdapter(kind, cli, cwd, app, events = () => undefined
             clientInfo: { name: '@agentshouse/kit', version: KIT_VERSION },
         });
         scope?.entered(child.pid);
-        return { child, connection, initialized, exited };
+        return { connection, initialized, exited, lost, retire };
     }
     catch (error) {
-        child.kill('SIGKILL');
+        retire();
         throw error;
     }
 }

package/dist/agents.js

@@ -5,7 +5,6 @@ import { startAdapter } from './acp.js';
 import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
 import { updatesItself } from './placement.js';
-import { killTree } from './scope.js';
 import { holdTranscription, transcriptionReport } from './transcription.js';
 import { KIT_WIRE } from './wire.js';
 // Two quiet seconds let a fresh conversation start before background model discovery competes for its CPU.
@@ -109,8 +108,7 @@ async function offer(kind, cli, known, signal) {
         };
     }
     finally {
-        if (adapter !== undefined)
-            killTree(adapter.child);
+        adapter?.retire();
     }
 }
 function reported(kind, reading) {

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -81,7 +81,7 @@ function editAnswer(forwarded) {
 export async function openBridge(house, copies, conversationId, signal) {
     const path = [join(kitHome(), 'shim'), dirname(process.execPath), await loginPath()].join(delimiter);
     const origin = (await readEnrolment()).house;
-    const { credential } = await house.post(`/kit/conversations/${conversationId}/credential`, {}, signal);
+    const { credential } = await retrying(() => house.post(`/kit/conversations/${conversationId}/credential`, {}, signal), signal);
     const closed = new AbortController();
     const sent = (message, operation) => callHouse(origin, credential, message, operation, closed.signal);
     const send = async (message, operation) => {

package/dist/conversations.js

@@ -1,9 +1,10 @@
-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';
 import { unlessAborted } from './abort.js';
 import { startAdapter } from './acp.js';
+import { finalRefusal } from './api.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { answeredFailure, readerFor } from './events.js';
@@ -11,14 +12,22 @@ import { placeFiles, uploadBytes } from './files.js';
 import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { Parts } from './parts.js';
+import { refusalOf } from './refusals.js';
 import { killMarked, Scope } from './scope.js';
 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_CONNECTION = "the Agent's computer could not open this conversation; try again";
+const GONE = 'House no longer holds this conversation; start a new one';
+const RETIRED = "this conversation's Agent is retired, so it cannot start";
+const ENDED = {
+    conversation_not_found: GONE,
+    conversation_historical: RETIRED,
+};
 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";
@@ -30,9 +39,12 @@ async function step(reason, work) {
         return await work;
     }
     catch (error) {
-        throw new NotStarted(reason, { cause: error });
+        throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
     }
 }
+function unbridged(error) {
+    return (finalRefusal(error) ? ENDED[refusalOf(error.text)?.code ?? ''] : undefined) ?? NO_CONNECTION;
+}
 const EXIT_PLAN_MODE = {
     parse(value) {
         if (typeof value !== 'object' || value === null || Array.isArray(value)) {
@@ -45,6 +57,13 @@ export const CONVERSATION_INPUTS = new Set(['open', 'message', 'interrupt', 'kil
 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)}`;
 }
@@ -111,9 +130,7 @@ function asksSecret(request) {
 export class Conversations {
     kit;
     conversations = new Map();
-    acks = new Map();
     questions = new Map();
-    carrying = 0;
     reporting = 0;
     watched = false;
     constructor(kit) {
@@ -122,37 +139,26 @@ export class Conversations {
         setInterval(() => this.look(), 2_000);
     }
     input(input) {
-        this.carrying++;
-        const carried = this.acks.get(input.input_id) ??
-            (() => {
-                const conversation = this.conversation(input.conversation_id);
-                if (input.kind === 'kill') {
-                    conversation.kills++;
-                    conversation.killed.abort(new Error(KILLED));
-                    for (const waiting of conversation.waiting.splice(0))
-                        waiting.settle({ refused: KILLED });
-                    this.halt(conversation);
-                }
-                if (input.kind === 'interrupt') {
-                    conversation.interrupts++;
-                    conversation.interrupted.abort();
-                }
-                const handled = conversation.queue.then(() => this.carry(conversation, input));
-                conversation.queue = handled.catch(() => undefined);
-                const work = handled.then(({ ack }) => ack);
-                this.acks.set(input.input_id, work);
-                return work;
-            })();
-        carried
-            .then((body) => this.kit.house.deliver(`/kit/inputs/${input.input_id}/ack`, body))
-            .catch(logged)
-            .finally(() => {
-            this.carrying--;
-            this.kit.changed();
+        void this.kit.inputs.carry(input.input_id, () => {
+            const conversation = this.conversation(input.conversation_id);
+            if (input.kind === 'kill') {
+                conversation.kills++;
+                conversation.killed.abort(new Error(KILLED));
+                for (const waiting of conversation.waiting.splice(0))
+                    waiting.settle({ refused: KILLED });
+                this.halt(conversation);
+            }
+            if (input.kind === 'interrupt') {
+                conversation.interrupts++;
+                conversation.interrupted.abort();
+            }
+            const handled = conversation.queue.then(() => this.carry(conversation, input));
+            conversation.queue = handled.catch(() => undefined);
+            return handled.then(async ({ ack }) => ({ ack: await ack }));
         });
     }
     idle() {
-        if (this.carrying > 0 || this.reporting > 0)
+        if (this.reporting > 0)
             return false;
         for (const conversation of this.conversations.values()) {
             const turn = conversation.turn;
@@ -387,7 +393,7 @@ export class Conversations {
             .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 step(NO_CONNECTION, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
+        const bridge = await step(unbridged, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
@@ -395,11 +401,12 @@ export class Conversations {
         conversation.opening = bridge;
         const work = workFor(route.kind, route.working_directory, () => this.kit.changed());
         const scope = new Scope(marker(bridge), randomUUID(), cli);
+        let adapter = null;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
             const streamed = await step(NO_CONNECTION, work.open(cli));
-            const adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+            adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
                 work.read(message);
                 this.read(conversation, reader, message);
             }, { ...bridge.env, ...streamed }, undefined, scope));
@@ -423,11 +430,11 @@ export class Conversations {
             if (conversation.commands !== null)
                 this.commands(conversation, conversation.commands);
             this.options(conversation, options);
-            void adapter.exited.then((cause) => this.exited(conversation, adapter, cause));
+            void adapter.lost.then((cause) => this.exited(conversation, running, cause));
             return running.sessionId;
         }
         catch (error) {
-            scope.kill();
+            adapter?.retire();
             work.close();
             conversation.leftovers.add(scope);
             bridge.close();
@@ -470,13 +477,10 @@ export class Conversations {
         }
         return options;
     }
-    exited(conversation, adapter, cause) {
-        const running = conversation.running;
-        if (running?.adapter !== adapter)
-            return;
+    exited(conversation, running, cause) {
         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();
@@ -543,6 +547,8 @@ export class Conversations {
     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);
@@ -556,7 +562,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);
@@ -569,18 +575,22 @@ export class Conversations {
         conversation.prompted = running.sessionId;
         running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
             const notice = answeredFailure(answer);
-            const failed = notice ?? (answer.stopReason === 'refusal' ? REFUSED : null);
-            this.end(conversation, turn, failed === null ? null : { failed }, notice);
+            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();
+                    running.adapter.retire();
                     this.detach(conversation, running);
                 }
-                this.end(conversation, turn, { failed: causeOf(error) });
+                this.end(conversation, turn, answeredWith(error));
             }
         });
     }

package/dist/copies.js

@@ -219,26 +219,35 @@ export class LocalCopies {
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    async connected() {
-        const copied = await this.answered(() => this.fetched(false));
-        if (copied.refused)
-            logged(copied.text);
+    connected() {
+        return this.selected();
+    }
+    async changed(rooms) {
+        if (rooms.length > 0)
+            await this.selected(rooms);
     }
     fetch() {
         return this.answered(() => this.fetched(true));
     }
+    async selected(rooms) {
+        const copied = await this.answered(() => this.fetched(false, rooms));
+        if (copied.refused)
+            logged(copied.text);
+    }
     answered(work) {
         const answered = this.answering.then(work);
         this.answering = answered.catch(() => undefined);
         return answered;
     }
-    async fetched(refreshing) {
-        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', {});
+    async fetched(refreshing, rooms) {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', rooms === undefined ? {} : { rooms });
         const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
-        return this.holding([...new Set([...this.copies.keys(), ...synced.keys()])].sort(), async () => {
+        const named = rooms === undefined ? null : new Set(rooms.map((room) => `rooms/${room}`));
+        const held = () => [...this.copies.values()].filter((copy) => named === null || named.has(copy.key));
+        return this.holding([...new Set([...held().map((copy) => copy.key), ...synced.keys()])].sort(), async () => {
             const said = [];
             let refused = false;
-            for (const copy of [...this.copies.values()]) {
+            for (const copy of held()) {
                 const returned = synced.has(copy.key);
                 if (returned && copy.erasing === undefined)
                     continue;

package/dist/events.js

@@ -513,7 +513,8 @@ class GrokReader extends Reader {
     }
 }
 export function answeredFailure(answer) {
-    return answer._meta?.jetbrains?.air?.sessionFailure?.title ?? null;
+    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')

package/dist/files.js

@@ -11,7 +11,7 @@ export function verified(bytes, sha256, name) {
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
-        const original = await house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal);
+        const original = await retrying(() => house.post('/kit/conversation/originals/get', { version: file.version, download: true }, signal), signal);
         const answer = await fetch(relayed(original.download.url), { signal });
         if (!answer.ok)
             throw new Error(`${file.name} did not download: ${answer.status}`);

package/dist/inputs.js

@@ -0,0 +1,37 @@
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+export class Inputs {
+    house;
+    changed;
+    carried = new Map();
+    open = 0;
+    constructor(house, changed) {
+        this.house = house;
+        this.changed = changed;
+    }
+    idle() {
+        return this.open === 0;
+    }
+    carry(inputId, work) {
+        const known = this.carried.get(inputId);
+        const carried = known ?? work();
+        if (known === undefined) {
+            this.carried.set(inputId, carried);
+            carried.catch(() => this.carried.delete(inputId));
+        }
+        this.open++;
+        this.changed();
+        return carried
+            .then(async ({ ack, acknowledged }) => {
+            await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+            if (known === undefined)
+                await acknowledged?.();
+        })
+            .catch(logged)
+            .finally(() => {
+            this.open--;
+            this.changed();
+        });
+    }
+}

package/dist/resident.js

@@ -12,6 +12,7 @@ import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart } from './end.js';
 import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
+import { Inputs } from './inputs.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
@@ -133,7 +134,7 @@ export async function resident() {
     const agents = new Agents(house, () => changed());
     let stream = null;
     let reported = false;
-    const idle = () => conversations.idle() && signIns.idle() && agents.idle();
+    const idle = () => inputs.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
@@ -146,15 +147,17 @@ export async function resident() {
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
+    const inputs = new Inputs(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
+        inputs,
         send: (frame) => stream?.send(frame) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, changed);
-    const updates = new Updates(house);
+    const signIns = new SignIns(house, agents, inputs);
+    const updates = new Updates(inputs);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -173,10 +176,11 @@ export async function resident() {
         frame: (arrived) => {
             if (arrived.type === 'watching')
                 conversations.watching(arrived.watching === true);
+            if (arrived.type === 'authority_changed')
+                logged(copies.changed(arrived.rooms));
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
             if (arrived.type === 'input') {
-                reported = false;
                 if (arrived.kind === 'sign_in')
                     signIns.start(arrived);
                 else if (arrived.kind === 'update')
@@ -185,7 +189,7 @@ export async function resident() {
                     conversations.input(arrived);
                 else {
                     const refused = { refused: `This Kit does not know ${arrived.kind}; update the Kit` };
-                    logged(house.deliver(`/kit/inputs/${arrived.input_id}/ack`, refused).finally(changed));
+                    void inputs.carry(String(arrived.input_id), async () => ({ ack: refused }));
                 }
             }
         },

package/dist/service.js

@@ -1,4 +1,7 @@
 import { spawnSync } from 'node:child_process';
+import { existsSync, realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { kitHome } from './home.js';
 const UNIT = 'house-kit.service';
 // launchctl and systemctl answer at once, so ten seconds only bounds a stuck service manager.
 const MANAGER_MS = 10_000;
@@ -12,18 +15,37 @@ function start(command, args) {
     const cause = started.error?.message ?? (started.stderr.trim() || `${command} exited with ${started.status ?? 'a signal'}`);
     throw new Error(`the House Kit service could not be started: ${cause}`);
 }
+function physical(path) {
+    return existsSync(path) ? realpathSync(path) : resolve(path);
+}
+function systemdHome(environment) {
+    for (const [, quoted, bare] of environment.matchAll(/"((?:[^"\\]|\\.)*)"|(\S+)/g)) {
+        const assignment = bare ?? quoted.replace(/\\(.)/g, '$1');
+        if (assignment.startsWith('HOUSE_KIT_HOME='))
+            return assignment.slice('HOUSE_KIT_HOME='.length);
+    }
+    return undefined;
+}
+function runsThisHome(served) {
+    return served !== undefined && physical(served) === physical(kitHome());
+}
 export function startService() {
     if (process.platform === 'darwin') {
         const service = `gui/${process.getuid()}/house-kit`;
         const printed = manage('launchctl', ['print', service]);
         if (printed.status !== 0 || /^\tstate = running$/m.test(printed.stdout))
             return false;
+        if (!runsThisHome(/^\t+HOUSE_KIT_HOME => (.+)$/m.exec(printed.stdout)?.[1]))
+            return false;
         start('launchctl', ['kickstart', service]);
         return true;
     }
     for (const scope of [['--user'], []]) {
         if (manage('systemctl', [...scope, 'is-enabled', '--quiet', UNIT]).status !== 0)
             continue;
+        const environment = manage('systemctl', [...scope, 'show', '--property=Environment', '--value', UNIT]).stdout;
+        if (!runsThisHome(systemdHome(environment)))
+            continue;
         if (manage('systemctl', [...scope, 'is-active', '--quiet', UNIT]).status === 0)
             return false;
         start('systemctl', [...scope, 'start', UNIT]);

package/dist/sign-in.js

@@ -9,36 +9,20 @@ const CODE = /^[A-Z0-9]+-[A-Z0-9]+$/;
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function logged(error) {
-    process.stderr.write(`kit: ${causeOf(error)}\n`);
-}
 function endOf(signal) {
     return new Promise((resolve) => signal.addEventListener('abort', () => resolve(true), { once: true }));
 }
 export class SignIns {
     house;
     agents;
-    changed;
-    running = new Set();
-    constructor(house, agents, changed) {
+    inputs;
+    constructor(house, agents, inputs) {
         this.house = house;
         this.agents = agents;
-        this.changed = changed;
-    }
-    idle() {
-        return this.running.size === 0;
+        this.inputs = inputs;
     }
     start(input) {
-        if (this.running.has(input.input_id))
-            return;
-        this.running.add(input.input_id);
-        this.changed();
-        this.signIn(input)
-            .catch(logged)
-            .finally(() => {
-            this.running.delete(input.input_id);
-            this.changed();
-        });
+        void this.inputs.carry(input.input_id, () => this.signIn(input));
     }
     async signIn(input) {
         const ending = new AbortController();
@@ -48,9 +32,7 @@ export class SignIns {
         clearTimeout(timer);
         if (ended)
             process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
-        await this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {});
-        if (!ended)
-            await this.agents.reread(input.cli);
+        return ended ? { ack: {} } : { ack: {}, acknowledged: () => this.agents.reread(input.cli) };
     }
     async signedIn(input, signal) {
         await this.login(input, signal);

package/dist/stream.js

@@ -1,5 +1,5 @@
 import { subscribe } from 'node:diagnostics_channel';
-import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
+import { HouseRefusal, retryDelay } from './api.js';
 import { end, REPLACED, signInAgain, updateRequired } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
@@ -82,9 +82,9 @@ export function holdStream(handlers) {
             }
             if (refused !== null && tooOld(refused.text))
                 updateRequired();
-            if (finalRefusal(refused))
-                end(refused.message);
-            // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
+            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.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
         opening.onopen = () => {

package/dist/update.js

@@ -6,9 +6,6 @@ import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome, workspaceRoot } from './home.js';
 import { service, throughSudo } from './placement.js';
-function logged(error) {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
-}
 function directory() {
     return join(kitHome(), 'update');
 }
@@ -50,6 +47,12 @@ async function recorded() {
         return null;
     return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
 }
+async function forget(inputId) {
+    if ((await pendingInput()) !== inputId)
+        return;
+    await rm(pending(), { force: true });
+    await rm(outcome(), { force: true });
+}
 async function finished(inputId) {
     for (;;) {
         const ack = await recorded();
@@ -90,27 +93,28 @@ function rerun(script, inputId, flags) {
     });
 }
 export class Updates {
-    house;
-    held = new Set();
+    inputs;
     queue = Promise.resolve();
-    constructor(house) {
-        this.house = house;
+    constructor(inputs) {
+        this.inputs = inputs;
     }
     async resumed() {
         const inputId = await pendingInput();
         if (inputId === null)
             return;
-        await this.acknowledge(inputId, await finished(inputId));
+        await this.enqueue(inputId, () => finished(inputId));
     }
     start(input) {
-        if (this.held.has(input.input_id))
-            return;
-        this.held.add(input.input_id);
-        this.queue = this.queue
-            .then(() => this.carry(input))
-            .then((ack) => this.acknowledge(input.input_id, ack))
-            .catch(logged)
-            .finally(() => this.held.delete(input.input_id));
+        void this.enqueue(input.input_id, () => this.carry(input));
+    }
+    enqueue(inputId, work) {
+        const before = this.queue;
+        const carried = this.inputs.carry(inputId, async () => {
+            await before;
+            return { ack: await work(), acknowledged: () => forget(inputId) };
+        });
+        this.queue = before.then(() => carried);
+        return carried;
     }
     async carry(input) {
         if ((await pendingInput()) === input.input_id)
@@ -131,11 +135,4 @@ export class Updates {
             refused: 'the Kit bootstrap did not finish',
         };
     }
-    async acknowledge(inputId, ack) {
-        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
-        if ((await pendingInput()) !== inputId)
-            return;
-        await rm(pending(), { force: true });
-        await rm(outcome(), { force: true });
-    }
 }

package/dist/wire.js

@@ -1,5 +1,5 @@
 import { refusalOf } from './refusals.js';
-export const KIT_WIRE = 1;
+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';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-caf8b8e5a324f",
+  "version": "0.2.1-cb345f4157685",
   "description": "House Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {