@agentshouse/kit 0.2.1-c53a84236c3d9 → 0.2.1-c57b73ff93a76

package/dist/update.js

@@ -4,11 +4,15 @@ 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`);
-}
+import { kitHome, workspaceRoot } from './home.js';
+import { service, throughSudo } from './placement.js';
+import { relayed } from './relay.js';
+const BOOTSTRAP_BYTES = 1_000_000;
+// A bootstrap is at most a million bytes, so two minutes carry it over ten kilobytes a second and no stalled host holds the update queue.
+const BOOTSTRAP_MS = 120_000;
+// A bootstrap's downloads and CLI updates take minutes, so one still running after an hour has hung and is ended before it keeps the Kit offline.
+const RERUN_MS = 60 * 60_000;
+const TIMED_OUT = '124';
 function directory() {
     return join(kitHome(), 'update');
 }
@@ -18,10 +22,25 @@ function pending() {
 function outcome() {
     return join(directory(), 'outcome');
 }
-function unit(inputId) {
-    return `house-kit-update-${inputId}`;
+function unit(callId) {
+    return `house-kit-update-${callId}`;
+}
+function manager() {
+    return service() === 'user' ? ['--user'] : [];
+}
+function elevated() {
+    return throughSudo() ? ['sudo', '-n'] : [];
+}
+function account() {
+    return throughSudo() ? [`--uid=${process.getuid()}`, `--gid=${process.getgid()}`] : [];
+}
+function placement() {
+    return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
 }
-async function pendingInput() {
+function record() {
+    return `outcome=$1; shift; timeout ${RERUN_MS / 1000} bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
+}
+async function pendingCall() {
     try {
         return JSON.parse(await readFile(pending(), 'utf8')).input_id;
     }
@@ -33,87 +52,130 @@ async function recorded() {
     const status = await readFile(outcome(), 'utf8').catch(() => null);
     if (status === null)
         return null;
+    if (status.trim() === TIMED_OUT)
+        return { refused: `the Kit bootstrap did not finish within ${RERUN_MS / 1000} seconds` };
     return status.trim() === '0' ? {} : { refused: `the Kit bootstrap exited with ${status.trim()}` };
 }
-async function finished(inputId) {
+async function forget(callId) {
+    if ((await pendingCall()) !== callId)
+        return;
+    await rm(pending(), { force: true });
+    await rm(outcome(), { force: true });
+}
+async function finished(callId) {
     for (;;) {
-        const ack = await recorded();
-        if (ack !== null)
-            return ack;
+        const result = await recorded();
+        if (result !== null)
+            return result;
         // systemctl answers at once, so ten seconds only bounds a stuck service manager.
-        if ((await run('systemctl', ['is-active', '--quiet', unit(inputId)], 10_000)).status !== 0) {
+        if ((await run('systemctl', [...manager(), 'is-active', '--quiet', unit(callId)], 10_000)).status !== 0) {
             return (await recorded()) ?? { refused: 'the Kit bootstrap did not finish' };
         }
         // The bootstrap runs for minutes, so checking each second sees its outcome within a second at little cost.
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
-function rerun(script, inputId, flags) {
+async function bounded(body, most) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of body ?? []) {
+        bytes += chunk.length;
+        if (bytes > most)
+            return null;
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks, bytes);
+}
+function rerun(script, callId, flags) {
     return new Promise((resolve) => {
-        const child = spawn('systemd-run', [
+        const [command, ...args] = [
+            ...elevated(),
+            'systemd-run',
+            ...manager(),
+            ...account(),
             '--wait',
             '--collect',
             '--quiet',
-            `--unit=${unit(inputId)}`,
+            `--unit=${unit(callId)}`,
             `--setenv=HOME=${homedir()}`,
+            `--setenv=HOUSE_KIT_HOME=${kitHome()}`,
             '/bin/sh',
             '-c',
-            RECORD,
+            record(),
             script,
             outcome(),
+            ...placement(),
             ...flags,
-        ], { stdio: ['ignore', 'ignore', 'inherit'] });
-        child.on('error', () => resolve({ refused: 'no service manager runs this Kit' }));
+        ];
+        const child = spawn(command, args, { stdio: ['ignore', 'ignore', 'inherit'] });
+        child.on('error', () => resolve({ refused: 'no service manager runs this Kit process' }));
         child.on('close', () => resolve(null));
     });
 }
-export class Updates {
-    house;
-    held = new Set();
+export class KitUpdate {
+    calls;
+    changed;
+    waiting = new Map();
     queue = Promise.resolve();
-    constructor(house) {
-        this.house = house;
+    constructor(calls, changed) {
+        this.calls = calls;
+        this.changed = changed;
     }
     async resumed() {
-        const inputId = await pendingInput();
-        if (inputId === null)
+        const callId = await pendingCall();
+        if (callId === null)
             return;
-        await this.acknowledge(inputId, await finished(inputId));
+        await this.enqueue(callId, () => finished(callId));
     }
-    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));
+    hold(call) {
+        this.waiting.set(call.input_id, call);
+        this.changed();
+    }
+    held() {
+        return this.waiting.size > 0;
+    }
+    apply(resume) {
+        const held = [...this.waiting.values()];
+        this.waiting.clear();
+        void Promise.all(held.map((call) => this.enqueue(call.input_id, () => this.carry(call)))).then(resume);
     }
-    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) {
+    enqueue(callId, work) {
+        const before = this.queue;
+        const carried = this.calls.carry(callId, async () => {
+            await before;
+            return { result: await work(), returned: () => forget(callId) };
+        });
+        this.queue = before.then(() => carried);
+        return carried;
+    }
+    async carry(call) {
+        if ((await pendingCall()) === call.input_id)
+            return finished(call.input_id);
+        const deadline = AbortSignal.timeout(BOOTSTRAP_MS);
+        let script;
+        try {
+            const answer = await fetch(relayed(call.bootstrap), { signal: deadline });
+            if (!answer.ok)
+                return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
+            script = await bounded(answer.body, BOOTSTRAP_BYTES);
+        }
+        catch (error) {
+            if (!deadline.aborted)
+                throw error;
+            return { refused: `the Kit bootstrap did not arrive within ${BOOTSTRAP_MS / 1000} seconds` };
+        }
+        if (script === null)
+            return { refused: `the Kit bootstrap is larger than ${BOOTSTRAP_BYTES} bytes` };
+        if (createHash('sha256').update(script).digest('hex') !== call.sha256) {
             return { refused: 'the Kit bootstrap does not match its sha256' };
         }
         await mkdir(directory(), { recursive: true, mode: 0o700 });
         const path = join(directory(), 'connect-linux.sh');
         await writeFile(path, script, { mode: 0o700 });
         await rm(outcome(), { force: true });
-        await writeFile(pending(), `${JSON.stringify({ input_id: input.input_id })}\n`, { mode: 0o600 });
-        return (await rerun(path, input.input_id, input.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
+        await writeFile(pending(), `${JSON.stringify({ input_id: call.input_id })}\n`, { mode: 0o600 });
+        return (await rerun(path, call.input_id, call.update_clis ? ['--update-clis'] : [])) ?? (await recorded()) ?? {
             refused: 'the Kit bootstrap did not finish',
         };
     }
-    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/dist/wire.js

@@ -0,0 +1,22 @@
+import { newerThanHouse, updateRequired } from './end.js';
+import { machine } from './placement.js';
+import { refusalOf } from './refusals.js';
+export const KIT_WIRE = 3;
+export const KIT_WIRE_HEADER = 'x-house-kit-wire';
+function newer(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    return body?.error?.code === 'kit_newer_than_house' ? body.error : null;
+}
+export function endUnserved(text) {
+    if (refusalOf(text)?.code === 'kit_update_required')
+        updateRequired();
+    const refused = newer(text);
+    if (refused !== null)
+        newerThanHouse(refused.release, refused.commands[machine()]);
+}

package/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');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-c53a84236c3d9",
-  "description": "House Kit connects an Environment to agents.house.",
+  "version": "0.2.1-c57b73ff93a76",
+  "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -12,27 +12,27 @@
     "kit": "dist/kit-main.js",
     "house": "dist/house-main.js"
   },
-  "exports": {
-    "./bootstrap": "./dist/bootstrap.json"
-  },
   "files": [
-    "dist",
-    "how-we-work.md",
-    "skills"
+    "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json && node scripts/bootstrap-manifest.mjs",
+    "bootstrap-manifest": "node scripts/bootstrap-manifest.mjs",
+    "build": "tsc -p tsconfig.build.json",
     "engine": "mkdir -p tmp/engine && docker run --rm -v \"$PWD:/kit\" -w /kit alpine:3.24@sha256:294b683cb724975bec92580e1e685676bd4b50bda910ddb8c51d4cabeaec77e6 sh scripts/engine.sh tmp/engine",
+    "follow-skills": "node scripts/follow-skills.mjs",
+    "release-files": "node scripts/release-files.mjs",
     "test": "tsc -p tsconfig.json && vitest run"
   },
   "dependencies": {
-    "@agentclientprotocol/sdk": "1.7.0",
-    "@agentshouse/mdmodel": "0.1.0-alpha.19",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-c1884c2b56810",
+    "@lydell/node-pty": "1.2.0-beta.15",
     "yaml": "2.9.1"
   },
   "peerDependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.85.1",
-    "@agentclientprotocol/codex-acp": "2.1.1"
+    "@agentclientprotocol/claude-agent-acp": "0.94.0",
+    "@agentclientprotocol/codex-acp": "2.2.2"
   },
   "peerDependenciesMeta": {
     "@agentclientprotocol/claude-agent-acp": {
@@ -43,26 +43,26 @@
     }
   },
   "devDependencies": {
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.2",
     "@types/ws": "8.18.2",
     "typescript": "7.0.2",
-    "vitest": "5.0.1",
+    "vitest": "5.0.5",
     "ws": "8.22.0"
   },
-  "packageManager": "npm@11.19.0",
+  "packageManager": "npm@11.19.1",
   "engines": {
-    "node": "24.21.0",
-    "npm": "11.19.0"
+    "node": "24.22.1",
+    "npm": "11.19.1"
   },
   "devEngines": {
     "runtime": {
       "name": "node",
-      "version": "24.21.0",
+      "version": "24.22.1",
       "onFail": "error"
     },
     "packageManager": {
       "name": "npm",
-      "version": "11.19.0",
+      "version": "11.19.1",
       "onFail": "error"
     }
   }

package/dist/bootstrap.json

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

package/dist/stream.js

@@ -1,72 +0,0 @@
-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(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}` },
-        });
-        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) => {
-            if (socket === opening)
-                socket = null;
-            process.stderr.write(`kit: control stream closed ${event.code} ${event.reason}\n`);
-            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();
-    return {
-        send(frame) {
-            if (socket === null || socket.readyState !== WebSocket.OPEN)
-                return false;
-            socket.send(JSON.stringify(frame));
-            return true;
-        },
-    };
-}

package/how-we-work.md

@@ -1,23 +0,0 @@
-# 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`): `glossary.md`
-- Decisions (ADRs): `decisions/NNNN-<slug>.md`
-- Plan (spec): `projects/<name>/plan.md`
-- Tasks (tickets): `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): `projects/<name>/map.md`, its tasks under
-  `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
-- Research: `research/<slug>.md`
-- Questionnaires: `questionnaires/<slug>.md`
-- Learning: `learning/<topic>/`
-- Prototype: one HTML file with every variant on one page.

package/skills/ask-matt/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Matt Pocock
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/skills/ask-matt/PHASE-BOUNDARIES.md

@@ -1,55 +0,0 @@
-# Phase boundaries
-
-A **phase** is a chunk of work inside a session: the grilling, the implementation, the QA. The definition is fuzzy on purpose: a phase ends when you think *"ok, we're done with that"*.
-
-The **phase boundary** is the gap between two phases, and it is the only place this decision belongs. Mid-phase there is no decision to make: continue, or split the work that's left into subagents. Compacting mid-phase makes the agent lose the thread.
-
-## The five options
-
-| Option       | What it does                                                    |
-| ------------ | --------------------------------------------------------------- |
-| **Continue** | Stay in the session. No context switch at all.                    |
-| **`/clear`** | Empty the context window and start from nothing.                  |
-| **`/handoff`** | Write a portable markdown file and seed a session anywhere with it. |
-| **Subagent** | Send the task to its own context window and get a report back.     |
-| **`/compact`** | Compress this context and seed a fresh session with the summary.  |
-
-## The tree
-
-Work top to bottom at the boundary. The first **yes** wins.
-
-**1. Can you continue in this session?** Two things make the answer yes: the next phase needs this phase as a **primary source**, or you have enough [smart zone](https://www.aihero.dev/ai-coding-dictionary/smart-zone) left (~150k tokens) for the next phase to fit. Grilling → implementation is the standard yes: the implementation wants the reasoning verbatim, not a summary of it. Continue costs nothing and loses nothing, so rule it out before anything else.
-
-**2. Is the context irrelevant to what comes next?** Is everything in this session (the exploration, the decisions, the dead ends) disposable? If so, **`/clear`**. It is the cheapest move on the board: it takes no time and hands back the whole window. `/clear` also isn't terminal: the old session stays resumable.
-
-The cost of getting this wrong is one-way. Clear a *relevant* context and you lose the **why** behind what you built, and no amount of reading the diff back gets it returned.
-
-**3. Do you need to hand off?** `/handoff` is narrow. You need it only when you are:
-
-- swapping to a **new harness** (Claude → Codex),
-- moving to a **new directory** or repo,
-- sending the work to a **colleague**,
-- or forking a side task you found **mid-phase** without derailing what you're doing.
-
-That list is the whole clause. What `/handoff` buys is **portability**: a file that travels. If nothing is travelling, you don't need it.
-
-**4. Can the task be done AFK?** Is it scoped tightly enough to run with you away from the keyboard, no steering? Then send it to a **subagent** and leave this session untouched. Automated review is the standard case: the agent reads the diff and reports, and you aren't needed while it does.
-
-**5. Otherwise, `/compact`.** Relevant context, same harness, same directory, and you need to stay in the loop: this is where the tree lands, and it lands here often. Pass it an instruction (`/compact we're going to QA this area`) so the summary keeps what the next phase needs.
-
-`/compact` is the **default, not the first reach**. It sits at the bottom because the four questions above it are all cheaper or more precise. The failure mode when people start here is a fresh session that is confidently wrong about a decision the summary flattened.
-
-## Primary and secondary sources
-
-Every move except **Continue** turns a **primary source** into a **secondary source**: the session as it happened, replaced by a summary of it. The trade is always the same shape:
-
-| Source                            | Information | Noise | Room to move |
-| --------------------------------- | ----------- | ----- | ------------ |
-| Primary (Continue)                | Full        | Lots  | Little       |
-| Secondary (`/compact`, `/handoff`) | Lossy       | Less  | Lots         |
-
-This is why question 1 comes first. You only pay the lossiness when staying costs more than it saves.
-
-## These are judgement calls
-
-The questions are not objective: each has taste in it, and the same boundary can go two ways on two days. The value is in asking them **in order**, at the boundary rather than in the middle of the work.