@agentshouse/kit 0.2.1-cde47fd72fe59 → 0.2.1-ce3d2bb67177c

package/dist/login.js

@@ -1,6 +1,5 @@
 import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
-import { hostname } from 'node:os';
 import { parseArgs } from 'node:util';
 import { HouseRefusal, post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
@@ -91,13 +90,12 @@ export async function login(argv) {
     let named = environment;
     let exchanged;
     if (values.code !== undefined) {
-        exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
+        exchanged = await post(house, '/kit/token', { code: values.code });
     }
     else {
         held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
         const verifier = randomBytes(32).toString('base64url');
         const start = () => retrying(() => post(house, '/kit', {
-            label: hostname(),
             ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
                 : { act: 'existing_environment', environment_id: named }),

package/dist/mcp.js

@@ -1,8 +1,10 @@
 import { randomUUID } from 'node:crypto';
-import { KIT_VERSION } from './clis.js';
+import { KIT_RELEASE } from './clis.js';
 import { relayed } from './relay.js';
 const MCP_PROTOCOL_VERSION = '2026-07-28';
 export const UNREACHABLE = 'House is unreachable; call again in a minute';
+export class Unsettled extends Error {
+}
 export function rpc(method, params) {
     return { jsonrpc: '2.0', id: randomUUID(), method, params };
 }
@@ -13,7 +15,7 @@ export function mcpBody(message, operation) {
             ...message.params,
             _meta: {
                 'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
-                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
+                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_RELEASE },
                 'io.modelcontextprotocol/clientCapabilities': {},
                 ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
             },

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

@@ -8,17 +8,17 @@ import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
 import { received } from './bridge.js';
-import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
+import { CONVERSATION_METHODS, 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 { Calls } from './calls.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
-import { holdStream } from './stream.js';
-import { Updates } from './update.js';
+import { holdConnection } from './connection.js';
+import { KitUpdate } from './update.js';
 import { codexLauncher } from './work.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -47,7 +47,7 @@ async function serveOwner(copies) {
     if (!claimed(lock)) {
         lock.close();
         const running = await runningResident();
-        throw new Error(`${running === null ? 'another Kit' : `Kit ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another here`);
+        throw new Error(`${running === null ? 'another Kit process' : `Kit process ${running}`} already runs this Environment from Kit home ${kitHome()}; stop it first to run another Kit process here`);
     }
     const server = createServer(async (request, response) => {
         try {
@@ -132,9 +132,9 @@ export async function resident() {
     });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
     const agents = new Agents(house, () => changed());
-    let stream = null;
+    let connection = null;
     let reported = false;
-    const idle = () => inputs.idle() && conversations.idle() && agents.idle();
+    const idle = () => calls.idle() && conversations.idle() && agents.idle();
     const changed = () => {
         if (!idle()) {
             reported = false;
@@ -147,17 +147,17 @@ export async function resident() {
             logged(house.deliver('/kit/idle', {}, idle));
         }
     };
-    const inputs = new Inputs(house, changed);
+    const calls = new Calls(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
-        inputs,
-        send: (frame) => stream?.send(frame) ?? false,
+        calls,
+        send: (notification) => connection?.send(notification) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, inputs);
-    const updates = new Updates(inputs);
+    const signIns = new SignIns(house, agents, calls);
+    const update = new KitUpdate(calls);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -165,33 +165,33 @@ export async function resident() {
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
-    await updates.resumed().catch(report);
+    await update.resumed().catch(report);
     logged(agents.refresh());
-    stream = holdStream({
+    connection = holdConnection({
         opened: () => {
             conversations.opened();
             changed();
             logged(copies.connected());
         },
-        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') {
-                if (arrived.kind === 'sign_in')
-                    signIns.start(arrived);
-                else if (arrived.kind === 'update')
-                    updates.start(arrived);
-                else if (CONVERSATION_INPUTS.has(arrived.kind))
-                    conversations.input(arrived);
-                else {
-                    const refused = { refused: `This Kit does not know ${arrived.kind}; update the Kit` };
-                    void inputs.carry(String(arrived.input_id), async () => ({ ack: refused }));
-                }
+        call: (call) => {
+            if (call.kind === 'sign_in')
+                signIns.start(call);
+            else if (call.kind === 'update')
+                update.start(call);
+            else if (CONVERSATION_METHODS.has(call.kind))
+                conversations.call(call);
+            else {
+                const refused = { refused: `This Kit does not know ${call.kind}; update the Kit` };
+                void calls.carry(call.input_id, async () => ({ result: refused }));
             }
         },
+        notification: (notification) => {
+            if (notification.type === 'watching')
+                conversations.watching(notification.watching === true);
+            if (notification.type === 'authority_changed')
+                logged(copies.changed(notification.rooms));
+            if (notification.type === 'work_available' && notification.subject === 'agents')
+                logged(agents.refresh());
+        },
     });
 }

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

@@ -13,7 +13,7 @@ function start(command, args) {
     if (started.status === 0)
         return;
     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}`);
+    throw new Error(`the Kit service could not be started: ${cause}`);
 }
 function physical(path) {
     return existsSync(path) ? realpathSync(path) : resolve(path);

package/dist/sign-in.js

@@ -15,44 +15,44 @@ function endOf(signal) {
 export class SignIns {
     house;
     agents;
-    inputs;
-    constructor(house, agents, inputs) {
+    calls;
+    constructor(house, agents, calls) {
         this.house = house;
         this.agents = agents;
-        this.inputs = inputs;
+        this.calls = calls;
     }
-    start(input) {
-        void this.inputs.carry(input.input_id, () => this.signIn(input));
+    start(call) {
+        void this.calls.carry(call.input_id, () => this.signIn(call));
     }
-    async signIn(input) {
+    async signIn(call) {
         const ending = new AbortController();
         // House stops waiting for a sign-in ten minutes after it wrote it and sends the seconds left, so its install and login end with the page.
-        const timer = setTimeout(() => ending.abort(), input.ends_in * 1000);
-        const ended = await Promise.race([this.signedIn(input, ending.signal), endOf(ending.signal)]);
+        const timer = setTimeout(() => ending.abort(), call.ends_in * 1000);
+        const ended = await Promise.race([this.signedIn(call, ending.signal), endOf(ending.signal)]);
         clearTimeout(timer);
         if (ended)
-            process.stderr.write(`kit: the ${input.cli} sign-in reached the end House set for it\n`);
-        return ended ? { ack: {} } : { ack: {}, acknowledged: () => this.agents.reread(input.cli) };
+            process.stderr.write(`kit: the ${call.cli} sign-in reached the end House set for it\n`);
+        return ended ? { result: {} } : { result: {}, returned: () => this.agents.reread(call.cli) };
     }
-    async signedIn(input, signal) {
-        await this.login(input, signal);
+    async signedIn(call, signal) {
+        await this.login(call, signal);
         if (!signal.aborted)
-            await this.agents.recheck(input.cli, signal);
+            await this.agents.recheck(call.cli, signal);
         return false;
     }
-    async login(input, signal) {
+    async login(call, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli, signal);
+            cli = await this.agents.located(call.cli, signal);
         }
         catch (error) {
             if (!signal.aborted)
-                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+                process.stderr.write(`kit: the ${call.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
         if (signal.aborted)
             return;
-        const login = CLIS[input.cli].login;
+        const login = CLIS[call.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             detached: true,
@@ -84,7 +84,7 @@ export class SignIns {
                 return;
             held = true;
             const steps = [{ kind: 'visit', label: 'Open this link and sign in', url: link }, step];
-            void holdSecretInput(this.house, input.input_id, steps, running).then((content) => {
+            void holdSecretInput(this.house, call.input_id, steps, running).then((content) => {
                 if (!running())
                     return;
                 if (content === null)
@@ -101,6 +101,6 @@ export class SignIns {
         });
         signal.removeEventListener('abort', stop);
         if (failed !== null && !signal.aborted)
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
+            process.stderr.write(`kit: the ${call.cli} sign-in failed: ${failed}\n`);
     }
 }

package/dist/skills.js

@@ -5,7 +5,7 @@ import { homedir } from 'node:os';
 import { join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parse } from 'yaml';
-import { KIT_VERSION } from './clis.js';
+import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
 const HOW_WE_WORK = '/rooms/private/how-we-work.md';
@@ -60,7 +60,7 @@ async function install() {
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_VERSION, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, names });
 }
 export async function placeSkillSet() {
     try {
@@ -73,7 +73,7 @@ export async function placeSkillSet() {
 async function replaceSkillSet() {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_VERSION)
+    if (accepted && installed?.version === KIT_RELEASE)
         return;
     for (const name of installed?.names ?? []) {
         await rm(join(claudeDirectory(), name), { recursive: true, force: true });

package/dist/transcription.js

@@ -6,6 +6,7 @@ import { basename, join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { unlessAborted } from './abort.js';
 import { failureOf, run } from './clis.js';
+import { downloaded, fetched } from './files.js';
 import { kitHome } from './home.js';
 const RELEASE = 'https://github.com/agentshouse/kit/releases/download/engine-2';
 export const MODEL = {
@@ -28,6 +29,11 @@ export const ENGINES = {
     },
 };
 const CHUNK_SECONDS = 20;
+const OFF = "transcription is off on the Agent's Environment, so this message's audio has no text; turn it on or write instead";
+const NOT_INSTALLED = "the speech engine is not installed on the Agent's Environment, so this message's audio has no text";
+const NOT_DOWNLOADED = 'an audio file this message links could not be downloaded; send the message again';
+const UNDECODABLE = 'an audio file this message links could not be decoded';
+const UNTRANSCRIBED = 'an audio file this message links could not be transcribed';
 let held = Promise.resolve();
 let holding = Promise.resolve();
 let setting = null;
@@ -62,6 +68,20 @@ async function sha256(path) {
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+async function failing(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new Error(reason, { cause: error });
+    }
+}
+function ready() {
+    if (setting !== true)
+        throw new Error(OFF);
+    if (!readiness.installed)
+        throw new Error(NOT_INSTALLED);
+}
 function pinnedHere() {
     return ENGINES[`${process.platform}-${process.arch}`];
 }
@@ -133,27 +153,23 @@ export function holdTranscription(transcribe) {
 export function transcriptionReport() {
     return readiness;
 }
-async function transcribed(path, signal) {
+async function transcribed(audio, parts, signal) {
     const pinned = pinnedHere();
-    const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
-    try {
-        await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
-            '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(work, '%05d.wav')], signal);
-        const parts = (await readdir(work)).sort().flatMap((part) => ['-f', join(work, part)]);
-        const text = await executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...parts], signal);
-        return text
-            .split('\n')
-            .map((line) => line.trim())
-            .filter((line) => line !== '')
-            .join(' ');
-    }
-    finally {
-        await rm(work, { recursive: true, force: true });
-    }
+    await mkdir(parts);
+    await failing(UNDECODABLE, executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', audio, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
+        '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(parts, '%05d.wav')], signal));
+    const segments = (await readdir(parts)).sort().flatMap((part) => ['-f', join(parts, part)]);
+    const said = await failing(UNTRANSCRIBED, executed(installed(pinned.engine), ['-t', String(await threads()), '-np', '-m', installed(MODEL), ...segments], signal));
+    const text = said
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line !== '')
+        .join(' ');
+    if (text === '')
+        throw new Error(UNTRANSCRIBED);
+    return text;
 }
-export async function transcribe(path, signal) {
-    if (!readiness.installed)
-        return null;
+async function alone(work, signal) {
     const before = held;
     let release;
     const mine = new Promise((resolve) => {
@@ -162,9 +178,24 @@ export async function transcribe(path, signal) {
     held = Promise.all([before, mine]);
     try {
         await unlessAborted(before, signal);
-        return readiness.installed ? await transcribed(path, signal) : null;
+        return await work();
     }
     finally {
         release();
     }
 }
+export async function transcribe(address, signal) {
+    ready();
+    const work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
+    try {
+        const audio = join(work, 'audio');
+        await failing(NOT_DOWNLOADED, downloaded(address, (url) => fetched(url, signal), audio, 'audio'));
+        return await alone(() => {
+            ready();
+            return transcribed(audio, join(work, 'parts'), signal);
+        }, signal);
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}

package/dist/update.js

@@ -15,8 +15,8 @@ function pending() {
 function outcome() {
     return join(directory(), 'outcome');
 }
-function unit(inputId) {
-    return `house-kit-update-${inputId}`;
+function unit(callId) {
+    return `house-kit-update-${callId}`;
 }
 function manager() {
     return service() === 'user' ? ['--user'] : [];
@@ -33,7 +33,7 @@ function placement() {
 function record() {
     return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
 }
-async function pendingInput() {
+async function pendingCall() {
     try {
         return JSON.parse(await readFile(pending(), 'utf8')).input_id;
     }
@@ -47,26 +47,26 @@ 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)
+async function forget(callId) {
+    if ((await pendingCall()) !== callId)
         return;
     await rm(pending(), { force: true });
     await rm(outcome(), { force: true });
 }
-async function finished(inputId) {
+async function finished(callId) {
     for (;;) {
-        const ack = await recorded();
-        if (ack !== null)
-            return ack;
+        const result = await recorded();
+        if (result !== null)
+            return result;
         // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(callId)], 10_000)).status !== 0) {
             return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
         }
         // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
-function rerun(script, inputId, flags) {
+function rerun(script, callId, flags) {
     return new Promise((resolve) => {
         const [command, ...args] = [
             ...elevated(),
@@ -76,7 +76,7 @@ function rerun(script, inputId, flags) {
             '--wait',
             '--collect',
             '--quiet',
-            `--unit=${unit(inputId)}`,
+            `--unit=${unit(callId)}`,
             `--setenv=HOME=${homedir()}`,
             `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
             '/bin/sh',
@@ -88,50 +88,50 @@ function rerun(script, inputId, flags) {
             ...flags,
         ];
         const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
-        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
+        child.on('error', () => resolve({ refused: 'no service manager runs this Kit process' }));
         child.on('close', () => resolve(null));
     });
 }
-export class Updates {
-    inputs;
+export class KitUpdate {
+    calls;
     queue = Promise.resolve();
-    constructor(inputs) {
-        this.inputs = inputs;
+    constructor(calls) {
+        this.calls = calls;
     }
     async resumed() {
-        const inputId = await pendingInput();
-        if (inputId === null)
+        const callId = await pendingCall();
+        if (callId === null)
             return;
-        await this.enqueue(inputId, () => finished(inputId));
+        await this.enqueue(callId, () => finished(callId));
     }
-    start(input) {
-        void this.enqueue(input.input_id, () => this.carry(input));
+    start(call) {
+        void this.enqueue(call.input_id, () => this.carry(call));
     }
-    enqueue(inputId, work) {
+    enqueue(callId, work) {
         const before = this.queue;
-        const carried = this.inputs.carry(inputId, async () => {
+        const carried = this.calls.carry(callId, async () => {
             await before;
-            return { ack: await work(), acknowledged: () => forget(inputId) };
+            return { result: await work(), returned: () => forget(callId) };
         });
         this.queue = before.then(() => carried);
         return carried;
     }
-    async carry(input) {
-        if ((await pendingInput()) === input.input_id)
-            return finished(input.input_id);
-        const answer = await fetch(input.bootstrap);
+    async carry(call) {
+        if ((await pendingCall()) === call.input_id)
+            return finished(call.input_id);
+        const answer = await fetch(call.bootstrap);
         if (!answer.ok)
             return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
         const script = Buffer.from(await answer.arrayBuffer());
-        if (createHash('sha256').update(script).digest('hex') !== input.sha256) {
+        if (createHash('sha256').update(script).digest('hex') !== call.sha256) {
             return { refused: 'the Kit bootstrap does not match its sha256' };
         }
         await mkdir(directory(), { recursive: true, mode: 0o700 });
         const path = join(directory(), 'connect-linux.sh');
         await writeFile(path, script, { mode: 0o700 });
         await rm(outcome(), { force: true });
-        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
-        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
+        await writeFile(pending(), `${JSON.stringify({ input_id: call.input_id })}\n`, { mode: 0o600 });
+        return (await rerun(path, call.input_id, call.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
             refused: 'the Kit bootstrap did not finish',
         };
     }

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 = 3;
 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,7 +1,7 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-cde47fd72fe59",
-  "description": "House Kit connects an Environment to agents.house.",
+  "version": "0.2.1-ce3d2bb67177c",
+  "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
     "type": "git",

package/dist/inputs.js

@@ -1,37 +0,0 @@
-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();
-        });
-    }
-}