@agentshouse/kit 0.2.1-ce3d2bb67177c → 0.2.1-ceeaf32286734

package/dist/silence.js

@@ -0,0 +1,28 @@
+const SYSTEM_CLOCK = {
+    later: (delay, callback) => setTimeout(callback, delay),
+    clear: (timer) => clearTimeout(timer),
+};
+export class Silence {
+    timer = null;
+    interval;
+    silent;
+    clock;
+    constructor(interval, silent, clock = SYSTEM_CLOCK) {
+        this.interval = interval;
+        this.silent = silent;
+        this.clock = clock;
+    }
+    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;
+    }
+}

package/dist/skills.js

@@ -1,31 +1,14 @@
-import { createHash } from 'node:crypto';
-import { readFileSync } from 'node:fs';
-import { cp, lstat, mkdir, readdir, realpath, rm, symlink } from 'node:fs/promises';
+import { cp, lstat, mkdir, 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 { GUIDE, listSkills } from '@agentshouse/skills';
 import { parse } from 'yaml';
 import { KIT_RELEASE } from './clis.js';
 import { kitHome, readConfiguration, readHome, writeHome } from './home.js';
-import { refusalOf } from './refusals.js';
-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 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: (.+)$/;
+const ENTRY = 'SKILL.md';
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n/u;
+const ORIGIN = '<origin>';
 function skillsDirectory() {
     return join(homedir(), '.agents', 'skills');
 }
@@ -43,105 +26,67 @@ async function present(path) {
         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);
+function skillName(text) {
+    const front = FRONTMATTER.exec(text);
+    const fields = (front === null ? null : parse(front[1]));
+    return typeof fields?.name === 'string' && typeof fields.description === 'string' ? fields.name : undefined;
+}
+function skillSet(origin) {
+    const upstream = listSkills().map(({ name, directory }) => ({
+        name,
+        place: (destination) => cp(directory, destination, { recursive: true }),
+    }));
+    const pages = GUIDE.flatMap(({ text }) => {
+        const name = skillName(text);
+        if (name === undefined)
+            return [];
+        const place = async (destination) => {
+            await mkdir(destination);
+            await writeFile(join(destination, ENTRY), text.replaceAll(ORIGIN, origin));
+        };
+        return [{ name, place }];
+    });
+    return [...upstream, ...pages].sort((left, right) => (left.name < right.name ? -1 : 1));
+}
+async function install(origin) {
+    const placed = [];
+    for (const skill of skillSet(origin)) {
+        if (!(await present(join(skillsDirectory(), skill.name))) && !(await present(join(claudeDirectory(), skill.name)))) {
+            placed.push(skill);
         }
     }
+    const names = placed.map((skill) => skill.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 });
+    for (const { name, place } of placed) {
+        await place(join(skillsDirectory(), name));
         if (claude !== skills)
             await symlink(relative(claude, join(skills, name)), join(claudeDirectory(), name));
     }
-    await writeHome(RECORD, { version: KIT_RELEASE, names });
+    await writeHome(RECORD, { version: KIT_RELEASE, origin, names });
 }
-export async function placeSkillSet() {
+export async function placeSkillSet(origin) {
     try {
-        await replaceSkillSet();
+        await replaceSkillSet(origin);
     }
     catch (error) {
         process.stderr.write(`kit: the skills could not be placed: ${error.message}\n`);
     }
 }
-async function replaceSkillSet() {
+async function replaceSkillSet(origin) {
     const accepted = (await readConfiguration()).skills;
     const installed = await readHome(RECORD);
-    if (accepted && installed?.version === KIT_RELEASE)
+    if (accepted && installed?.version === KIT_RELEASE && installed.origin === origin)
         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();
+        await install(origin);
     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 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;
-    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;
-    }
-    await writeHome(WRITTEN, current);
-}

package/dist/transcription.js

@@ -1,31 +1,31 @@
-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 { downloadServed } from './building.js';
 import { failureOf, run } from './clis.js';
 import { downloaded, fetched } from './files.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',
+    name: 'ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
+    from: 'https://huggingface.co/ggml-org/parakeet-GGUF/resolve/35156454d1a39de06863303dd209fd2bed6ee079/ggml-parakeet-tdt-0.6b-v3-q4_k.bin',
     sha256: '8b205b8b39c6535e153de6fb11c51db46125d45c4f16ba496fe41a0fe71b885e',
+    bytes: 415_611_879,
     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 },
+        decoder: { name: 'ffmpeg-linux-x86_64', from: `${RELEASE}/ffmpeg-linux-x86_64`, sha256: '1f8235d206428305afb89c6e8ab99d100425a0ba61e22bb4c7aff017db8c8de5', bytes: 5_175_832, executable: true },
+        engine: { name: 'parakeet-cli-linux-x86_64', from: `${RELEASE}/parakeet-cli-linux-x86_64`, sha256: 'bb2585695992fe1927a33960002cdf51b8a90a96ad65593c3d0a9f1fbc0865c2', bytes: 3_801_616, 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 },
+        decoder: { name: 'ffmpeg-linux-aarch64', from: `${RELEASE}/ffmpeg-linux-aarch64`, sha256: 'a7e08a0fae0179d1078312f6bb13d2a9aa4d4c71a1d82a022953f25dee452f5e', bytes: 4_590_208, executable: true },
+        engine: { name: 'parakeet-cli-linux-aarch64', from: `${RELEASE}/parakeet-cli-linux-aarch64`, sha256: 'cbc0bedc8daae97f1ef9dcee4200c06226218e300e0fd62ead1306d22742b7ed', bytes: 3_477_624, 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 },
+        decoder: { name: 'ffmpeg-darwin-arm64', from: `${RELEASE}/ffmpeg-darwin-arm64`, sha256: '7abe154aaed3d6b49f5167ca7221bb66bed51388925d99a7e4261a41fe52fba6', bytes: 3_696_768, executable: true },
+        engine: { name: 'parakeet-cli-darwin-arm64', from: `${RELEASE}/parakeet-cli-darwin-arm64`, sha256: '9a2aafc0922ad7c0b6db6eff1641e96572ba32ac40bf995a1df242ed2febf297', bytes: 1_939_728, executable: true },
     },
 };
 const CHUNK_SECONDS = 20;
@@ -46,7 +46,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.
+    // A decode or a transcription runs as long as its audio 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)));
@@ -60,11 +60,6 @@ async function threads() {
     const allowed = quota === 'max' ? Infinity : Math.ceil(Number(quota) / Number(period));
     return Math.max(1, Math.floor(Math.min(availableParallelism(), allowed) / 2));
 }
-async function sha256(path) {
-    const hash = createHash('sha256');
-    await pipeline(createReadStream(path), hash);
-    return hash.digest('hex');
-}
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -85,6 +80,25 @@ function ready() {
 function pinnedHere() {
     return ENGINES[`${process.platform}-${process.arch}`];
 }
+const DOWNLOADS = 3;
+async function downloadedAgain(artifact, signal) {
+    // An artifact arrives at a hundred kilobytes a second or its download ends, so a stalled Building cannot hold the install open.
+    const deadlineMs = Math.ceil(artifact.bytes / 100);
+    const deadline = AbortSignal.timeout(deadlineMs);
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await downloadServed(artifact.name, artifact.sha256, `${installed(artifact)}.part`, AbortSignal.any([signal, deadline]), artifact.bytes);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            if (deadline.aborted)
+                throw new Error(`${artifact.name} did not arrive within ${Math.ceil(deadlineMs / 1000)} seconds`);
+            if (attempt === DOWNLOADS)
+                throw error;
+        }
+    }
+}
 async function install(artifacts, signal) {
     await mkdir(directory(), { recursive: true });
     const pinned = new Set(artifacts.map((artifact) => artifact.sha256));
@@ -97,13 +111,8 @@ async function install(artifacts, signal) {
         if (!(await present(installed(artifact))))
             missing.push(artifact);
     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`);
-        }
+        for (const artifact of missing)
+            await downloadedAgain(artifact, signal);
         for (const artifact of missing) {
             if (artifact.executable)
                 await chmod(`${installed(artifact)}.part`, 0o755);

package/dist/update.js

@@ -6,6 +6,13 @@ import { join } from 'node:path';
 import { run } from './clis.js';
 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');
 }
@@ -31,7 +38,7 @@ function placement() {
     return service() === 'user' ? ['--workspace', workspaceRoot()] : ['--linux'];
 }
 function record() {
-    return `outcome=$1; shift; bash "$0" "$@"; printf %s "$?" > "$outcome"; ${[...elevated(), 'systemctl', ...manager(), 'start', 'house-kit.service'].join(' ')}`;
+    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 {
@@ -45,6 +52,8 @@ 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 forget(callId) {
@@ -66,6 +75,17 @@ async function finished(callId) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
     }
 }
+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 [command, ...args] = [
@@ -94,9 +114,12 @@ function rerun(script, callId, flags) {
 }
 export class KitUpdate {
     calls;
+    changed;
+    waiting = new Map();
     queue = Promise.resolve();
-    constructor(calls) {
+    constructor(calls, changed) {
         this.calls = calls;
+        this.changed = changed;
     }
     async resumed() {
         const callId = await pendingCall();
@@ -104,8 +127,17 @@ export class KitUpdate {
             return;
         await this.enqueue(callId, () => finished(callId));
     }
-    start(call) {
-        void this.enqueue(call.input_id, () => this.carry(call));
+    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);
     }
     enqueue(callId, work) {
         const before = this.queue;
@@ -119,10 +151,21 @@ export class KitUpdate {
     async carry(call) {
         if ((await pendingCall()) === call.input_id)
             return finished(call.input_id);
-        const answer = await fetch(call.bootstrap);
-        if (!answer.ok)
-            return { refused: `the Kit bootstrap could not be downloaded: ${answer.status}` };
-        const script = Buffer.from(await answer.arrayBuffer());
+        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' };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentshouse/kit",
-  "version": "0.2.1-ce3d2bb67177c",
+  "version": "0.2.1-ceeaf32286734",
   "description": "Kit connects an Environment to agents.house.",
   "license": "MIT",
   "repository": {
@@ -12,28 +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",
-    "sync-skills": "node scripts/sync-skills.mjs",
+    "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-cabd61587647f",
+    "@agentclientprotocol/sdk": "2.0.1",
+    "@agentshouse/mdmodel": "0.1.0-c4f4d37bc9d6a",
+    "@agentshouse/skills": "0.1.0-c27d55a17e1d8",
+    "@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": {
@@ -44,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-ce3d2bb67177c",
-  "hosts": {
-    "macos": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce3d2bb67177c/connect-linux.sh"
-      }
-    },
-    "linux": {
-      "asset": {
-        "name": "connect-linux.sh",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce3d2bb67177c/connect-linux.sh"
-      }
-    },
-    "windows": {
-      "asset": {
-        "name": "connect-windows.ps1",
-        "url": "https://github.com/agentshouse/kit/releases/download/v0.2.1-ce3d2bb67177c/connect-windows.ps1"
-      }
-    }
-  }
-}

package/how-we-work.md

@@ -1,33 +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.
-
-Every House answer carries the `url` of what it names; send the User that link.
-
-The skills are already set up; never run `setup-matt-pocock-skills`.
-
-## Where skill output goes
-
-- Glossary (`GLOSSARY.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`, or `done` once implemented), a
-  `Category:` line (`bug`, `enhancement`), a `Blocked by:` line and comments
-  under `## Comments`; triage takes no pull requests
-- Rejected requests (triage): `out-of-scope/<concept>.md`
-- Implementation notes (implement-spec): `projects/<name>/notes/`
-- PR bodies (pr): `projects/<name>/prs/<branch>.md`
-- Map (Wayfinding): `projects/<name>/map.md`, its tasks under
-  `tasks/` with `Type:`, `Status: claimed|resolved` and `Blocked by:` lines
-- Research: `research/<slug>.md`
-- Architecture reports (improve-codebase-architecture): `architecture/<slug>.html`
-- Handoffs: `handoffs/<slug>.md`
-- Questionnaires: `questionnaires/<slug>.md`
-- Retrospectives (retro): `retros/<date>-<slug>.md`
-- Wizards: `wizards/<slug>.sh`; the values they capture stay out of the Room
-- 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.