@agentshouse/kit 0.2.1-c64c31420c9bf → 0.2.1-c6ec4d4d781e7

package/dist/house-cli.js

@@ -1,14 +1,18 @@
 import { createHash } from 'node:crypto';
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
-import { basename, dirname, extname, join, resolve } from 'node:path';
-import { verified } from './files.js';
+import { request as httpsRequest } from 'node:https';
+import { basename, extname, join, resolve } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { downloaded, inspectedFile, storeRefusal, uploaded } from './files.js';
 import { HOUSE_REF } from './git.js';
 import { ownerSocket, readOwnAgent } from './home.js';
-import { callHouse, rpc, UNREACHABLE } from './mcp.js';
-import { refusalOf } from './refusals.js';
+import { callHouse, rpc, UNREACHABLE, Unsettled } from './mcp.js';
+import { refusalOf, retryable } from './refusals.js';
 import { relayed, selectRelay } from './relay.js';
-import { parse, stringify } from 'yaml';
+import { parse } from 'yaml';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const PUSH_USAGE = 'usage: house push [commit] [--owner]';
 const PUSH = "push [commit]: sends the Local copy's committed changes to House";
@@ -51,15 +55,12 @@ const MEDIA_TYPES = new Map([
     ['xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
     ['zip', 'application/zip'],
 ]);
-function refused(path, method, status, text, local) {
+function refused(path, status, text, local) {
     const refusal = refusalOf(text);
     if (refusal !== null)
         return refusal.text;
     if (status === 401)
         return REVOKED;
-    const act = method === 'GET' ? 'download' : 'upload';
-    if (URL.canParse(path))
-        return `the ${act} answered ${status}; ${act} the file again`;
     if (status === 502 && local)
         return text;
     return path === '/' ? unconfirmed(status) : `${path} answered ${status}`;
@@ -67,26 +68,23 @@ function refused(path, method, status, text, local) {
 function unconfirmed(status) {
     return `House answered ${status} ${UNCONFIRMED}`;
 }
-function exchanged(path, method, body, headers = { 'content-type': 'application/json' }, to = socketPath) {
+function bridged(path, body, to = socketPath) {
     return new Promise((resolve, reject) => {
-        const sent = request({ socketPath: to, path, method, headers }, (answer) => {
+        const sent = request({ socketPath: to, path, method: 'POST', headers: { 'content-type': 'application/json' } }, (answer) => {
             const chunks = [];
             answer.on('data', (chunk) => chunks.push(chunk));
             answer.on('end', () => {
-                const bytes = Buffer.concat(chunks);
+                const text = Buffer.concat(chunks).toString('utf8');
                 if (answer.statusCode === 200)
-                    resolve(bytes);
+                    resolve(text);
                 else
-                    reject(new Error(refused(path, method, answer.statusCode, bytes.toString('utf8'), answer.headers['content-type'] === undefined)));
+                    reject(new Error(refused(path, answer.statusCode, text, answer.headers['content-type'] === undefined)));
             });
         });
         sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
-        sent.end(body === undefined ? undefined : body instanceof Buffer ? body : JSON.stringify(body));
+        sent.end(JSON.stringify(body));
     });
 }
-async function bridged(path, body, headers, to = socketPath) {
-    return (await exchanged(path, 'POST', body, headers, to)).toString('utf8');
-}
 async function direct(message) {
     const ownAgent = await readOwnAgent();
     if (ownAgent === null)
@@ -94,11 +92,14 @@ async function direct(message) {
     selectRelay(process.env.HOUSE_KIT_RELAY || ownAgent.relay);
     setGlobalProxyFromEnv();
     const answer = await callHouse(ownAgent.house, ownAgent.credential, message).catch(() => {
-        throw new Error(UNREACHABLE);
+        throw new Unsettled(UNREACHABLE);
     });
     if (answer.status === 200)
         return answer.text;
-    throw new Error(answer.status === 401 ? DISCONNECTED : (refusalOf(answer.text)?.text ?? unconfirmed(answer.status)));
+    if (answer.status === 401)
+        throw new Error(DISCONNECTED);
+    const refusal = refusalOf(answer.text)?.text ?? unconfirmed(answer.status);
+    throw retryable(answer.text) === false ? new Error(refusal) : new Unsettled(refusal);
 }
 async function mcp(method, params) {
     const message = rpc(method, params);
@@ -110,31 +111,51 @@ async function mcp(method, params) {
 async function tools() {
     return (await mcp('tools/list', {})).tools;
 }
+function unreadable(path, error) {
+    return new Error(error.code === 'EISDIR'
+        ? `${path} is a folder; upload one file at a time`
+        : `${path} is not a readable file`);
+}
 async function localFile(path) {
     try {
         return await readFile(path);
     }
     catch (error) {
-        throw new Error(error.code === 'EISDIR'
-            ? `${path} is a folder; upload one file at a time`
-            : `${path} is not a readable file`);
+        throw unreadable(path, error);
     }
 }
-async function transferred(url, method, bytes, headers) {
-    if (socketPath !== undefined)
-        return exchanged(url, method, bytes, headers);
-    setGlobalProxyFromEnv();
-    const answer = await fetch(relayed(url), { method, ...(headers === undefined ? {} : { headers }), ...(bytes === undefined ? {} : { body: bytes }) }).catch(() => {
-        throw new Error(UNREACHABLE);
+function opened(url, method, headers, body) {
+    return new Promise((answered, failed) => {
+        const local = socketPath !== undefined;
+        const target = local ? null : relayed(url);
+        if (!local)
+            setGlobalProxyFromEnv();
+        const sent = target === null
+            ? request({ socketPath, path: url, method, headers }, answered)
+            : (target.protocol === 'https:' ? httpsRequest : request)(target, { method, headers }, answered);
+        sent.on('error', (error) => failed(new Error(!local ? UNREACHABLE : error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
+        if (body instanceof Readable)
+            pipeline(body, sent).catch(() => undefined);
+        else
+            sent.end(body);
     });
-    const received = Buffer.from(await answer.arrayBuffer());
-    if (answer.status === 200)
-        return received;
-    throw new Error(refused(url, method, answer.status, received.toString('utf8'), false));
+}
+async function textOf(answer) {
+    return Buffer.concat(await answer.toArray()).toString('utf8');
 }
 async function sent(url, bytes, operation) {
     const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
-    return (await transferred(url, 'POST', bytes, headers)).toString('utf8');
+    const answer = await opened(url, 'POST', headers, bytes);
+    const text = await textOf(answer);
+    if (answer.statusCode === 200)
+        return text;
+    throw new Error(refusalOf(text)?.text ?? storeRefusal('upload', answer.statusCode).message);
+}
+async function sentPart(url, file, start, end) {
+    const answer = await opened(url, 'PUT', { 'content-length': String(end - start) }, end === start ? undefined : createReadStream(file, { start, end: end - 1 }));
+    await answer.toArray();
+    if (answer.statusCode !== 200)
+        throw storeRefusal('upload', answer.statusCode);
 }
 async function download(args) {
     const { flags, positionals: [argument] } = accepted(args, ['--help'], 1, DOWNLOAD_USAGE);
@@ -143,37 +164,52 @@ async function download(args) {
     const { file, ...selected } = argumentsOf(argument);
     if (typeof file !== 'string' || file === '')
         throw new Error('download needs "file", the local file to write');
-    const inspected = parse(await called('inspect', selected));
-    if (typeof inspected?.download !== 'string')
-        throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
-    const bytes = verified(await transferred(inspected.download, 'GET'), String(inspected.sha256), String(selected.path));
     const written = resolve(file);
-    await mkdir(dirname(written), { recursive: true });
-    await writeFile(written, bytes);
+    await downloaded(async () => {
+        const file = inspectedFile(await called('inspect', selected));
+        if (file === null)
+            throw new Error(`${String(selected.path)} holds no binary file; shell reads its text`);
+        return file;
+    }, async (url) => {
+        const answer = await opened(url, 'GET', {});
+        return { status: answer.statusCode, body: answer };
+    }, written, String(selected.path));
     return written;
 }
 async function described(file) {
-    const bytes = await localFile(file);
+    const digest = createHash('sha256');
+    let bytes = 0;
+    try {
+        for await (const chunk of createReadStream(file)) {
+            digest.update(chunk);
+            bytes += chunk.length;
+        }
+    }
+    catch (error) {
+        throw unreadable(file, error);
+    }
     const mediaType = MEDIA_TYPES.get(extname(file).slice(1).toLowerCase());
-    return {
-        bytes,
-        description: {
-            bytes: bytes.length,
-            sha256: createHash('sha256').update(bytes).digest('hex'),
-            ...(mediaType === undefined ? {} : { media_type: mediaType }),
-        },
-    };
+    return { bytes, sha256: digest.digest('hex'), ...(mediaType === undefined ? {} : { media_type: mediaType }) };
+}
+async function finished(upload, room) {
+    const text = await called('upload', { upload, room_ref: room });
+    const answer = parse(text);
+    return answer !== null && ('upload' in answer || 'checking' in answer) ? answer : { text };
 }
 async function upload({ file, ...destination }) {
     if (typeof file !== 'string' || file === '')
         throw new Error('upload needs "file", a local file');
-    const { bytes, description } = await described(file);
+    const description = await described(file);
     const answer = await called('upload', { ...destination, ...description });
     const declared = parse(answer);
-    if (declared.upload === undefined)
+    if (declared?.upload === undefined)
         return answer;
-    const written = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
-    return stringify(written, { lineWidth: 0 }).trimEnd();
+    const accepted = await uploaded(declared.upload, {
+        bytes: description.bytes,
+        send: (url, start, end) => sentPart(url, file, start, end),
+        finish: (id) => finished(id, destination.room_ref),
+    });
+    return accepted.text;
 }
 async function appendRecord(args) {
     const held = new Map();
@@ -181,8 +217,8 @@ async function appendRecord(args) {
         ? await Promise.all(args.attachments.map(async (attachment) => {
             if (typeof attachment !== 'string')
                 return attachment;
-            const { bytes, description } = await described(attachment);
-            held.set(description.sha256, bytes);
+            const description = await described(attachment);
+            held.set(description.sha256, attachment);
             return { name: basename(attachment), ...description };
         }))
         : args.attachments;
@@ -193,7 +229,7 @@ async function appendRecord(args) {
         if (upload === undefined)
             return answer;
         for (const grant of upload)
-            await sent(grant.url, held.get(grant.sha256), grant.operation);
+            await sent(grant.url, await localFile(held.get(grant.sha256)), grant.operation);
     }
 }
 function unexpected(argument, usage) {
@@ -220,7 +256,7 @@ async function push(args) {
         throw new Error('--owner is not for Agent conversations; run house push without it');
     if (!owner && socketPath === undefined)
         throw new Error('outside an Agent conversation, house push needs --owner');
-    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, undefined, owner ? ownerSocket() : socketPath));
+    const pushed = JSON.parse(await bridged('/git/push', { cwd: process.cwd(), commit }, owner ? ownerSocket() : socketPath));
     if (pushed.refused)
         throw new Error(pushed.text);
     return pushed.text;
@@ -228,7 +264,7 @@ async function push(args) {
 async function fetched(args) {
     if (accepted(args, ['--help'], 0, FETCH_USAGE).flags.has('--help'))
         return FETCH_USAGE;
-    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? ownerSocket()));
+    const answer = JSON.parse(await bridged('/git/fetch', {}, socketPath ?? ownerSocket()));
     if (answer.refused)
         throw new Error(answer.text);
     return answer.text;

package/dist/instructions.js

@@ -4,8 +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 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, ...(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/kit-cli.js

@@ -11,7 +11,7 @@ const COMMANDS = new Map([
         'logout',
         {
             usage: 'usage: kit logout',
-            about: "disconnects this computer, stops House Kit and ends your own agent's connection",
+            about: "disconnects this computer, stops the Kit process and ends your own agent's connection",
             operands: 0,
             run: logout,
         },
@@ -20,7 +20,7 @@ const COMMANDS = new Map([
         'resident',
         {
             usage: 'usage: kit resident',
-            about: "keeps this Environment connected; House Kit's service runs it",
+            about: "keeps this Environment connected; Kit's service runs it",
             operands: 0,
             run: resident,
         },

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,16 +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 { 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`);
@@ -46,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 {
@@ -131,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 = () => conversations.idle() && signIns.idle() && agents.idle();
+    const idle = () => calls.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 calls = new Calls(house, changed);
     const conversations = new Conversations({
         house,
         agents,
         copies,
-        send: (frame) => stream?.send(frame) ?? false,
+        calls,
+        send: (notification) => connection?.send(notification) ?? false,
         changed,
     });
-    const signIns = new SignIns(house, agents, changed);
-    const updates = new Updates(house);
+    const signIns = new SignIns(house, agents, calls);
+    const update = new KitUpdate(calls);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -162,32 +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 === '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')
-                    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` };
-                    logged(house.deliver(`/kit/inputs/${arrived.input_id}/ack`, refused).finally(changed));
-                }
+        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

@@ -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;
@@ -10,7 +13,21 @@ 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);
+}
+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') {
@@ -18,12 +35,17 @@ export function startService() {
         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,68 +9,50 @@ 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) {
+    calls;
+    constructor(house, agents, calls) {
         this.house = house;
         this.agents = agents;
-        this.changed = changed;
-    }
-    idle() {
-        return this.running.size === 0;
+        this.calls = calls;
     }
-    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();
-        });
+    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`);
-        await this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {});
-        if (!ended)
-            await 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,
@@ -102,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)
@@ -119,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`);
     }
 }