@agentshouse/kit 0.2.1-alpha.2 → 0.2.1-alpha.21

package/dist/mcp.js

@@ -0,0 +1,38 @@
+import { randomUUID } from 'node:crypto';
+import { KIT_VERSION } from './clis.js';
+const MCP_PROTOCOL_VERSION = '2026-07-28';
+export const UNREACHABLE = 'House is unreachable; call again in a minute';
+export function rpc(method, params) {
+    return { jsonrpc: '2.0', id: randomUUID(), method, params };
+}
+export function mcpBody(message, operation) {
+    return JSON.stringify({
+        ...message,
+        params: {
+            ...message.params,
+            _meta: {
+                'io.modelcontextprotocol/protocolVersion': MCP_PROTOCOL_VERSION,
+                'io.modelcontextprotocol/clientInfo': { name: '@agentshouse/kit', version: KIT_VERSION },
+                'io.modelcontextprotocol/clientCapabilities': {},
+                ...(operation === null ? {} : { 'agents.house/agent-operation': operation }),
+            },
+        },
+    });
+}
+export async function callHouse(origin, credential, message, operation = null, signal) {
+    const tool = message.method === 'tools/call' ? String(message.params.name) : null;
+    const answer = await fetch(new URL('/', origin), {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+            authorization: `Bearer ${credential}`,
+            accept: 'application/json, text/event-stream',
+            'mcp-protocol-version': MCP_PROTOCOL_VERSION,
+            'mcp-method': message.method,
+            ...(tool === null ? {} : { 'mcp-name': tool }),
+        },
+        body: mcpBody(message, operation),
+        signal,
+    });
+    return { status: answer.status, text: await answer.text() };
+}

package/dist/operation.js

@@ -0,0 +1,12 @@
+import { randomBytes } from 'node:crypto';
+export function uuidOf(bytes, version) {
+    bytes[6] = (version << 4) | (bytes[6] & 0x0f);
+    bytes[8] = 0x80 | (bytes[8] & 0x3f);
+    const hex = bytes.toString('hex', 0, 16);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+export function operationId() {
+    const bytes = randomBytes(16);
+    bytes.writeUIntBE(Date.now(), 0, 6);
+    return uuidOf(bytes, 7);
+}

package/dist/refusals.js

@@ -0,0 +1,41 @@
+import { parse } from 'yaml';
+const HEAD = /^([a-z][a-z0-9_]*): \S/;
+function conflictCodes(detail) {
+    let parsed;
+    try {
+        parsed = parse(detail);
+    }
+    catch {
+        return [];
+    }
+    const conflicts = parsed?.conflicts;
+    if (!Array.isArray(conflicts))
+        return [];
+    return conflicts.flatMap((conflict) => typeof conflict?.code === 'string' ? [conflict.code] : []);
+}
+function spoken(text) {
+    const head = HEAD.exec(text);
+    if (head === null)
+        return null;
+    const said = text.replace(/\n+$/, '');
+    const detail = said.indexOf('\n');
+    return { code: head[1], text: said, conflicts: detail === -1 ? [] : conflictCodes(said.slice(detail + 1)) };
+}
+export function refusalOf(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return spoken(text);
+    }
+    const error = body?.error;
+    if (typeof error !== 'object' || error === null)
+        return null;
+    const { code, message, data } = error;
+    const said = typeof message === 'string' ? spoken(message) : null;
+    if (said !== null)
+        return said;
+    const named = typeof code === 'string' ? code : typeof data?.code === 'string' ? data.code : null;
+    return named === null ? null : { code: named, text: named, conflicts: [] };
+}

package/dist/resident.js

@@ -1,24 +1,69 @@
+import { once } from 'node:events';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { killDescendants } from './acp.js';
 import { Agents } from './agents.js';
 import { house } from './api.js';
+import { received } from './bridge.js';
 import { Conversations } from './conversations.js';
-import { readEnrolment } from './home.js';
+import { WorkingCopies } from './copies.js';
+import { agentBase, kitHome, readEnrolment } from './home.js';
 import { SignIns } from './sign-in.js';
+import { placeSkillSet } from './skills.js';
 import { holdStream } from './stream.js';
+import { Updates } from './update.js';
 function report(error) {
     process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
 }
 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 });
+    await writeFile(join(kitHome(), 'shim', 'git'), `#!/bin/sh\nexec ${quoted(process.execPath)} ${quoted(main)} "$@"\n`, {
+        mode: 0o755,
+    });
+}
+async function serveOwner(copies) {
+    const socketPath = join(kitHome(), 'owner.sock');
+    await rm(socketPath, { force: true });
+    const server = createServer(async (request, response) => {
+        try {
+            if (request.url !== '/git/push') {
+                response.writeHead(404).end();
+                return;
+            }
+            const { cwd, commit } = JSON.parse(await received(request));
+            const pushed = await copies.push(cwd, commit, copies.owner);
+            response.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(pushed));
+        }
+        catch (error) {
+            response.writeHead(502).end(error instanceof Error ? error.message : String(error));
+        }
+    });
+    server.listen(socketPath);
+    await once(server, 'listening');
+}
 export async function resident() {
     if ((await readEnrolment()) === null) {
         process.stderr.write('kit: this Environment is not enrolled; run kit login\n');
         process.exitCode = 1;
         return;
     }
+    await placeSkillSet();
+    await mkdir(agentBase(), { recursive: true });
     process.env.HOUSE_KIT_RESIDENT = String(process.pid);
     const agents = new Agents(house);
+    const copies = new WorkingCopies(house);
+    await copies.load();
+    await installShim();
+    await serveOwner(copies);
     let stream = null;
     let reported = false;
     const idle = () => conversations.idle() && signIns.idle();
@@ -34,10 +79,12 @@ export async function resident() {
     const conversations = new Conversations({
         house,
         agents,
+        copies,
         send: (frame) => stream?.send(frame) ?? false,
         changed,
     });
     const signIns = new SignIns(house, agents, changed);
+    const updates = new Updates(house);
     for (const signal of ['SIGTERM', 'SIGINT']) {
         process.once(signal, () => {
             killDescendants();
@@ -45,21 +92,30 @@ export async function resident() {
         });
     }
     await house.deliver('/kit/restarted', {}).catch(report);
+    await updates.resumed().catch(report);
     logged(agents.refresh());
     stream = holdStream({
         opened: () => {
             conversations.opened();
             changed();
+            logged(copies.select());
         },
-        frame: (received) => {
-            if (received.type === 'work_available' && received.subject === 'agents')
+        frame: (arrived) => {
+            if (arrived.type === 'work_available' && arrived.subject === 'agents')
                 logged(agents.refresh());
-            if (received.type === 'input') {
+            if (arrived.type === 'work_available' && arrived.subject === 'working_copy')
+                logged(copies.select());
+            if (arrived.type === 'entries') {
+                copies.entries(arrived);
+            }
+            if (arrived.type === 'input') {
                 reported = false;
-                if (received.kind === 'sign_in')
-                    signIns.start(received);
+                if (arrived.kind === 'sign_in')
+                    signIns.start(arrived);
+                else if (arrived.kind === 'update')
+                    updates.start(arrived);
                 else
-                    conversations.input(received);
+                    conversations.input(arrived);
             }
         },
     });

package/dist/sign-in.js

@@ -1,13 +1,16 @@
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { killTree } from './acp.js';
-import { CLIS, cliCommand } from './clis.js';
+import { CLIS, withoutProxy } from './clis.js';
 import { holdSecretInput } from './secret-input.js';
 const ESCAPE = /\u001b\[[\d;]*m/g;
 const LINK = /https:\/\/\S+/;
 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: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
 export class SignIns {
     house;
@@ -28,7 +31,7 @@ export class SignIns {
         this.running.add(input.input_id);
         this.changed();
         this.login(input)
-            .then(() => this.agents.report())
+            .then(() => this.agents.reread(input.cli))
             .then(() => this.house.deliver(`/kit/inputs/${input.input_id}/ack`, {}))
             .catch(logged)
             .finally(() => {
@@ -37,9 +40,20 @@ export class SignIns {
         });
     }
     async login(input) {
-        await this.agents.installed();
+        let cli;
+        try {
+            cli = await this.agents.located(input.cli);
+        }
+        catch (error) {
+            process.stderr.write(`kit: the ${input.cli} sign-in failed: ${causeOf(error)}\n`);
+            return;
+        }
         const login = CLIS[input.cli].login;
-        const child = spawn(cliCommand(input.cli), login.args, { stdio: ['pipe', 'pipe', 'pipe'], detached: true });
+        const child = spawn(cli, login.args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: true,
+            env: withoutProxy(),
+        });
         const running = () => child.exitCode === null && child.signalCode === null;
         let link;
         let code;
@@ -50,6 +64,8 @@ export class SignIns {
             if (plain === '')
                 return;
             last = plain;
+            if (login.code === 'collect' && plain.includes(login.rejected))
+                killTree(child);
             link ??= LINK.exec(plain)?.[0];
             if (CODE.test(plain))
                 code ??= plain;

package/dist/skills.js

@@ -0,0 +1,78 @@
+import { readFileSync } from 'node:fs';
+import { cp, lstat, mkdir, readdir, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { KIT_VERSION } from './clis.js';
+import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
+import { refusalOf } from './refusals.js';
+export const HOW_WE_WORK = '/private/library/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 RECORD = 'skill-set.json';
+const CREATED = 'how-we-work-created';
+const UNWRITABLE = new Set(['room_not_found', 'operation_denied']);
+function skillsDirectory() {
+    return join(homedir(), '.agents', 'skills');
+}
+function claudeDirectory() {
+    return join(homedir(), '.claude', 'skills');
+}
+async function present(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+async function install() {
+    const names = [];
+    for (const name of (await readdir(SKILL_SET)).sort()) {
+        if (!(await present(join(skillsDirectory(), name))) && !(await present(join(claudeDirectory(), name)))) {
+            names.push(name);
+        }
+    }
+    await writeHome(RECORD, { names });
+    await mkdir(skillsDirectory(), { recursive: true });
+    await mkdir(claudeDirectory(), { recursive: true });
+    const skills = await realpath(skillsDirectory());
+    const claude = await realpath(claudeDirectory());
+    for (const name of names) {
+        await cp(join(SKILL_SET, name), join(skillsDirectory(), name), { recursive: true });
+        if (claude !== skills)
+            await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
+    }
+    await writeHome(RECORD, { version: KIT_VERSION, names });
+}
+export async function placeSkillSet() {
+    const accepted = (await readConfiguration()).skills;
+    const installed = await readHome(RECORD);
+    if (accepted && installed?.version === KIT_VERSION)
+        return;
+    for (const name of installed?.names ?? []) {
+        await rm(join(claudeDirectory(), name), { recursive: true, force: true });
+        await rm(join(skillsDirectory(), name), { recursive: true, force: true });
+    }
+    if (accepted)
+        await install();
+    else
+        await rm(join(kitHome(), RECORD), { force: true });
+}
+export async function createHowWeWork(bridge) {
+    if ((await readHome(RECORD)) === null || (await present(join(kitHome(), CREATED))))
+        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 ?? ''))
+            return;
+        if (refusal?.code !== 'edit_conflict' || !refusal.conflicts.includes('path_exists'))
+            throw new Error(text);
+    }
+    await writeFile(join(kitHome(), CREATED), '');
+}

package/dist/transcription.js

@@ -0,0 +1,122 @@
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { chmod, mkdir, mkdtemp, readdir, readFile, rename, rm, stat } from 'node:fs/promises';
+import { availableParallelism, tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { unlessAborted } from './abort.js';
+import { failureOf, run } from './clis.js';
+import { kitHome } from './home.js';
+const RELEASE = 'https://github.com/agentshouse/kit/releases/download/engine-2';
+export const MODEL = {
+    url: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    sha256: '8b205b8b39c6535e153de6fb11c51db46125d45c4f16ba496fe41a0fe71b885e',
+    executable: false,
+};
+export const ENGINES = {
+    'linux-x64': {
+        decoder: { url: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', executable: true },
+    },
+    'linux-arm64': {
+        decoder: { url: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', executable: true },
+    },
+    'darwin-arm64': {
+        decoder: { url: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', executable: true },
+        engine: { url: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', executable: true },
+    },
+};
+const CHUNK_SECONDS = 20;
+let held = Promise.resolve();
+function directory() {
+    return join(kitHome(), 'transcription');
+}
+function installed(artifact) {
+    return join(directory(), artifact.sha256);
+}
+async function executed(command, args, signal) {
+    const ran = await run(command, args, 0, false, signal);
+    if (ran.status !== 0)
+        throw new Error(failureOf(ran, basename(command)));
+    return ran.stdout;
+}
+function present(path) {
+    return stat(path).then(() => true, () => false);
+}
+async function cpus() {
+    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);
+}
+async function sha256(path) {
+    const hash = createHash('sha256');
+    await pipeline(createReadStream(path), hash);
+    return hash.digest('hex');
+}
+async function install(artifacts, signal) {
+    await mkdir(directory(), { recursive: true });
+    const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
+    for (const name of await readdir(directory())) {
+        if (!pinned.has(name))
+            await rm(join(directory(), name), { recursive: true, force: true });
+    }
+    const missing = [];
+    for (const artifact of artifacts)
+        if (!(await present(installed(artifact))))
+            missing.push(artifact);
+    try {
+        for (const artifact of missing) {
+            const part = `${installed(artifact)}.part`;
+            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`);
+        }
+        for (const artifact of missing) {
+            if (artifact.executable)
+                await chmod(`${installed(artifact)}.part`, 0o755);
+            await rename(`${installed(artifact)}.part`, installed(artifact));
+        }
+    }
+    finally {
+        for (const artifact of missing)
+            await rm(`${installed(artifact)}.part`, { force: true });
+    }
+}
+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 work = await mkdtemp(join(tmpdir(), 'kit-transcription-'));
+    try {
+        await executed(installed(pinned.decoder), ['-nostdin', '-hide_banner', '-loglevel', 'error', '-i', path, '-ar', '16000', '-ac', '1', '-c:a', 'pcm_s16le',
+            '-f', 'segment', '-segment_time', String(CHUNK_SECONDS), join(work, '%05d.wav')], signal);
+        const parts = (await readdir(work)).sort().flatMap((part) => ['-f', join(work, part)]);
+        const text = await executed(installed(pinned.engine), ['-t', String(await cpus()), '-np', '-m', installed(MODEL), ...parts], signal);
+        return text
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line !== '')
+            .join(' ');
+    }
+    finally {
+        await rm(work, { recursive: true, force: true });
+    }
+}
+export async function transcribe(path, signal) {
+    const before = held;
+    let release;
+    const mine = new Promise((resolve) => {
+        release = resolve;
+    });
+    held = Promise.all([before, mine]);
+    try {
+        await unlessAborted(before, signal);
+        return await transcribed(path, signal);
+    }
+    finally {
+        release();
+    }
+}

package/dist/translate.js

@@ -0,0 +1,51 @@
+import { apply, parse, serialize } from '@agentshouse/mdmodel';
+function same(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function applied(document, changes) {
+    let current = document;
+    for (const change of changes) {
+        const result = apply(current, change);
+        if (result.outcome !== 'applied')
+            return null;
+        current = result.document;
+    }
+    return serialize(current);
+}
+function components(path, before, after, text) {
+    const edits = [];
+    const changes = [];
+    if (before.preamble !== after.preamble) {
+        edits.push({ op: 'replace_preamble', path, base: before.preamble, content: after.preamble });
+        changes.push({ kind: 'preamble', value: after.preamble, prior: before.preamble });
+    }
+    for (const name of new Set([...Object.keys(before.fields), ...Object.keys(after.fields)])) {
+        const prior = before.fields[name];
+        const value = after.fields[name];
+        if (same(prior, value))
+            continue;
+        if (value === undefined)
+            return null;
+        edits.push({ op: 'set_field', path, field: name, ...(prior === undefined ? {} : { base: prior }), value });
+        changes.push({ kind: 'field', name, value, prior });
+    }
+    for (const name of new Set([...Object.keys(before.sections), ...Object.keys(after.sections)])) {
+        const prior = before.sections[name];
+        const value = after.sections[name];
+        if (prior === value)
+            continue;
+        if (prior === undefined || value === undefined)
+            return null;
+        edits.push({ op: 'replace_section', path, section: name, base: prior, content: value });
+        changes.push({ kind: 'section', name, value, prior });
+    }
+    return edits.length > 0 && applied(before, changes) === text ? edits : null;
+}
+export function changed(path, file, base, before, after) {
+    if (!file.endsWith('.md'))
+        return [{ op: 'replace', path, base, content: after }];
+    const parsedBefore = parse(before, file);
+    const parsedAfter = parse(after, file);
+    const structured = parsedBefore.ok && parsedAfter.ok ? components(path, parsedBefore.document, parsedAfter.document, after) : null;
+    return structured ?? [{ op: 'replace', path, base, content: after }];
+}

package/dist/update.js

@@ -0,0 +1,117 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { run } from './clis.js';
+import { kitHome } from './home.js';
+const RECORD = 'outcome=$1; shift; bash "$0" --linux "$@"; printf %s "$?" > "$outcome"; systemctl start house-kit.service';
+function logged(error) {
+    process.stderr.write(`kit: ${error instanceof Error ? error.message : String(error)}\n`);
+}
+function directory() {
+    return join(kitHome(), 'update');
+}
+function pending() {
+    return join(directory(), 'pending.json');
+}
+function outcome() {
+    return join(directory(), 'outcome');
+}
+function unit(inputId) {
+    return `house-kit-update-${inputId}`;
+}
+async function pendingInput() {
+    try {
+        return JSON.parse(await readFile(pending(), 'utf8')).input_id;
+    }
+    catch {
+        return null;
+    }
+}
+async function recorded() {
+    const status = await readFile(outcome(), 'utf8').catch(() => null);
+    if (status === null)
+        return null;
+    return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
+}
+async function finished(inputId) {
+    for (;;) {
+        const ack = await recorded();
+        if (ack !== null)
+            return ack;
+        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+            return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}
+function rerun(script, inputId, flags) {
+    return new Promise((resolve) => {
+        const child = spawn('systemd-run', [
+            '--wait',
+            '--collect',
+            '--quiet',
+            `--unit=${unit(inputId)}`,
+            `--setenv=HOME=${homedir()}`,
+            '/bin/sh',
+            '-c',
+            RECORD,
+            script,
+            outcome(),
+            ...flags,
+        ], { stdio: ['ignore', 'ignore', 'inherit'] });
+        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
+        child.on('close', () => resolve(null));
+    });
+}
+export class Updates {
+    house;
+    held = new Set();
+    queue = Promise.resolve();
+    constructor(house) {
+        this.house = house;
+    }
+    async resumed() {
+        const inputId = await pendingInput();
+        if (inputId === null)
+            return;
+        await this.acknowledge(inputId, await finished(inputId));
+    }
+    start(input) {
+        if (this.held.has(input.input_id))
+            return;
+        this.held.add(input.input_id);
+        this.queue = this.queue
+            .then(() => this.carry(input))
+            .then((ack) => this.acknowledge(input.input_id, ack))
+            .catch(logged)
+            .finally(() => this.held.delete(input.input_id));
+    }
+    async carry(input) {
+        if ((await pendingInput()) === input.input_id)
+            return finished(input.input_id);
+        const answer = await fetch(input.bootstrap);
+        if (!answer.ok)
+            return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
+        const script = Buffer.from(await answer.arrayBuffer());
+        if (createHash('sha256').update(script).digest('hex') !== input.sha256) {
+            return { refused: 'the Kit bootstrap does not match its sha256' };
+        }
+        await mkdir(directory(), { recursive: true, mode: 0o700 });
+        const path = join(directory(), 'connect-linux.sh');
+        await writeFile(path, script, { mode: 0o700 });
+        await rm(outcome(), { force: true });
+        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
+        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
+            refused: 'the Kit bootstrap did not finish',
+        };
+    }
+    async acknowledge(inputId, ack) {
+        await this.house.deliver(`/kit/inputs/${inputId}/ack`, ack);
+        if ((await pendingInput()) !== inputId)
+            return;
+        await rm(pending(), { force: true });
+        await rm(outcome(), { force: true });
+    }
+}

package/how-we-work.md

@@ -0,0 +1,23 @@
+# How we work
+
+A Room is where information people share is kept; it is not the place for
+private information. Work goes into the Room it belongs to, or the First Room
+when none is named.
+
+The skills are already set up; never run `setup-matt-pocock-skills`.
+
+## Where skill output goes
+
+- Glossary (`CONTEXT.md`): `library/glossary.md`
+- Decisions (ADRs): `library/decisions/NNNN-<slug>.md`
+- Plan (spec): `library/projects/<name>/plan.md`
+- Tasks (tickets): `library/projects/<name>/tasks/NN-<slug>.md`, with a
+  `Status:` line (`needs-triage`, `needs-info`, `ready-for-agent`,
+  `ready-for-human`, `wontfix`), a `Blocked by:` line and comments under
+  `## Comments`
+- Map (Wayfinding): `library/projects/<name>/map.md`, its tasks under
+  `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
+- Research: `library/research/<slug>.md`
+- Questionnaires: `library/questionnaires/<slug>.md`
+- Learning: `library/learning/<topic>/`
+- Prototype: one HTML file with every variant on one page.