@agentshouse/kit 0.2.1-c5987c9cb6553 → 0.2.1-c59ffcda991c1

package/dist/kit-main.js

@@ -1,69 +1,10 @@
 #!/usr/bin/env node
-import { setGlobalProxyFromEnv } from 'node:http';
-import { parseArgs } from 'node:util';
-import { answerGitCredential } from './app-git.js';
-import { chatgpt } from './chatgpt.js';
-import { login } from './login.js';
-import { logout } from './logout.js';
-import { resident } from './resident.js';
-const USAGE = 'usage: kit <login|logout|resident|chatgpt>\n';
-const COMMANDS = new Map([
-    [
-        'logout',
-        {
-            usage: 'usage: kit logout',
-            about: "disconnects this computer, stops House Kit and ends your own agent's connection",
-            operands: 0,
-            run: logout,
-        },
-    ],
-    [
-        'resident',
-        {
-            usage: 'usage: kit resident',
-            about: "keeps this Environment connected; House Kit's service runs it",
-            operands: 0,
-            run: resident,
-        },
-    ],
-    [
-        'git-credential',
-        {
-            usage: 'usage: kit git-credential <get|store|erase>',
-            about: "answers git with your own agent's House credential; git runs it",
-            operands: 1,
-            run: ([operation]) => answerGitCredential(operation),
-        },
-    ],
-]);
-const [command, ...argv] = process.argv.slice(2);
-setGlobalProxyFromEnv();
-async function run() {
-    if (command === 'login')
-        return login(argv);
-    if (command === 'chatgpt')
-        return chatgpt(argv);
-    if (command === '--help') {
-        parseArgs({ args: argv });
-        process.stdout.write(USAGE);
-        return;
-    }
-    const chosen = COMMANDS.get(command ?? '');
-    if (chosen === undefined) {
-        process.stderr.write(USAGE);
-        process.exitCode = 2;
-        return;
-    }
-    const { values, positionals } = parseArgs({ args: argv, options: { help: { type: 'boolean', default: false } }, allowPositionals: true });
-    if (positionals.length > chosen.operands)
-        throw new Error(`unexpected argument ${positionals[chosen.operands]}; ${chosen.usage}`);
-    if (values.help) {
-        process.stdout.write(`${chosen.usage}\n  ${chosen.about}\n`);
-        return;
-    }
-    return chosen.run(positionals);
-}
-run().catch((error) => {
-    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
+if (major < 24 || (major === 24 && minor < 14)) {
+    process.stderr.write(`kit: the Kit needs Node 24.14.0 or newer; this is ${process.versions.node}\n`);
     process.exitCode = 1;
-});
+}
+else {
+    await import('./kit-cli.js');
+}
+export {};

package/dist/login.js

@@ -2,11 +2,12 @@ import { spawn } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { hostname } from 'node:os';
 import { parseArgs } from 'node:util';
-import { post, retrying } from './api.js';
+import { HouseRefusal, post, retrying } from './api.js';
 import { placeAppGit } from './app-git.js';
 import { writeCodexRule } from './clis.js';
-import { forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent } from './home.js';
+import { forgetDisconnected, forgetOwnAgent, readDisconnected, readEnrolment, readOwnAgent, writeEnrolment, writeOwnAgent, } from './home.js';
 import { callHouse, rpc } from './mcp.js';
+import { refusalOf } from './refusals.js';
 import { selectRelay } from './relay.js';
 import { startService } from './service.js';
 import { placeSkillSet } from './skills.js';
@@ -35,6 +36,16 @@ const USAGE = `usage: kit login [--house <origin>] [--environment <id>] [--rooms
   --no-private              give this Environment every Room but your Private Room
   --code <code>             connect this machine with a login code
 `;
+function connected(house, named, environment) {
+    if (named === undefined)
+        return `Environment ${environment} is connected to ${house}.\n`;
+    if (named === environment)
+        return `Environment ${environment} is reconnected to ${house}.\n`;
+    return `Environment ${named} stays with its account; this computer is connected to ${house} as new Environment ${environment} of the account that confirmed.\n`;
+}
+function gone(error) {
+    return error instanceof HouseRefusal && refusalOf(error.text)?.code === 'kit_environment_not_found';
+}
 function chosenRooms(rooms, noPrivate) {
     if (rooms !== undefined && noPrivate)
         throw new Error('--rooms and --no-private are two choices of Rooms; pass one');
@@ -73,9 +84,11 @@ export async function login(argv) {
     selectRelay(relay);
     const house = values.house ?? enrolled?.house ?? DEFAULT_HOUSE;
     const replaces = process.env.HOUSE_KIT_REPLACES;
-    const environment = replaces === undefined ? (values.environment ?? (enrolled?.house === house ? enrolled.environment : undefined)) : undefined;
+    const remembered = replaces === undefined && values.environment === undefined && enrolled?.house === house ? enrolled.environment : undefined;
+    const environment = replaces === undefined ? (values.environment ?? remembered) : undefined;
     const ownAgent = await readOwnAgent();
     let held = false;
+    let named = environment;
     let exchanged;
     if (values.code !== undefined) {
         exchanged = await post(house, '/kit/token', { code: values.code, label: hostname() });
@@ -83,41 +96,52 @@ export async function login(argv) {
     else {
         held = ownAgent !== null && ownAgent.house === house && (await accepted(house, ownAgent.credential));
         const verifier = randomBytes(32).toString('base64url');
-        const started = await retrying(() => post(house, '/kit', {
+        const start = () => retrying(() => post(house, '/kit', {
             label: hostname(),
-            ...(environment === undefined
+            ...(named === undefined
                 ? { act: 'new_environment', ...(replaces === undefined ? {} : { replaces }) }
-                : { act: 'existing_environment', environment_id: environment }),
+                : { act: 'existing_environment', environment_id: named }),
             ...rooms,
             code_challenge: createHash('sha256').update(verifier).digest('base64url'),
             ...(held ? {} : { headless: true }),
         }));
+        let started;
+        try {
+            started = await start();
+        }
+        catch (error) {
+            if (remembered === undefined || !gone(error))
+                throw error;
+            await forgetDisconnected();
+            process.stdout.write(`House no longer holds Environment ${remembered}; connecting this computer as a new one.\n`);
+            named = undefined;
+            started = await start();
+        }
         process.stdout.write(`Open this link and confirm: ${started.start_url}\n`);
         open(started.start_url);
         exchanged = await retrying(() => post(house, '/kit/token', { login: started.login, code_verifier: verifier }), undefined, () => POLL_INTERVAL_MS);
     }
-    try {
-        await placeSkillSet();
-    }
-    catch (error) {
-        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
-    }
+    await placeSkillSet();
     await writeCodexRule().catch((error) => process.stderr.write(`kit: ${error.message}\n`));
+    const relayRecord = relay === undefined ? {} : { relay };
     await writeEnrolment({
         house,
-        ...(relay === undefined ? {} : { relay }),
+        ...relayRecord,
         environment: exchanged.environment,
         credential: exchanged.credential,
     });
-    process.stdout.write(`Environment ${exchanged.environment} is connected to ${house}.\n`);
+    process.stdout.write(connected(house, named, exchanged.environment));
     if (exchanged.headless_credential !== undefined) {
-        await writeOwnAgent({ house, user: exchanged.user, credential: exchanged.headless_credential });
+        await writeOwnAgent({ house, ...relayRecord, user: exchanged.user, credential: exchanged.headless_credential });
     }
     else if (held && ownAgent !== null && ownAgent.user !== exchanged.user) {
         await forgetOwnAgent();
         process.stdout.write("This computer's own agent was another User's; run kit login again to connect it to you.\n");
     }
-    await placeAppGit(ownAgent, await readOwnAgent());
+    else if (held && ownAgent !== null) {
+        await writeOwnAgent({ house, ...relayRecord, user: ownAgent.user, credential: ownAgent.credential });
+    }
+    await placeAppGit(await readOwnAgent()).catch((error) => process.stderr.write(`kit: ${error.message}\n`));
     try {
         startService();
     }

package/dist/logout.js

@@ -1,5 +1,4 @@
 import { HouseRefusal, post } from './api.js';
-import { forgetAppGit } from './app-git.js';
 import { forgetEnrolment, forgetOwnAgent, readEnrolment } from './home.js';
 export async function logout() {
     const enrolled = await readEnrolment();
@@ -13,7 +12,6 @@ export async function logout() {
         }
         await forgetEnrolment(enrolled);
     }
-    await forgetAppGit();
     await forgetOwnAgent();
     process.stdout.write(enrolled === null
         ? 'This computer is not connected to House.\n'

package/dist/placement.js

@@ -2,7 +2,6 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { run } from './clis.js';
 import { kitHome } from './home.js';
-import { relayOrigin } from './relay.js';
 export function service() {
     if (process.platform !== 'linux' || !process.env.INVOCATION_ID)
         return null;
@@ -19,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;
 }
-function installed() {
+export function installCommand() {
     try {
-        return readFileSync(join(kitHome(), 'placement'), 'utf8').trim();
+        return readFileSync(join(kitHome(), 'install-command'), 'utf8').trim();
     }
     catch (error) {
         if (error.code === 'ENOENT')
@@ -29,20 +28,3 @@ function installed() {
         throw error;
     }
 }
-function entries(house) {
-    const host = new URL(house).host;
-    const relay = relayOrigin();
-    if (relay === undefined)
-        return [`curl -fsSL ${host}/kit | sh`, `irm ${host}/kit.ps1 | iex`];
-    const entry = `${relay}/${host}/kit`;
-    return [`curl -fsSL ${entry} | HOUSE_KIT_RELAY=${relay} sh`, `$env:HOUSE_KIT_RELAY='${relay}'; irm ${entry}.ps1 | iex`];
-}
-export function installCommand(house) {
-    const [shell, windows] = entries(house);
-    const placement = installed();
-    if (placement === 'native')
-        return shell;
-    if (placement === 'server')
-        return `${shell} -s -- --linux`;
-    return `${shell} -s -- --container, or ${windows} on Windows`;
-}

package/dist/resident.js

@@ -1,8 +1,9 @@
 import { once } from 'node:events';
 import { watch } from 'node:fs';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
-import { createServer } from 'node:http';
+import { createServer, get } from 'node:http';
 import { dirname, extname, join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import { fileURLToPath } from 'node:url';
 import { Agents } from './agents.js';
 import { house } from './api.js';
@@ -10,7 +11,7 @@ import { received } from './bridge.js';
 import { CONVERSATION_INPUTS, Conversations } from './conversations.js';
 import { LocalCopies } from './copies.js';
 import { restart } from './end.js';
-import { agentBase, enrolled, forgetRestart, kitHome, restartAsked } from './home.js';
+import { agentBase, enrolled, forgetRestart, kitHome, ownerLock, ownerSocket, restartAsked } from './home.js';
 import { killDescendants } from './scope.js';
 import { quoted } from './shell.js';
 import { SignIns } from './sign-in.js';
@@ -29,13 +30,32 @@ async function installShim(path, module) {
     await mkdir(dirname(path), { recursive: true });
     await writeFile(path, `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, { mode: 0o755 });
 }
+function claimed(lock) {
+    try {
+        lock.exec('BEGIN EXCLUSIVE');
+        return true;
+    }
+    catch (error) {
+        if (error.errcode === 5)
+            return false;
+        throw error;
+    }
+}
 async function serveOwner(copies) {
-    const socketPath = join(kitHome(), 'owner.sock');
-    await rm(socketPath, { force: true });
+    const lock = new DatabaseSync(ownerLock());
+    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`);
+    }
     const server = createServer(async (request, response) => {
         try {
             const text = await received(request);
             let answered;
+            if (request.url === '/resident') {
+                response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ pid: process.pid }));
+                return;
+            }
             if (request.url === '/git/fetch') {
                 answered = await copies.fetch();
             }
@@ -53,9 +73,23 @@ async function serveOwner(copies) {
             response.writeHead(502).end(error instanceof Error ? error.message : String(error));
         }
     });
-    server.listen(socketPath);
+    server.on('close', () => lock.close());
+    await rm(ownerSocket(), { force: true });
+    server.listen(ownerSocket());
     await once(server, 'listening');
 }
+function runningResident() {
+    return new Promise((resolve, reject) => {
+        get({ socketPath: ownerSocket(), path: '/resident' }, (answer) => {
+            received(answer).then((text) => resolve(JSON.parse(text).pid), reject);
+        }).on('error', (error) => {
+            if (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')
+                resolve(null);
+            else
+                reject(error);
+        });
+    });
+}
 function connected() {
     return new Promise((resolve) => {
         const watcher = watch(kitHome(), () => {
@@ -72,7 +106,7 @@ function connected() {
         resolve();
     });
 }
-export async function resident() {
+async function started() {
     await connected();
     await forgetRestart();
     watch(kitHome(), () => {
@@ -83,13 +117,20 @@ export async function resident() {
     });
     await placeSkillSet();
     await mkdir(agentBase(), { recursive: true });
-    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
-    const agents = new Agents(house, () => changed());
-    const copies = new LocalCopies(house);
-    await copies.load();
     await installShim(join(kitHome(), 'shim', 'git'), 'git-main');
     await installShim(codexLauncher(), 'codex-main');
+}
+export async function resident() {
+    await mkdir(kitHome(), { recursive: true, mode: 0o700 });
+    const copies = new LocalCopies(house);
+    await copies.load();
     await serveOwner(copies);
+    await started().catch((error) => {
+        report(error);
+        process.exit(1);
+    });
+    process.env.HOUSE_KIT_RESIDENT = String(process.pid);
+    const agents = new Agents(house, () => changed());
     let stream = null;
     let reported = false;
     const idle = () => conversations.idle() && signIns.idle() && agents.idle();
@@ -132,6 +173,8 @@ export async function resident() {
         frame: (arrived) => {
             if (arrived.type === 'watching')
                 conversations.watching(arrived.watching === true);
+            if (arrived.type === 'authority_changed')
+                logged(copies.connected());
             if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
             if (arrived.type === 'input') {

package/dist/skills.js

@@ -1,17 +1,31 @@
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, lstat, mkdir, readdir, realpath, rm, symlink } from 'node:fs/promises';
 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 { kitHome, readConfiguration, readHome, writeHome } from './home.js';
 import { refusalOf } from './refusals.js';
-export const HOW_WE_WORK = '/rooms/private/how-we-work.md';
+const HOW_WE_WORK = '/rooms/private/how-we-work.md';
 const SKILL_SET = fileURLToPath(new URL('../skills/', import.meta.url));
 const HOW_WE_WORK_TEXT = readFileSync(new URL('../how-we-work.md', import.meta.url), 'utf8');
+const SHIPPED_HOW_WE_WORK = [
+    'ae4dda60da7b174f22dc5fa9bf07fc27c25864932a74230de4f9f509ddd91f41',
+    '0bdcd43e1603ba6673a3cae56d70bbf90657cbeefd124e91a47be2ca1cbd6c93',
+    '4106a87ec66da6f7b2a10e74d18e6559d68d5f4fe7415dae68f5c7bdb9081968',
+    'ac814a2197038f037b657bb719340395f89f319ac9fcdd386629c3fe2cec68f1',
+    '29951ee394aad9979eecfed3e5dc32c2c86e2226b6a380db5dbd4f305f4d1156',
+];
 const RECORD = 'skill-set.json';
-const CREATED = 'how-we-work-created';
+const WRITTEN = 'how-we-work.json';
 const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
+const PRESENT = new Set(['path_exists']);
+const CHANGED = new Set(['base_revision_stale', 'path_absent']);
+const UNREADABLE = /^(?:\S+: )?(?:path_not_found|room_not_found|operation_denied)\b/;
+const FAILED = /^exit: [1-9]\d*$/;
+const CUT = /^stderr: shell: output_cut (\d+) of \d+ bytes; continue with: (.+)$/;
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -49,6 +63,14 @@ async function install() {
     await writeHome(RECORD, { version: KIT_VERSION, names });
 }
 export async function placeSkillSet() {
+    try {
+        await replaceSkillSet();
+    }
+    catch (error) {
+        process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
+    }
+}
+async function replaceSkillSet() {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
     if (accepted && installed?.version === KIT_VERSION)
@@ -62,17 +84,64 @@ export async function placeSkillSet() {
     else
         await rm(join(kitHome(), RECORD), { force: true });
 }
+function sha256(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+function cutOf(lines) {
+    const cut = CUT.exec(lines[0] ?? '');
+    return cut !== null && Buffer.byteLength(lines.slice(1).join('\n')) === Number(cut[1]) ? cut : null;
+}
+export async function readHowWeWork(bridge) {
+    let document = '';
+    for (let command = `cat ${HOW_WE_WORK}`; command !== undefined;) {
+        const read = await bridge.tool('shell', { command });
+        const text = read.content.map((content) => content.text).join('\n');
+        const lines = text.split('\n');
+        if (read.isError === true || (FAILED.test(lines[0] ?? '') && lines[1]?.startsWith('stderr: '))) {
+            const refusal = read.isError === true ? text : lines.slice(1).join('\n').replace(/^stderr: /gm, '');
+            if (UNREADABLE.test(refusal))
+                return '';
+            throw new Error(refusal);
+        }
+        const cut = cutOf(lines);
+        document += lines.slice(cut === null ? 0 : 1).join('\n');
+        command = cut?.[2];
+    }
+    return document;
+}
+async function currentRevision(bridge) {
+    const inspected = await bridge.tool('inspect', { path: HOW_WE_WORK });
+    const text = inspected.content.map((content) => content.text).join('\n');
+    if (inspected.isError === true)
+        throw new Error(text);
+    return parse(text).revisions[0].revision;
+}
+async function edit(bridge, change, kept) {
+    const edited = await bridge.tool('edit', { changes: [{ ...change, path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
+    if (edited.isError !== true)
+        return 'written';
+    const text = edited.content.map((content) => content.text).join('\n');
+    const refusal = refusalOf(text);
+    if (UNWRITABLE.has(refusal?.code ?? ''))
+        return 'unwritable';
+    if (refusal?.code === 'edit_conflict' && refusal.conflicts.some((conflict) => kept.has(conflict)))
+        return 'kept';
+    throw new Error(text);
+}
 export async function createHowWeWork(bridge) {
-    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
+    if (!(await readConfiguration()).skills || (await readHome(RECORD))?.version === undefined)
+        return;
+    const current = sha256(HOW_WE_WORK_TEXT);
+    if ((await readHome(WRITTEN)) === current)
+        return;
+    const created = await edit(bridge, { op: 'create' }, PRESENT);
+    if (created === 'unwritable')
         return;
-    const created = await bridge.tool('edit', { changes: [{ op: 'create', path: HOW_WE_WORK, content: HOW_WE_WORK_TEXT }] });
-    if (created.isError === true) {
-        const text = created.content.map((content) => content.text).join('\n');
-        const refusal = refusalOf(text);
-        if (UNWRITABLE.has(refusal?.code ?? ''))
+    if (created === 'kept') {
+        const base = await currentRevision(bridge);
+        const held = sha256(await readHowWeWork(bridge));
+        if (held !== current && SHIPPED_HOW_WE_WORK.includes(held) && (await edit(bridge, { op: 'replace', base }, CHANGED)) === 'unwritable')
             return;
-        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
-            throw new Error(text);
     }
-    await writeFile(join(kitHome(), CREATED), '');
+    await writeHome(WRITTEN, current);
 }

package/dist/stream.js

@@ -7,6 +7,36 @@ import { KIT_WIRE, tooOld } from './wire.js';
 const PATH = '/kit/stream';
 const SUBPROTOCOL = `house.kit.stream.${KIT_WIRE}`;
 const REFUSAL_HEADER = 'x-house-refusal';
+// House beats each stream every thirty seconds, so two silent beats mean this Kit cannot hear House.
+export const STREAM_SILENCE_MS = 60_000;
+const SYSTEM_STREAM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class StreamSilence {
+    timer = null;
+    silent;
+    clock;
+    interval;
+    constructor(silent, clock = SYSTEM_STREAM_CLOCK, interval = STREAM_SILENCE_MS) {
+        this.silent = silent;
+        this.clock = clock;
+        this.interval = interval;
+    }
+    heard() {
+        this.stop();
+        this.timer = this.clock.later(this.interval, () => {
+            this.timer = null;
+            this.silent();
+        });
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.clock.clear(this.timer);
+        this.timer = null;
+    }
+}
 function streamUrl(house) {
     const url = new URL(PATH, house);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
@@ -37,17 +67,10 @@ export function holdStream(handlers) {
             headers: { authorization: `Bearer ${credential}` },
         });
         let opened = false;
-        opening.onopen = () => {
-            opened = true;
-            failures = 0;
-            socket = opening;
-            handlers.opened();
-        };
-        opening.onmessage = (event) => {
-            handlers.frame(JSON.parse(String(event.data)));
-        };
-        opening.onerror = () => undefined;
-        opening.onclose = (event) => {
+        let silence = null;
+        const closed = (event) => {
+            silence?.stop();
+            silence = null;
             if (socket === opening)
                 socket = null;
             process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
@@ -58,12 +81,35 @@ export function holdStream(handlers) {
                 return;
             }
             if (refused !== null && tooOld(refused.text))
-                updateRequired(house);
+                updateRequired();
             if (finalRefusal(refused))
                 end(refused.message);
             // A closed socket reopens in one to three seconds, spread so Kits one restart closed return apart; an opening House refused as retryable or left unanswered backs off on the jittered curve.
             setTimeout(() => void connect(), opened ? 1000 + Math.random() * 2000 : retryDelay(failures++));
         };
+        opening.onopen = () => {
+            opened = true;
+            failures = 0;
+            socket = opening;
+            silence = new StreamSilence(() => {
+                if (socket !== opening)
+                    return;
+                socket = null;
+                opening.onclose = null;
+                opening.close();
+                closed(new CloseEvent('close', { code: 1006, reason: 'heartbeat_missed' }));
+            });
+            silence.heard();
+            handlers.opened();
+        };
+        opening.onmessage = (event) => {
+            silence?.heard();
+            const frame = JSON.parse(String(event.data));
+            if (frame.type !== 'beat')
+                handlers.frame(frame);
+        };
+        opening.onerror = () => undefined;
+        opening.onclose = closed;
     };
     void connect();
     return {

package/dist/transcription.js

@@ -49,10 +49,10 @@ async function executed(command, args, signal) {
 function present(path) {
     return stat(path).then(() => true, () => false);
 }
-async function cpus() {
+async function threads() {
     const [quota, period] = (await readFile('/sys/fs/cgroup/cpu.max', 'utf8').catch(() => 'max')).split(' ');
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
-    return Math.min(availableParallelism(), allowed);
+    return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
 async function sha256(path) {
     const hash = createHash('sha256');
@@ -140,7 +140,7 @@ async function transcribed(path, signal) {
         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 cpus()), '-np', '-m', installed(MODEL), ...parts], signal);
+        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())

package/dist/update.js

@@ -75,6 +75,7 @@ function rerun(script, inputId, flags) {
             '--quiet',
             `--unit=${unit(inputId)}`,
             `--setenv=HOME=${homedir()}`,
+            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
             '/bin/sh',
             '-c',
             record(),

package/dist/wire.js

@@ -1,5 +1,5 @@
 import { refusalOf } from './refusals.js';
-export const KIT_WIRE = 1;
+export const KIT_WIRE = 2;
 export const KIT_WIRE_HEADER = 'x-house-kit-wire';
 export function tooOld(text) {
     return refusalOf(text)?.code === 'kit_update_required';

package/dist/work.js

@@ -1,11 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { once } from 'node:events';
 import { readFileSync } from 'node:fs';
-import { mkdir, rm } from 'node:fs/promises';
+import { rm } from 'node:fs/promises';
 import { createServer } from 'node:net';
 import { join } from 'node:path';
 import { RUNNING_JOB } from './events.js';
-import { kitHome } from './home.js';
+import { kitHome, socketDirectory } from './home.js';
 const ENDED_TASK = new Set(['completed', 'failed', 'killed']);
 const SCHEDULING = new Set(['CronCreate', 'CronDelete', 'ScheduleWakeup']);
 const QUEUE_LIST = 'house-kit-queue-';
@@ -194,9 +194,7 @@ class CodexWork extends Work {
     proving = -1;
     proven = -1;
     async open(cli) {
-        const sockets = join(kitHome(), 'bridges');
-        await mkdir(sockets, { recursive: true, mode: 0o700 });
-        this.path = join(sockets, `${randomUUID()}.sock`);
+        this.path = join(socketDirectory(), `${randomUUID()}.sock`);
         this.server = createServer((socket) => this.connected(socket));
         this.server.listen(this.path);
         await once(this.server, 'listening');