@agentshouse/kit 0.2.1-c3cf4b145dcda → 0.2.1-c3db1f18aed8f

package/dist/copies.js

@@ -3,7 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, readFile, readdir, realpath, rename, rm, rmdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { finalRefusal, HouseRefusal, retrying } from './api.js';
-import { blobId, blobText, git, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
+import { blobId, blobText, git, isText, HOUSE_REF, importCommits, localCopies, revision, run, succeeded, tree, } from './git.js';
 import { kitHome } from './home.js';
 import { operationId } from './operation.js';
 import { refusalOf } from './refusals.js';
@@ -29,9 +29,29 @@ const REBASED = new Set([
 function rebaseFixes(refusal) {
     return refusal.code === 'edit_conflict' && refusal.conflicts.some((code) => REBASED.has(code));
 }
+function textOnly(paths) {
+    const [named, them] = paths.length === 1 ? [`${paths[0]} is`, 'it'] : [`${paths.join(', ')} are`, 'them'];
+    return `${named} not text, and house push sends text only; remove ${them} from the commit and place ${them} with house upload`;
+}
 function short(commit) {
     return commit.slice(0, 12);
 }
+function moved(before, after) {
+    if (before.house !== after.house)
+        return [`${rootOf(after.room_handle)}: ${HOUSE_REF} is at ${short(after.house)}`];
+    return before.position === after.position ? [] : [`${rootOf(after.room_handle)}: read-only files refreshed`];
+}
+function expiredAuthority(error) {
+    if (!(error instanceof HouseRefusal))
+        return undefined;
+    try {
+        const { error: refused } = JSON.parse(error.text);
+        return refused?.code === 'expired' && typeof refused.authority === 'string' ? refused.authority : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function covers(path, prefix) {
     return prefix === '' || path === prefix || path.startsWith(`${prefix}/`);
 }
@@ -152,8 +172,7 @@ export class LocalCopies {
     house;
     copies = new Map();
     queues = new Map();
-    delivering = new Set();
-    selecting = Promise.resolve();
+    answering = Promise.resolve();
     constructor(house) {
         this.house = house;
         this.owner = {
@@ -185,42 +204,68 @@ export class LocalCopies {
         }
     }
     async mapping() {
-        await this.selecting;
+        await this.answering;
         return [...this.copies.values()]
             .filter((copy) => copy.active)
             .map((copy) => `${rootOf(copy.room_handle)}: ${copy.repository}`)
             .sort();
     }
-    select() {
-        const selected = this.selecting.then(() => this.reselect());
-        this.selecting = selected.catch(() => undefined);
-        return selected;
-    }
-    async reselect() {
-        const { local_copy: chosen } = await this.house.post('/kit/local-copy/selection', {});
-        const selected = (chosen?.rooms ?? []).flatMap((room) => room.room_handle === null ? [] : [{ key: `rooms/${room.room_ref}`, handle: room.room_handle }]);
-        const keys = new Set(selected.map((scope) => scope.key));
-        const work = [];
-        for (const key of this.copies.keys()) {
-            if (keys.has(key))
-                continue;
-            work.push(this.exclusive(key, async () => {
-                const copy = this.copies.get(key);
-                if (copy.active)
-                    await this.save({ ...copy, active: false });
-            }));
-        }
-        for (const scope of selected)
-            work.push(this.exclusive(scope.key, () => this.apply(scope)).catch(logged));
-        await Promise.all(work);
+    async connected() {
+        const copied = await this.answered(() => this.fetched(false));
+        if (copied.refused)
+            logged(copied.text);
     }
-    entries(frame) {
-        const copy = [...this.copies.values()].find((held) => held.active && held.room_ref === frame.authority);
-        if (copy === undefined)
-            return;
-        if (copy.log_epoch === frame.log_epoch && BigInt(frame.position) <= BigInt(copy.position))
-            return;
-        this.deliver(copy.key);
+    fetch() {
+        return this.answered(() => this.fetched(true));
+    }
+    answered(work) {
+        const answered = this.answering.then(work);
+        this.answering = answered.catch(() => undefined);
+        return answered;
+    }
+    async fetched(refreshing) {
+        const { local_copy: answer } = await this.house.post('/kit/local-copy/selection', {});
+        const synced = new Map(answer.rooms.map((room) => [`rooms/${room.room_ref}`, room.room_handle]));
+        return this.holding([...new Set([...this.copies.keys(), ...synced.keys()])].sort(), async () => {
+            const said = [];
+            let refused = false;
+            for (const copy of this.copies.values()) {
+                if (synced.has(copy.key) || !copy.active)
+                    continue;
+                await this.save({ ...copy, active: false });
+                said.push(`${rootOf(copy.room_handle)}: no longer synced to this Environment; its files stay`);
+            }
+            const current = [];
+            for (const [key, handle] of synced) {
+                try {
+                    const held = this.copies.get(key);
+                    if (held === undefined || !(await exists(held.repository))) {
+                        said.push(await this.materialize(key, handle));
+                        continue;
+                    }
+                    const copy = held.room_handle === handle ? held : await this.save({ ...held, room_handle: handle });
+                    if (copy.active)
+                        current.push(copy);
+                    else
+                        said.push(...moved(copy, await this.save(await this.received({ ...copy, active: true }))));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(`${rootOf(handle)}: ${causeOf(error)}`);
+                }
+            }
+            if (refreshing && current.length > 0) {
+                try {
+                    const refreshed = await this.refreshed(current);
+                    current.forEach((copy, index) => said.push(...moved(copy, refreshed[index])));
+                }
+                catch (error) {
+                    refused = true;
+                    said.push(error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error));
+                }
+            }
+            return { refused, text: said.length === 0 ? 'Nothing new from House.' : said.join('\n') };
+        });
     }
     async observed(report) {
         const key = await this.keyAt(dirname(report.common));
@@ -270,16 +315,9 @@ export class LocalCopies {
         this.queues.set(key, queued.catch(() => undefined));
         return queued;
     }
-    deliver(key) {
-        if (this.delivering.has(key))
-            return;
-        this.delivering.add(key);
-        void this.exclusive(key, async () => {
-            this.delivering.delete(key);
-            const copy = this.copies.get(key);
-            if (copy.active)
-                await this.save(await this.caughtUp(copy));
-        }).catch(logged);
+    holding(keys, work) {
+        const [key, ...rest] = keys;
+        return key === undefined ? work() : this.exclusive(key, () => this.holding(rest, work));
     }
     async save(copy) {
         const path = join(kitHome(), 'local-copies', `${copy.key}.json`);
@@ -325,46 +363,13 @@ export class LocalCopies {
         }
         return read;
     }
-    async apply(scope) {
-        let copy = this.copies.get(scope.key);
-        if (copy === undefined || !(await exists(copy.repository))) {
-            await this.materialize(scope);
-            return;
-        }
-        if (copy.room_handle !== scope.handle)
-            copy = await this.save({ ...copy, room_handle: scope.handle });
-        if (!copy.active) {
-            await this.save(await this.received({ ...copy, active: true }));
-            return;
-        }
-        const discovery = await this.house.post('/kit/door/discover', {
-            prefixes: [rootOf(copy.room_handle)],
-        });
-        const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
-        if (authority === undefined)
-            return;
-        if (authority.managed_replication !== 'admitted') {
-            logged(`operation_denied: ${rootOf(copy.room_handle)} is not synchronized to this Environment`);
-            return;
-        }
-        if (JSON.stringify([authority.operations.write, authority.protected_paths]) !==
-            JSON.stringify([copy.write, copy.protected])) {
-            await this.save(await this.received(copy));
-            return;
-        }
-        await this.save(await this.caughtUp(copy));
-    }
-    async materialize(scope) {
-        const read = await this.read(scope.handle);
-        if (read === null) {
-            logged(`House serves nothing of ${rootOf(scope.handle)} to copy`);
-            return;
-        }
+    async materialize(key, handle) {
+        const read = await this.read(handle);
+        if (read === null)
+            throw new Error('House serves nothing of it to copy');
         const repository = join(localCopies(), 'rooms', read.anchor);
-        if (await exists(repository)) {
-            logged(`${repository} already exists and House Kit leaves it as it is`);
-            return;
-        }
+        if (await exists(repository))
+            throw new Error(`${repository} already exists and House Kit leaves it as it is`);
         const staging = join(dirname(repository), `.${randomUUID()}`);
         await mkdir(staging, { recursive: true });
         let house;
@@ -372,7 +377,7 @@ export class LocalCopies {
         try {
             await git(staging, ['init', '-q', '-b', BRANCH]);
             house = await importCommits(staging, [
-                { message: `House ${rootOf(scope.handle)}`, from: null, files: read.writable },
+                { message: `House ${rootOf(handle)}`, from: null, files: read.writable },
             ]);
             await git(staging, ['update-ref', `refs/heads/${BRANCH}`, house]);
             await git(staging, ['reset', '-q', '--hard']);
@@ -385,9 +390,9 @@ export class LocalCopies {
             throw error;
         }
         await this.save({
-            key: scope.key,
+            key,
             room_ref: read.anchor,
-            room_handle: scope.handle,
+            room_handle: handle,
             repository,
             active: true,
             house,
@@ -399,6 +404,7 @@ export class LocalCopies {
             manifests: { [house]: { parent: null, files: read.revisions } },
             moves: [],
         });
+        return `${rootOf(handle)}: copied to ${repository}`;
     }
     async received(copy) {
         const read = await this.read(copy.room_handle);
@@ -422,29 +428,52 @@ export class LocalCopies {
         await ignoreRules(copy.repository, [...read.writable.keys()], next);
         return next;
     }
-    async caughtUp(start) {
-        let copy = start;
-        for (;;) {
+    async refreshed(copies) {
+        const discovery = await this.house.post('/kit/door/discover', {
+            prefixes: copies.map((copy) => rootOf(copy.room_handle)),
+        });
+        const regranted = new Map();
+        for (const copy of copies) {
+            const authority = discovery.authorities.find((entry) => entry.room_ref === copy.room_ref);
+            if (authority !== undefined &&
+                JSON.stringify([authority.operations.write, authority.protected_paths]) !== JSON.stringify([copy.write, copy.protected])) {
+                regranted.set(copy.key, await this.save(await this.received(copy)));
+            }
+        }
+        const caught = await this.caughtUp(copies.filter((copy) => !regranted.has(copy.key)), false);
+        return copies.map((copy) => regranted.get(copy.key) ?? caught.find((held) => held.key === copy.key));
+    }
+    async caughtUp(copies, whole) {
+        const caught = new Map(copies.map((copy) => [copy.key, copy]));
+        let asking = [...copies];
+        while (asking.length > 0) {
             let answer;
             try {
                 answer = await this.house.post('/kit/door/enumerate', {
-                    prefixes: [rootOf(copy.room_handle)],
-                    positions: [{ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch }],
+                    prefixes: asking.map((copy) => rootOf(copy.room_handle)),
+                    positions: asking.map((copy) => ({ authority: copy.room_ref, position: copy.position, log_epoch: copy.log_epoch })),
                 });
             }
             catch (error) {
-                const code = error instanceof HouseRefusal ? (refusalOf(error.text)?.code ?? null) : null;
-                if (code === 'position_expired')
-                    return this.received(copy);
-                if (code !== 'replica_behind')
+                const expired = asking.find((copy) => copy.room_ref === expiredAuthority(error));
+                if (expired === undefined)
                     throw error;
-                return copy;
+                caught.set(expired.key, await this.save(await this.received(expired)));
+                asking = asking.filter((copy) => copy !== expired);
+                continue;
+            }
+            const advanced = [];
+            for (const copy of asking) {
+                const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
+                if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
+                    continue;
+                const next = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+                caught.set(copy.key, next);
+                advanced.push(next);
             }
-            const view = answer.authorities.find((entry) => entry.authority === copy.room_ref);
-            if (view === undefined || (view.position === copy.position && view.log_epoch === copy.log_epoch))
-                return copy;
-            copy = await this.save(await this.incorporated(copy, view.changes, view.position, view.log_epoch));
+            asking = whole ? advanced : [];
         }
+        return copies.map((copy) => caught.get(copy.key));
     }
     async incorporated(copy, changes, position, logEpoch) {
         const houseTree = await tree(copy.repository, copy.house);
@@ -547,7 +576,13 @@ export class LocalCopies {
         const after = await tree(copy.repository, commit);
         const moved = movedPaths(copy.moves, before, after);
         const arrived = new Set(moved.values());
-        const text = (entry, path) => blobText(copy.repository, entry, path);
+        const binary = [];
+        for (const [path, entry] of after)
+            if (before.get(path) !== entry && !(await isText(copy.repository, entry)))
+                binary.push(path);
+        if (binary.length > 0)
+            throw new Error(textOnly(binary));
+        const text = (entry) => blobText(copy.repository, entry);
         const changes = [];
         for (const path of [...new Set([...before.keys(), ...after.keys()])].sort()) {
             if (arrived.has(path))
@@ -560,7 +595,7 @@ export class LocalCopies {
                 changes.push({ op: 'rename', path: `${root}/${path}`, to: `${root}/${to}`, base: known });
                 const moving = after.get(to);
                 if (moving !== prior) {
-                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving, to) });
+                    changes.push({ op: 'replace', path: `${root}/${to}`, base: known, content: await text(moving) });
                 }
                 continue;
             }
@@ -569,9 +604,9 @@ export class LocalCopies {
             if (next === undefined)
                 changes.push({ op: 'remove', path: `${root}/${path}`, base: known });
             else if (prior === undefined)
-                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next, path) });
+                changes.push({ op: 'create', path: `${root}/${path}`, content: await text(next) });
             else
-                changes.push(...changed(`${root}/${path}`, path, known, await text(prior, path), await text(next, path)));
+                changes.push(...changed(`${root}/${path}`, path, known, await text(prior), await text(next)));
         }
         return changes;
     }
@@ -598,12 +633,12 @@ export class LocalCopies {
                 const { upload, ...unstaged } = copy.push;
                 return this.settle(await this.save({ ...copy, push: unstaged }), caller, true);
             }
-            if (outcome.refused.code === 'operation_expired')
+            if (outcome.refused.code === 'expired')
                 return this.recovered(copy);
             const rebased = rebaseFixes(outcome.refused);
             let settled = await this.save(without(copy));
             try {
-                settled = await this.save(await this.caughtUp(settled));
+                settled = (await this.caughtUp([settled], true))[0];
             }
             catch {
                 return {
@@ -622,7 +657,7 @@ export class LocalCopies {
     }
     async recovered(copy) {
         const push = copy.push;
-        const current = await this.save(await this.caughtUp(copy));
+        const current = (await this.caughtUp([copy], true))[0];
         const house = await tree(copy.repository, current.house);
         const root = rootOf(current.room_handle);
         if (!(await this.landed(copy.repository, push.changes, house, await tree(copy.repository, push.commit)))) {
@@ -638,7 +673,7 @@ export class LocalCopies {
             written.push({
                 path: `${root}/${path}`,
                 revision: entry === undefined ? null : (revisionAt(current, current.house, path) ?? null),
-                content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                content: entry === undefined ? null : await blobText(copy.repository, entry),
             });
         }
         return this.finished(await this.save({ ...current, push: { ...push, state: 'accepted', written } }));
@@ -666,7 +701,7 @@ export class LocalCopies {
         const push = copy.push;
         let written = push.written;
         if (push.changes.some((change) => change.op === 'rename')) {
-            copy = await this.save(await this.caughtUp(copy));
+            copy = (await this.caughtUp([copy], true))[0];
             const house = await tree(copy.repository, copy.house);
             const sent = await tree(copy.repository, push.house);
             if (push.changes.some((change) => change.op === 'rename' && !house.has(relative(change.to)))) {
@@ -682,7 +717,7 @@ export class LocalCopies {
                     {
                         path: `${rootOf(copy.room_handle)}/${path}`,
                         revision: entry === undefined ? null : (revisionAt(copy, copy.house, path) ?? null),
-                        content: entry === undefined ? null : await blobText(copy.repository, entry, path),
+                        content: entry === undefined ? null : await blobText(copy.repository, entry),
                     },
                 ];
             }
@@ -727,7 +762,7 @@ export class LocalCopies {
     async landed(repository, changes, house, selected) {
         const text = async (path) => {
             const entry = house.get(relative(path));
-            return entry === undefined ? undefined : blobText(repository, entry, path);
+            return entry === undefined ? undefined : blobText(repository, entry);
         };
         for (const change of changes) {
             const current = await text(change.path);

package/dist/end.js

@@ -1,8 +1,22 @@
-import { killDescendants } from './acp.js';
+import { forgetRejected } from './home.js';
+import { installCommand } from './placement.js';
+import { killDescendants } from './scope.js';
 export const REPLACED = 'another Kit started for this Environment';
-export const SIGN_IN_AGAIN = 'sign in again';
-export function end(reason) {
+function exit(reason, status) {
     process.stderr.write(`kit: ${reason}\n`);
     killDescendants();
-    process.exit(0);
+    process.exit(status);
+}
+export function end(reason) {
+    exit(reason, 0);
+}
+export function restart(reason) {
+    exit(reason, 1);
+}
+export function updateRequired(house) {
+    end(`This Kit is too old for House. Update it: ${installCommand(house)}`);
+}
+export async function signInAgain(rejected) {
+    await forgetRejected(rejected);
+    restart('sign in again');
 }

package/dist/enrol-main.js

@@ -1,4 +1,10 @@
 import { readFileSync } from 'node:fs';
 import { writeEnrolment } from './home.js';
 const [house, environment] = process.argv.slice(2);
-await writeEnrolment({ house: house, environment: environment, credential: readFileSync(0, 'utf8').trim() });
+const relay = process.env.HOUSE_KIT_RELAY || undefined;
+await writeEnrolment({
+    house: house,
+    ...(relay === undefined ? {} : { relay }),
+    environment: environment,
+    credential: readFileSync(0, 'utf8').trim(),
+});

package/dist/events.js

@@ -1,7 +1,7 @@
 const COMMAND = { shown: 'command' };
 const HIDDEN = { shown: 'hidden' };
 const FINISHED = new Set(['completed', 'failed']);
-const RUNNING_JOB = new Set(['running', 'paused']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
 const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
 function words(line) {
     const found = [];
@@ -113,9 +113,6 @@ class Reader {
     refused(option) {
         this.requestedOptions.delete(option);
     }
-    turnStarted() {
-        return [];
-    }
     closeTurn() {
         const events = [];
         for (const [id, call] of this.calls) {
@@ -187,10 +184,7 @@ class Reader {
         const label = this.jobs.get(id) ?? '';
         if (state !== 'running')
             this.jobs.delete(id);
-        return [
-            { kind: 'busy', key: `job:${id}`, running: state === 'running' },
-            { kind: 'marker', marker: 'job', text: `${label}: ${state}` },
-        ];
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
     }
     optionsChanged(options) {
         const events = [];
@@ -275,7 +269,6 @@ class Reader {
 class ClaudeReader extends Reader {
     watchedOptions = { model: 'model' };
     tasks = new Map();
-    scheduled = new Map();
     own(message) {
         if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
             return [];
@@ -295,10 +288,6 @@ class ClaudeReader extends Reader {
             return [];
         const sdk = message.params.message;
         switch (sdk.subtype) {
-            case 'background_tasks_changed':
-                return [{ kind: 'busy', key: 'tasks', running: sdk.tasks.length > 0 }];
-            case 'session_state_changed':
-                return [{ kind: 'busy', key: 'state', running: sdk.state === 'running' }];
             case 'task_started':
                 if (sdk.tool_use_id !== undefined)
                     this.tasks.set(sdk.task_id, sdk.tool_use_id);
@@ -309,16 +298,6 @@ class ClaudeReader extends Reader {
                 return [];
         }
     }
-    turnStarted() {
-        const events = [];
-        for (const [id, entry] of this.scheduled) {
-            if (entry.recurring)
-                continue;
-            this.scheduled.delete(id);
-            events.push({ kind: 'busy', key: `scheduled:${id}`, running: false });
-        }
-        return events;
-    }
     decide(call, final) {
         const tool = call.meta.claudeCode?.toolName;
         if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
@@ -350,22 +329,7 @@ class ClaudeReader extends Reader {
         if (call.status !== 'completed')
             return [];
         if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
-            this.scheduled.set(call.id, {
-                recurring: tool === 'CronCreate' && call.rawInput?.recurring !== false,
-                text: contentText(call.content) ?? '',
-            });
-            return [
-                { kind: 'busy', key: `scheduled:${call.id}`, running: true },
-                { kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` },
-            ];
-        }
-        if (tool === 'CronDelete') {
-            for (const [id, entry] of this.scheduled) {
-                if (!entry.text.includes(String(call.rawInput?.id)))
-                    continue;
-                this.scheduled.delete(id);
-                return [{ kind: 'busy', key: `scheduled:${id}`, running: false }];
-            }
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
         }
         return [];
     }
@@ -402,15 +366,9 @@ class CodexReader extends Reader {
             case 'subagent_spawned':
                 this.children.set(update.subagentSessionId, { id: null, text: '' });
                 this.subagents.add(update.subagentSessionId);
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: true },
-                    { kind: 'subagent', id: update.subagentSessionId, description: update.name },
-                ];
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
             case 'subagent_state_update':
-                return [
-                    { kind: 'busy', key: `subagent:${update.subagentSessionId}`, running: false },
-                    ...this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null),
-                ];
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
             default:
                 return super.update(update);
         }
@@ -427,10 +385,6 @@ class CodexReader extends Reader {
             child.id = id;
             child.text += update.content.text;
         }
-        const status = update._meta?.codex?.threadStatus?.type;
-        if (update.sessionUpdate === 'session_info_update' && status !== undefined) {
-            return [{ kind: 'busy', key: `thread:${session}`, running: status === 'active' }];
-        }
         return [];
     }
     decide(call) {
@@ -460,7 +414,6 @@ class CodexReader extends Reader {
 class GrokReader extends Reader {
     watchedOptions = {};
     children = new Map();
-    queues = new Map();
     models = [];
     model = null;
     answered(result) {
@@ -473,15 +426,10 @@ class GrokReader extends Reader {
         if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
             return [];
         if (message.method === '_x.ai/queue/changed') {
-            const running = message.params.runningPromptId ?? null;
-            this.queues.set(session, { running, entries: message.params.entries.length });
-            return [this.queued(session), ...(running !== null && session === this.session ? [{ kind: 'started' }] : [])];
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
         }
         if (message.params?.update?.sessionUpdate === 'turn_completed') {
-            const queue = this.queues.get(session);
-            if (queue !== undefined && queue.running === message.params.update.prompt_id)
-                queue.running = null;
-            return [this.queued(session), ...(session === this.session ? [{ kind: 'ended' }] : [])];
+            return session === this.session ? [{ kind: 'ended' }] : [];
         }
         if (message.method === '_x.ai/models/update') {
             this.offered(message.params);
@@ -489,10 +437,6 @@ class GrokReader extends Reader {
         }
         return super.read(message);
     }
-    queued(session) {
-        const queue = this.queues.get(session);
-        return { kind: 'busy', key: `queue:${session}`, running: queue !== undefined && (queue.running !== null || queue.entries > 0) };
-    }
     offered(models) {
         this.models = models.availableModels ?? this.models;
         this.model = models.currentModelId ?? this.model;
@@ -508,16 +452,9 @@ class GrokReader extends Reader {
             case '_x.ai/task_completed':
                 return this.job(update.task_snapshot.task_id, null, update.task_snapshot.exit_code === 0 ? 'completed' : 'failed');
             case '_x.ai/scheduled_task_created':
-                return [
-                    { kind: 'busy', key: `scheduled:${update.task_id}`, running: true },
-                    { kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` },
-                ];
-            case '_x.ai/scheduled_task_deleted':
-                return [{ kind: 'busy', key: `scheduled:${update.task_id}`, running: false }];
+                return [{ kind: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
             case '_x.ai/session_notification':
                 return this.notification(update);
-            case '_x.ai/mcp_initialized':
-                return [{ kind: 'servers' }];
             default:
                 return [];
         }
@@ -538,14 +475,11 @@ class GrokReader extends Reader {
                     candidate.decided.description === update.description) ??
                     [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' && ![...this.children.values()].includes(candidate.id));
                 this.children.set(update.child_session_id, call?.id ?? null);
-                return [{ kind: 'busy', key: `subagent:${update.child_session_id}`, running: true }];
+                return [];
             }
             case 'subagent_finished': {
                 const call = this.children.get(update.child_session_id);
-                return [
-                    { kind: 'busy', key: `subagent:${update.child_session_id}`, running: false },
-                    ...(typeof call === 'string' ? this.finish(call, update.output ?? null) : []),
-                ];
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
             }
             case 'auto_compact_completed':
                 return [{ kind: 'marker', marker: 'compaction', text: '' }];

package/dist/files.js

@@ -1,7 +1,13 @@
+import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { HouseRefusal, retrying } from './api.js';
 import { relayed } from './relay.js';
+export function verified(bytes, sha256, name) {
+    if (createHash('sha256').update(bytes).digest('hex') !== sha256)
+        throw new Error(`${name} did not arrive whole; download it again`);
+    return bytes;
+}
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
     for (const file of files) {
@@ -16,7 +22,7 @@ export async function placeFiles(house, directory, files, signal) {
         });
         await mkdir(folder, { recursive: true });
         const path = join(folder, file.name);
-        await writeFile(path, Buffer.from(await answer.arrayBuffer()));
+        await writeFile(path, verified(Buffer.from(await answer.arrayBuffer()), file.sha256, file.name));
         paths.push(path);
     }
     return paths;