@agentshouse/kit 0.2.1-c3895fcff473b → 0.2.1-c4ea88ba9424e

package/README.md

@@ -37,10 +37,11 @@ them out; running it again without the flag brings them back.
 Environment's credential in `~/.house-kit`, or in `$HOUSE_KIT_HOME` when it is
 set. Pass `--manual` to paste the code by hand on a machine without a browser,
 and `--environment <id>` to reconnect an Environment you already have. It also
-connects your own agent: `house <tool>` run outside an Agent conversation calls
-House as you, until you revoke that connection on Connections. `house help`
-lists the Tools. `kit logout` disconnects this computer and stops House Kit; a
-later `kit login` reconnects the same Environment.
+connects your own agent: outside an Agent conversation, `house <tool>` calls
+House as you and `git` clones and pushes your Apps at `<house>/app/` as you,
+until you revoke that connection on Connections. `house help` lists the Tools.
+`kit logout` disconnects this computer, stops House Kit and ends that Git
+access; a later `kit login` reconnects the same Environment.
 
 `kit resident` keeps the Environment connected, and keeps the Rooms you chose
 for this Environment as Git repositories under `local-copies` in the
@@ -49,11 +50,9 @@ commit to House; in the container, run it through the install command from the
 copy's directory. Inside an Agent conversation the Agent runs `house push`.
 
 House Kit turns each audio file of your message to an Agent into text on this
-computer before the Agent reads the message. The first audio file downloads the
-speech engine and model, about 425 MB, into `~/.house-kit`.
+computer before the Agent reads it. While transcription is on, the speech
+engine and model use about 425 MB in `~/.house-kit`; turning it off deletes them.
 
 ## License
 
-MIT
-
-The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.
+MIT. The skills come from [mattpocock/skills](https://github.com/mattpocock/skills); thank you, Matt Pocock.

package/dist/acp.js

@@ -5,7 +5,7 @@ import { Readable, Writable } from 'node:stream';
 import { CLIS, KIT_VERSION, adapterCommand, withoutProxy } from './clis.js';
 export const TURN_STARTED = 'kit/turn_started';
 export const TURN_ENDED = 'kit/turn_ended';
-export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined, added = {}) {
+export async function startAdapter(kind, cli, cwd, app, jobs = () => undefined, added = {}, signal) {
     const adapter = CLIS[kind].adapter;
     const child = spawn(adapter === null ? cli : adapterCommand(kind), CLIS[kind].args, {
         cwd,
@@ -13,6 +13,9 @@ export async function startAdapter(kind, cli, cwd, app, jobs = () => 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 stderr = '';
     child.stderr.on('data', (chunk) => {
         stderr = (stderr + chunk.toString('utf8')).slice(-4000);

package/dist/agents.js

@@ -3,6 +3,7 @@ import { readFile, realpath } from 'node:fs/promises';
 import { killTree, startAdapter } from './acp.js';
 import { CLIS, KIT_VERSION, below, installAdapter, installCli, locate, run, versionOf } from './clis.js';
 import { agentBase, kitHome } from './home.js';
+import { holdTranscription, transcriptionReport } from './transcription.js';
 const SIGNED_OUT = { signed_in: false, models: [], modes: [] };
 function select(options, category) {
     const option = options.find((candidate) => candidate.category === category);
@@ -46,13 +47,29 @@ async function models(kind, adapter, known) {
     }
     return { models: offered, modes };
 }
-async function offer(kind, cli, known) {
+async function signedIn(kind, cli, known, signal) {
     const probe = CLIS[kind].signedIn;
-    if ('command' in probe && (await run(cli, probe.command, 30_000)).status !== 0)
+    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
+    if ('command' in probe)
+        return (await run(cli, probe.command, 30_000, false, signal)).status === 0;
+    return (await offer(kind, cli, known, signal)).signed_in;
+}
+function ended(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
+async function offer(kind, cli, known, signal) {
+    const probe = CLIS[kind].signedIn;
+    // A sign-in check that has not answered in half a minute counts as signed out rather than stalling the report.
+    if ('command' in probe && (await run(cli, probe.command, 30_000, false, signal)).status !== 0)
         return SIGNED_OUT;
     let adapter;
     try {
-        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }));
+        adapter = await startAdapter(kind, cli, kitHome(), client({ name: '@agentshouse/kit' }), () => undefined, {}, signal);
+        signal?.throwIfAborted();
         if ('initializeMeta' in probe) {
             const method = adapter.initialized._meta?.[probe.initializeMeta];
             if (typeof method !== 'string' || method.length === 0)
@@ -61,7 +78,8 @@ async function offer(kind, cli, known) {
         return { signed_in: true, ...(await models(kind, adapter, known.models)) };
     }
     catch (error) {
-        process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
+        if (!signal?.aborted)
+            process.stderr.write(`kit: ${kind} did not offer its models: ${causeOf(error)}\n`);
         return {
             signed_in: adapter === undefined && 'initializeMeta' in probe ? known.signed_in : true,
             models: known.models,
@@ -90,17 +108,19 @@ function tooOld(kind, release) {
     return `${cli.bin} ${release} is older than ${cli.minimum}, the oldest this Kit runs`;
 }
 async function sshHostKey() {
+    // Listing a local host key takes a moment, so ten seconds only bounds a stuck ssh-keygen.
     const listed = await run('ssh-keygen', ['-l', '-E', 'sha256', '-f', '/etc/ssh/ssh_host_ed25519_key.pub'], 10_000);
     return listed.status === 0 ? (/^\d+ (SHA256:\S+)/.exec(listed.output)?.[1] ?? null) : null;
 }
 async function operatingSystem() {
+    // sw_vers answers at once, so ten seconds only bounds a stuck call.
     if (process.platform === 'darwin')
         return `macOS ${(await run('sw_vers', ['-productVersion'], 10_000)).output.trim()}`;
     const release = await readFile('/etc/os-release', 'utf8');
     return /^PRETTY_NAME="?([^"\n]*)"?$/m.exec(release)?.[1] ?? release;
 }
 export class Agents {
-    desired = { agents: [], routes: [] };
+    desired = { agents: [], routes: [], transcribe: false };
     house;
     reading = Promise.resolve();
     queues = new Map();
@@ -124,8 +144,11 @@ export class Agents {
             return this.desired;
         });
         this.reading = reading;
-        return reading.then(({ agents }) => {
-            Promise.all(agents.map((kind) => this.queue(kind, () => this.load(kind))))
+        return reading.then(({ agents, transcribe }) => {
+            holdTranscription(transcribe)
+                .then((changed) => (changed ? this.report() : undefined))
+                .catch(logged);
+            Promise.all(agents.map((kind) => this.load(kind)))
                 .then(() => this.report())
                 .catch(logged);
         });
@@ -154,16 +177,19 @@ export class Agents {
             return cli;
         });
     }
-    located(kind) {
-        return this.queue(kind, () => this.ensure(kind));
+    located(kind, signal) {
+        return this.queue(kind, () => this.ensure(kind, signal), signal);
     }
     async reread(kind) {
-        await this.queue(kind, async () => {
-            this.nextRead(kind);
-            this.readings.set(kind, await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT));
-        });
+        await this.examine(kind, this.readings.get(kind) ?? SIGNED_OUT, offer);
         await this.report();
     }
+    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);
+        if (!signal.aborted)
+            await this.report();
+    }
     report() {
         const sending = this.sending.catch(() => undefined).then(() => this.send());
         this.sending = sending;
@@ -178,39 +204,42 @@ export class Agents {
         this.readings.set(kind, reading);
         this.report().catch(logged);
     }
-    queue(kind, work) {
-        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(work);
+    queue(kind, work, signal) {
+        const queued = (this.queues.get(kind) ?? Promise.resolve()).then(() => {
+            signal?.throwIfAborted();
+            return work();
+        });
         this.queues.set(kind, queued.catch(() => undefined));
-        return queued;
+        return signal === undefined ? queued : Promise.race([queued, ended(signal)]);
     }
-    async ensure(kind) {
-        const failed = await installAdapter(kind);
+    async ensure(kind, signal) {
+        const failed = await installAdapter(kind, signal);
         if (failed !== null)
             throw new Error(failed);
-        const found = await locate(kind);
+        const found = await locate(kind, signal);
         if (found !== null)
             return found;
-        const installing = this.installing.catch(() => undefined).then(() => installCli(kind));
+        const installing = this.installing.catch(() => undefined).then(() => installCli(kind, signal));
         this.installing = installing;
         const failure = await installing;
         if (failure !== null)
             throw new Error(failure);
-        const installed = await locate(kind);
+        const installed = await locate(kind, signal);
         if (installed === null)
             throw new Error(`the login shell does not find ${CLIS[kind].bin} after its install`);
         return installed;
     }
-    async resolve(kind) {
+    async resolve(kind, signal) {
         let cli;
         try {
-            cli = await realpath(await this.ensure(kind));
+            cli = await realpath(await this.ensure(kind, signal));
         }
         catch (error) {
             const failure = causeOf(error);
             process.stderr.write(`kit: ${kind} did not install: ${failure}\n`);
             return { release: null, failure, ...SIGNED_OUT };
         }
-        const release = await versionOf(cli);
+        const release = await versionOf(cli, signal);
         if (release === null)
             return { release: null, failure: `${cli} --version names no version`, ...SIGNED_OUT };
         const minimum = CLIS[kind].minimum;
@@ -218,18 +247,18 @@ export class Agents {
             return { release, minimum, failure: null, ...SIGNED_OUT };
         return { cli, release };
     }
-    async examine(kind, known) {
-        const resolved = await this.resolve(kind);
-        if (!('cli' in resolved))
-            return resolved;
-        return { release: resolved.release, failure: null, ...(await offer(kind, resolved.cli, known)) };
+    async examine(kind, known, read, signal) {
+        const current = this.nextRead(kind);
+        const resolved = await this.queue(kind, () => this.resolve(kind, signal), 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);
     }
     async load(kind) {
         const known = this.readings.get(kind);
         if (known !== undefined && known.failure === null)
             return;
-        this.nextRead(kind);
-        this.readings.set(kind, await this.examine(kind, SIGNED_OUT));
+        await this.examine(kind, SIGNED_OUT, offer);
     }
     async send() {
         const agents = this.desired.agents.flatMap((kind) => {
@@ -242,6 +271,7 @@ export class Agents {
             kit_version: KIT_VERSION,
             agent_base: agentBase(),
             agents,
+            transcription: transcriptionReport(),
             ...(hostKey === null ? {} : { ssh_host_key: hostKey }),
         };
         const state = JSON.stringify(body);

package/dist/api.js

@@ -1,4 +1,7 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { end, SIGN_IN_AGAIN } from './end.js';
 import { readEnrolment } from './home.js';
+import { retryable } from './refusals.js';
 import { relayed } from './relay.js';
 export class HouseRefusal extends Error {
     status;
@@ -9,9 +12,26 @@ export class HouseRefusal extends Error {
         this.text = text;
     }
 }
+export function finalRefusal(error) {
+    return error instanceof HouseRefusal && retryable(error.text) === false;
+}
 export function retryDelay(attempt) {
+    // Full jitter, doubling from one second to a 30-second cap, spreads the Kits one outage dropped and retries within half a minute of House's return.
     return Math.random() * Math.min(30_000, 1000 * 2 ** attempt);
 }
+export async function retrying(sent, signal) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await sent();
+        }
+        catch (error) {
+            if (!(error instanceof HouseRefusal) || retryable(error.text) !== true)
+                throw error;
+        }
+        // A request House refused as retryable is sent again on the jittered curve.
+        await delay(retryDelay(attempt), undefined, { signal });
+    }
+}
 export async function post(house, path, body, credential, signal) {
     const answer = await fetch(relayed(new URL(path, house)), {
         method: 'POST',
@@ -29,7 +49,14 @@ export async function post(house, path, body, credential, signal) {
 }
 async function enrolledPost(path, body, signal) {
     const { house, credential } = (await readEnrolment());
-    return post(house, path, body, credential, signal);
+    try {
+        return await post(house, path, body, credential, signal);
+    }
+    catch (error) {
+        if (error instanceof HouseRefusal && error.status === 401)
+            end(SIGN_IN_AGAIN);
+        throw error;
+    }
 }
 export const house = {
     post: enrolledPost,
@@ -39,9 +66,10 @@ export const house = {
                 return await enrolledPost(path, body);
             }
             catch (error) {
-                if (error instanceof HouseRefusal && error.status < 500)
+                if (finalRefusal(error))
                     throw error;
                 process.stderr.write(`kit: ${path} did not reach House: ${error.message}\n`);
+                // A delivery House did not take is sent again on the jittered curve for as long as it is still current.
                 await new Promise((resolve) => setTimeout(resolve, retryDelay(attempt)));
                 if (!current())
                     throw error;

package/dist/app-git.js

@@ -0,0 +1,64 @@
+import { extname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { run } from './git.js';
+import { kitHome, readOwnAgent } from './home.js';
+import { quoted } from './shell.js';
+function section(house) {
+    return `credential.${new URL('/app/', house).href}`;
+}
+function helper() {
+    const main = fileURLToPath(new URL(`./kit-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
+    return `!HOUSE_KIT_HOME=${quoted(resolve(kitHome()))} ${quoted(process.execPath)} ${quoted(main)} git-credential`;
+}
+async function configured(args) {
+    try {
+        return await run(kitHome(), ['config', '--global', ...args]);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+async function forget(house) {
+    await configured(['--remove-section', section(house)]);
+}
+async function register(house) {
+    await forget(house);
+    for (const value of ['', helper()]) {
+        const ran = await configured(['--add', `${section(house)}.helper`, value]);
+        if (ran === null)
+            return;
+        if (ran.status !== 0)
+            throw new Error(`git config failed: ${ran.stderr.trim()}`);
+    }
+}
+export async function placeAppGit(before, after) {
+    if (before !== null && before.house !== after?.house)
+        await forget(before.house);
+    if (after !== null)
+        await register(after.house);
+}
+export async function forgetAppGit() {
+    const ownAgent = await readOwnAgent();
+    if (ownAgent !== null)
+        await forget(ownAgent.house);
+}
+export async function answerGitCredential(operation) {
+    let asked = '';
+    for await (const chunk of process.stdin)
+        asked += String(chunk);
+    if (operation !== 'get')
+        return;
+    const attributes = new Map(asked
+        .split('\n')
+        .filter((line) => line.includes('='))
+        .map((line) => [line.slice(0, line.indexOf('=')), line.slice(line.indexOf('=') + 1)]));
+    const ownAgent = await readOwnAgent();
+    if (ownAgent === null)
+        return;
+    const house = new URL(ownAgent.house);
+    if (attributes.get('protocol') !== house.protocol.slice(0, -1) || attributes.get('host') !== house.host)
+        return;
+    process.stdout.write(`username=house\npassword=${ownAgent.credential}\n`);
+}

package/dist/bootstrap.json

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

package/dist/bridge.js

@@ -6,13 +6,13 @@ import { createServer, request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { delimiter, dirname, join } from 'node:path';
 import { parse } from 'yaml';
-import { HouseRefusal, retryDelay } from './api.js';
+import { finalRefusal, HouseRefusal, retryDelay, retrying } from './api.js';
 import { loginPath } from './clis.js';
 import { changedPaths, } from './copies.js';
 import { kitHome, readEnrolment } from './home.js';
 import { callHouse, mcpBody, rpc, UNREACHABLE } from './mcp.js';
 import { operationId, uuidOf } from './operation.js';
-import { refusalOf } from './refusals.js';
+import { refusalOf, retryable } from './refusals.js';
 import { relayed } from './relay.js';
 const MCP_REQUEST_BYTES = 4 * 1024 * 1024;
 const ATTACHMENTS = '/kit/attachments/upload';
@@ -40,8 +40,6 @@ function refusalIn(text, status) {
     return refusalOf(text) ?? { code: '', text: text === '' ? `House refused it with ${status}` : text, conflicts: [] };
 }
 function answered(forwarded) {
-    if (forwarded.status >= 500)
-        throw new HouseRefusal('/', forwarded.status, forwarded.text);
     if (forwarded.status !== 200)
         return { refused: refusalIn(forwarded.text, forwarded.status) };
     const answer = JSON.parse(forwarded.text);
@@ -65,8 +63,8 @@ function pendingSeconds(forwarded) {
 function resendAfter(forwarded, attempt) {
     if (forwarded === null)
         return retryDelay(attempt);
-    if (forwarded.status >= 500)
-        return refusalOf(forwarded.text) === null ? retryDelay(attempt) : null;
+    if (forwarded.status !== 200)
+        return retryable(forwarded.text) === false ? null : retryDelay(attempt);
     const seconds = pendingSeconds(forwarded);
     return seconds === null ? null : seconds * 1000;
 }
@@ -105,6 +103,7 @@ export async function openBridge(house, copies, conversationId, signal) {
             const after = resendAfter(forwarded, attempt);
             if (after === null)
                 return forwarded;
+            // A write House did not settle is sent again on the jittered curve, or after the wait House names for a pending one.
             await delay(after, undefined, { signal: closed.signal });
         }
     };
@@ -119,17 +118,26 @@ export async function openBridge(house, copies, conversationId, signal) {
         if ('refused' in prepared)
             return prepared;
         const { transfer } = parse(prepared.text);
-        const posted = await fetch(relayed(transfer.url), {
-            method: 'POST',
-            headers: { 'content-type': 'text/plain; charset=utf-8' },
-            body: Buffer.concat([Buffer.from(`${transfer.operation}\n`), bytes]),
-            signal: closed.signal,
-        });
-        const text = await posted.text();
-        if (posted.status >= 500)
-            throw new HouseRefusal('/', posted.status, text);
-        if (!posted.ok)
-            return { refused: refusalIn(text, posted.status) };
+        let text;
+        try {
+            text = await retrying(async () => {
+                const posted = await fetch(relayed(transfer.url), {
+                    method: 'POST',
+                    headers: { 'content-type': 'text/plain; charset=utf-8' },
+                    body: Buffer.concat([Buffer.from(`${transfer.operation}\n`), bytes]),
+                    signal: closed.signal,
+                });
+                const answer = await posted.text();
+                if (!posted.ok)
+                    throw new HouseRefusal('/', posted.status, answer);
+                return answer;
+            }, closed.signal);
+        }
+        catch (error) {
+            if (!finalRefusal(error))
+                throw error;
+            return { refused: refusalIn(error.text, error.status) };
+        }
         const held = JSON.parse(text).transfer;
         return { url: held.url, operation: held.operation, bytes: bytes.length, sha256 };
     };

package/dist/clis.js

@@ -105,7 +105,9 @@ const KIT_PACKAGE = JSON.parse(readFileSync(new URL('../package.json', import.me
 export const KIT_VERSION = KIT_PACKAGE.version;
 const PROXY = /^https?_proxy$/i;
 const VERSION = /\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?/;
+// An install still running after fifteen minutes is ended and reported as failed, so a hung download cannot hold its CLI's report.
 const INSTALL_MS = 15 * 60_000;
+// A login shell or a version read is ended after half a minute, so a profile that waits for input cannot stall the report.
 const READ_MS = 30_000;
 const CAUSE_CHARACTERS = 4000;
 function prefix(kind) {
@@ -133,8 +135,22 @@ export function run(command, args, timeoutMs, detached = false, signal) {
             timeout: timeoutMs,
             env: withoutProxy(),
             detached,
-            signal,
+            signal: detached ? undefined : signal,
         });
+        const stop = () => {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { }
+        };
+        if (detached && signal?.aborted)
+            stop();
+        if (detached)
+            signal?.addEventListener('abort', stop, { once: true });
+        const ended = (ran) => {
+            signal?.removeEventListener('abort', stop);
+            resolve(ran);
+        };
         let stdout = '';
         let output = '';
         child.stdout.setEncoding('utf8').on('data', (chunk) => {
@@ -144,25 +160,25 @@ export function run(command, args, timeoutMs, detached = false, signal) {
         child.stderr.setEncoding('utf8').on('data', (chunk) => {
             output += chunk;
         });
-        child.on('error', (error) => resolve({ status: null, stdout, output: error.message }));
-        child.on('close', (status) => resolve({ status, stdout, output }));
+        child.on('error', (error) => ended({ status: null, stdout, output: error.message }));
+        child.on('close', (status) => ended({ status, stdout, output }));
     });
 }
 export function failureOf(ran, program) {
     return ran.output.trim().slice(-CAUSE_CHARACTERS) || `${program} exited with ${ran.status ?? 'a signal'}`;
 }
-export async function installAdapter(kind) {
+export async function installAdapter(kind, signal) {
     const adapter = CLIS[kind].adapter;
     if (adapter === null)
         return null;
     const release = KIT_PACKAGE.peerDependencies[adapter.package];
     if ((await installedAdapter(kind)) === release)
         return null;
-    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS);
+    const ran = await run('npm', ['install', '--prefix', prefix(kind), '--no-save', '--no-audit', '--no-fund', '--omit=optional', `${adapter.package}@${release}`], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'npm');
 }
-export async function installCli(kind) {
-    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true);
+export async function installCli(kind, signal) {
+    const ran = await run('bash', ['-o', 'pipefail', '-c', CLIS[kind].install], INSTALL_MS, true, signal);
     return ran.status === 0 ? null : failureOf(ran, 'the install');
 }
 function loginShell() {
@@ -171,11 +187,11 @@ function loginShell() {
 const FOUND = 'house-kit-cli ';
 const LOOKUP = `found=$(command -v "$1") || exit 0; case $found in /*) ;; *) found=$(pwd -P)/$found ;; esac; printf "${FOUND}%s\\n" "$found"`;
 const USER_BIN = 'case ":$PATH:" in *":$HOME/.local/bin:"*) ;; *) PATH="$PATH:$HOME/.local/bin" ;; esac; export PATH';
-function inLoginShell(script, argument = '') {
-    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true);
+function inLoginShell(script, argument = '', signal) {
+    return run(loginShell(), ['-l', '-i', '-c', `exec /bin/sh -c '${USER_BIN}; ${script}' sh ${argument}`], READ_MS, true, signal);
 }
-export async function locate(kind) {
-    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin);
+export async function locate(kind, signal) {
+    const ran = await inLoginShell(LOOKUP, CLIS[kind].bin, signal);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(FOUND))?.slice(FOUND.length) ?? null;
 }
 export async function loginPath() {
@@ -183,8 +199,8 @@ export async function loginPath() {
     const ran = await inLoginShell(`printf "${marker}%s\\n" "$PATH"`);
     return ran.stdout.split('\n').findLast((line) => line.startsWith(marker)).slice(marker.length);
 }
-export async function versionOf(path) {
-    return VERSION.exec((await run(path, ['--version'], READ_MS)).stdout)?.[0] ?? null;
+export async function versionOf(path, signal) {
+    return VERSION.exec((await run(path, ['--version'], READ_MS, false, signal)).stdout)?.[0] ?? null;
 }
 function numbers(version) {
     return version.split(/[.-]/, 3).map(Number);

package/dist/conversations.js

@@ -209,7 +209,7 @@ export class Conversations {
                 continue;
             try {
                 const text = await transcribe(path, AbortSignal.any([conversation.killed.signal, conversation.interrupted.signal]));
-                if (text !== '')
+                if (text !== null && text !== '')
                     lines.push(`Transcript: ${text}`);
             }
             catch (error) {
@@ -392,10 +392,8 @@ export class Conversations {
         turn.admitted = true;
         for (const note of turn.notes.splice(0))
             this.kit.send(note);
-        if (turn.text !== '') {
-            turn.unsentFrom = 0;
-            this.draft(conversation, turn);
-        }
+        turn.unsentFrom = 0;
+        this.draft(conversation, turn);
         if (turn.entries !== null)
             this.plan(conversation, turn);
     }
@@ -445,8 +443,11 @@ export class Conversations {
             this.attach(conversation.turn ?? this.begin(conversation), sent);
         }
         running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then(() => this.answered(conversation, sent, null), async (error) => {
-            if (!running.adapter.connection.signal.aborted)
+            if (!running.adapter.connection.signal.aborted) {
                 this.answered(conversation, sent, causeOf(error));
+                if (conversation.open === 0 && conversation.running === running)
+                    stop(running.bridge);
+            }
             else if (sent.turn !== null) {
                 this.end(conversation, sent.turn, { failed: running.killed ? KILLED : await running.adapter.exited });
             }

package/dist/copies.js

@@ -2,7 +2,7 @@ import { parse } from '@agentshouse/mdmodel';
 import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { HouseRefusal } from './api.js';
+import { finalRefusal, HouseRefusal, retrying } from './api.js';
 import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
@@ -11,7 +11,6 @@ import { changed } from './translate.js';
 import { relayed } from './relay.js';
 const BRANCH = 'main';
 const PROVENANCE = '_provenance';
-const REPLICA_RETRY_MS = 30_000;
 const IDENTITY = { GIT_COMMITTER_NAME: 'House Kit', GIT_COMMITTER_EMAIL: 'house-kit@localhost' };
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -161,11 +160,11 @@ export class LocalCopies {
             key: 'owner',
             submit: async (operation, changes) => {
                 try {
-                    const outcome = await house.post('/kit/door/batch', { operation_id: operation, changes });
+                    const outcome = await retrying(() => house.post('/kit/door/batch', { operation_id: operation, changes }));
                     return { accepted: outcome.contents };
                 }
                 catch (error) {
-                    if (!(error instanceof HouseRefusal) || error.status >= 500)
+                    if (!finalRefusal(error))
                         throw error;
                     return {
                         refused: refusalOf(error.text) ?? { code: '', text: `House refused it with ${error.status}`, conflicts: [] },
@@ -439,7 +438,6 @@ export class LocalCopies {
                     return this.received(copy);
                 if (code !== 'replica_behind')
                     throw error;
-                setTimeout(() => this.deliver(copy.key), REPLICA_RETRY_MS).unref();
                 return copy;
             }
             const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);

package/dist/end.js

@@ -0,0 +1,8 @@
+import { killDescendants } from './acp.js';
+export const REPLACED = 'another Kit started for this Environment';
+export const SIGN_IN_AGAIN = 'sign in again';
+export function end(reason) {
+    process.stderr.write(`kit: ${reason}\n`);
+    killDescendants();
+    process.exit(0);
+}

package/dist/kit-main.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { setGlobalProxyFromEnv } from 'node:http';
+import { answerGitCredential } from './app-git.js';
 import { login } from './login.js';
 import { logout } from './logout.js';
 import { resident } from './resident.js';
@@ -12,6 +13,8 @@ async function run() {
         return logout();
     if (command === 'resident')
         return resident();
+    if (command === 'git-credential')
+        return answerGitCredential(argv[0]);
     process.stderr.write('usage: kit <login|logout|resident>\n');
     process.exitCode = 2;
 }

package/dist/login.js

@@ -4,6 +4,7 @@ import { hostname } from 'node:os';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
 import { post } from './api.js';
+import { placeAppGit } from './app-git.js';
 import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
 import { callHouse, rpc } from './mcp.js';
 const DEFAULT_HOUSE = 'https://agents.house';
@@ -104,6 +105,7 @@ export async function login(argv) {
             process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
         }
     };
+    const placeGit = async () => placeAppGit(ownAgent, await readOwnAgent());
     if (values.manual) {
         const { start_url } = await post(house, '/kit', {
             ...started,
@@ -111,6 +113,7 @@ export async function login(argv) {
         });
         process.stdout.write(`Open this link and confirm: ${start_url}\n`);
         await exchange(await typed('Code: '));
+        await placeGit();
         return;
     }
     const callback = await listen();
@@ -133,4 +136,5 @@ export async function login(argv) {
     finally {
         callback.close();
     }
+    await placeGit();
 }

package/dist/logout.js

@@ -1,8 +1,10 @@
 import { HouseRefusal, post } from './api.js';
+import { forgetAppGit } from './app-git.js';
 import { forgetEnrolment, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
     if (enrolled === null) {
+        await forgetAppGit();
         process.stdout.write('This computer is not connected to House.\n');
         return;
     }
@@ -14,5 +16,6 @@ export async function logout() {
             throw error;
     }
     await forgetEnrolment(enrolled);
+    await forgetAppGit();
     process.stdout.write(`Environment ${enrolled.environment} is disconnected; kit login reconnects it.\n`);
 }

package/dist/refusals.js

@@ -21,6 +21,18 @@ function spoken(text) {
     const detail = said.indexOf('\n');
     return { code: head[1], text: said, conflicts: detail === -1 ? [] : conflictCodes(said.slice(detail + 1)) };
 }
+export function retryable(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    const error = body?.error;
+    const verdict = error?.retryable ?? error?.data?.retryable;
+    return typeof verdict === 'boolean' ? verdict : null;
+}
 export function refusalOf(text) {
     let body;
     try {

package/dist/resident.js

@@ -11,6 +11,7 @@ import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { agentBase, enrolled, kitHome } from './home.js';
+import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
 import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
@@ -21,9 +22,6 @@ function report(error) {
 function logged(work) {
     work.catch(report);
 }
-function quoted(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
 async function installShim() {
     const main = fileURLToPath(new URL(`./git-main${extname(fileURLToPath(import.meta.url))}`, import.meta.url));
     await mkdir(join(kitHome(), 'shim'), { recursive: true });

package/dist/secret-input.js

@@ -1,4 +1,4 @@
-import { retryDelay } from './api.js';
+import { finalRefusal, retryDelay } from './api.js';
 export async function holdSecretInput(house, subject, steps, waiting) {
     for (let failures = 0; waiting();) {
         try {
@@ -10,7 +10,10 @@ export async function holdSecretInput(house, subject, steps, waiting) {
             failures = 0;
         }
         catch (error) {
+            if (finalRefusal(error))
+                return null;
             process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+            // A wait that did not reach House is held again on the jittered curve for as long as its asker still waits.
             await new Promise((resolve) => setTimeout(resolve, retryDelay(failures++)));
         }
     }

package/dist/shell.js

@@ -0,0 +1,3 @@
+export function quoted(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}

package/dist/sign-in.js

@@ -12,6 +12,9 @@ function causeOf(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;
@@ -30,24 +33,43 @@ export class SignIns {
             return;
         this.running.add(input.input_id);
         this.changed();
-        this.login(input)
-            .then(() => this.agents.reread(input.cli))
-            .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
+        this.signIn(input)
             .catch(logged)
             .finally(() => {
             this.running.delete(input.input_id);
             this.changed();
         });
     }
-    async login(input) {
+    async signIn(input) {
+        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)]);
+        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);
+    }
+    async signedIn(input, signal) {
+        await this.login(input, signal);
+        if (!signal.aborted)
+            await this.agents.recheck(input.cli, signal);
+        return false;
+    }
+    async login(input, signal) {
         let cli;
         try {
-            cli = await this.agents.located(input.cli);
+            cli = await this.agents.located(input.cli, signal);
         }
         catch (error) {
-            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            if (!signal.aborted)
+                process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
             return;
         }
+        if (signal.aborted)
+            return;
         const login = CLIS[input.cli].login;
         const child = spawn(cli, login.args, {
             stdio: ['pipe', 'pipe', 'pipe'],
@@ -55,6 +77,8 @@ export class SignIns {
             env: withoutProxy(),
         });
         const running = () => child.exitCode === null && child.signalCode === null;
+        const stop = () => killTree(child);
+        signal.addEventListener('abort', stop, { once: true });
         let link;
         let code;
         let last = '';
@@ -91,9 +115,10 @@ export class SignIns {
             createInterface({ input: output }).on('line', read);
         const failed = await new Promise((resolve) => {
             child.on('error', (error) => resolve(error.message));
-            child.on('close', (status, signal) => resolve(status === 0 ? null : `exited with ${status ?? signal}${last ? `: ${last}` : ''}`));
+            child.on('close', (status, killed) => resolve(status === 0 ? null : `exited with ${status ?? killed}${last ? `: ${last}` : ''}`));
         });
-        if (failed !== null)
+        signal.removeEventListener('abort', stop);
+        if (failed !== null && !signal.aborted)
             process.stderr.write(`kit: the ${input.cli} sign-in failed: ${failed}\n`);
     }
 }

package/dist/stream.js

@@ -1,17 +1,36 @@
-import { retryDelay } from './api.js';
+import { subscribe } from 'node:diagnostics_channel';
+import { finalRefusal, HouseRefusal, retryDelay } from './api.js';
+import { end, REPLACED, SIGN_IN_AGAIN } from './end.js';
 import { readEnrolment } from './home.js';
 import { relayed } from './relay.js';
+const PATH = '/kit/stream';
 const SUBPROTOCOL = 'house.kit.stream.1';
+const REFUSAL_HEADER = 'x-house-refusal';
 function streamUrl(house) {
-    const url = new URL('/kit/stream', house);
+    const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url;
 }
+function header(headers, name) {
+    for (let index = 0; index < headers.length; index += 2) {
+        if (headers[index].toString('latin1').toLowerCase() === name)
+            return headers[index + 1].toString('latin1');
+    }
+    return '';
+}
+let refused = null;
+subscribe('undici:request:headers', (message) => {
+    const { request, response } = message;
+    if (!request.path.endsWith(PATH))
+        return;
+    refused = new HouseRefusal(PATH, response.statusCode, header(response.headers, REFUSAL_HEADER) || response.statusText);
+});
 export function holdStream(handlers) {
     let socket = null;
     let failures = 0;
     const connect = async () => {
         const { house, credential } = (await readEnrolment());
+        refused = null;
         const opening = new WebSocket(relayed(streamUrl(house)), {
             protocols: [SUBPROTOCOL],
             headers: { authorization: `Bearer ${credential}` },
@@ -31,8 +50,14 @@ export function holdStream(handlers) {
             if (socket === opening)
                 socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            const delay = opened ? 1000 + Math.random() * 2000 : retryDelay(failures++);
-            setTimeout(() => void connect(), delay);
+            if (event.reason === 'replaced')
+                end(REPLACED);
+            if (event.reason === 'credential_rejected' || refused?.status === 401)
+                end(SIGN_IN_AGAIN);
+            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.
+            setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
     };
     void connect();

package/dist/transcription.js

@@ -29,6 +29,10 @@ export const ENGINES = {
 };
 const CHUNK_SECONDS = 20;
 let held = Promise.resolve();
+let holding = Promise.resolve();
+let setting = null;
+let downloading = null;
+let readiness = { installed: false, failure: null };
 function directory() {
     return join(kitHome(), 'transcription');
 }
@@ -36,6 +40,7 @@ function installed(artifact) {
     return join(directory(), artifact.sha256);
 }
 async function executed(command, args, signal) {
+    // A download or a transcription runs as long as its size needs; the setting turning off or the turn's interrupt or end aborts it instead.
     const ran = await run(command, args, 0, false, signal);
     if (ran.status !== 0)
         throw new Error(failureOf(ran, basename(command)));
@@ -54,6 +59,12 @@ async function sha256(path) {
     await pipeline(createReadStream(path), hash);
     return hash.digest('hex');
 }
+function causeOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function pinnedHere() {
+    return ENGINES[`${process.platform}-${process.arch}`];
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -68,6 +79,7 @@ async function install(artifacts, signal) {
     try {
         for (const artifact of missing) {
             const part = `${installed(artifact)}.part`;
+            // Three retries carry a large download past a dropped connection before the download fails.
             await executed('curl', ['-fsSL', '--retry', '3', '-o', part, artifact.url], signal);
             if ((await sha256(part)) !== artifact.sha256)
                 throw new Error(`${artifact.url} does not match its sha256`);
@@ -83,12 +95,46 @@ async function install(artifacts, signal) {
             await rm(`${installed(artifact)}.part`, { force: true });
     }
 }
+function reported(next) {
+    const changed = next.installed !== readiness.installed || next.failure !== readiness.failure;
+    readiness = next;
+    return changed;
+}
+async function settle(transcribe) {
+    if (transcribe === setting)
+        return false;
+    setting = transcribe;
+    if (!transcribe) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: null });
+    }
+    const download = new AbortController();
+    downloading = download;
+    try {
+        const pinned = pinnedHere();
+        await install([pinned.decoder, pinned.engine, MODEL], download.signal);
+        return reported({ installed: true, failure: null });
+    }
+    catch (error) {
+        await rm(directory(), { recursive: true, force: true });
+        return reported({ installed: false, failure: download.signal.aborted ? null : causeOf(error) });
+    }
+    finally {
+        downloading = null;
+    }
+}
+export function holdTranscription(transcribe) {
+    if (!transcribe)
+        downloading?.abort();
+    const settled = holding.then(() => settle(transcribe));
+    holding = settled.catch(() => undefined);
+    return settled;
+}
+export function transcriptionReport() {
+    return readiness;
+}
 async function transcribed(path, signal) {
-    const platform = `${process.platform}-${process.arch}`;
-    const pinned = ENGINES[platform];
-    if (pinned === undefined)
-        throw new Error(`no transcription engine is pinned for ${platform}`);
-    await install([pinned.decoder, pinned.engine, MODEL], 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',
@@ -106,6 +152,8 @@ async function transcribed(path, signal) {
     }
 }
 export async function transcribe(path, signal) {
+    if (!readiness.installed)
+        return null;
     const before = held;
     let release;
     const mine = new Promise((resolve) => {
@@ -114,7 +162,7 @@ export async function transcribe(path, signal) {
     held = Promise.all([before, mine]);
     try {
         await unlessAborted(before, signal);
-        return await transcribed(path, signal);
+        return readiness.installed ? await transcribed(path, signal) : null;
     }
     finally {
         release();

package/dist/update.js

@@ -40,9 +40,11 @@ async function finished(inputId) {
         const ack = await recorded();
         if (ack !== null)
             return ack;
+        // systemctl answers at once, so ten seconds only bounds a stuck service manager.
         if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 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));
     }
 }

package/package.json

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