@agentshouse/kit 0.2.1-cd9cbd8b6428c → 0.2.1-cfe564e35b4a5

package/dist/events.js

@@ -0,0 +1,521 @@
+const COMMAND = { shown: 'command' };
+const HIDDEN = { shown: 'hidden' };
+const FINISHED = new Set(['completed', 'failed']);
+export const RUNNING_JOB = new Set(['running', 'paused']);
+const ROUTINE_TARGETS = { send_routine_request: 'access', cancel_routine_request: 'request' };
+function words(line) {
+    const found = [];
+    let word = null;
+    let quote = null;
+    for (let index = 0; index < line.length; index++) {
+        const character = line[index];
+        if (quote !== null) {
+            if (character === quote)
+                quote = null;
+            else if (character === '\\' && quote === '"')
+                word += line[++index] ?? '';
+            else
+                word += character;
+        }
+        else if (character === "'" || character === '"') {
+            quote = character;
+            word ??= '';
+        }
+        else if (character === '\\') {
+            word = (word ?? '') + (line[++index] ?? '');
+        }
+        else if (/\s/.test(character)) {
+            if (word !== null)
+                found.push(word);
+            word = null;
+        }
+        else {
+            word = (word ?? '') + character;
+        }
+    }
+    if (word !== null)
+        found.push(word);
+    return found;
+}
+export function houseMessage(line) {
+    const [program, verb, json] = words(line.trim());
+    if (program !== 'house' || verb !== 'run_command' || json === undefined)
+        return null;
+    let call;
+    try {
+        call = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    const argument = ROUTINE_TARGETS[call.command];
+    if (argument === undefined)
+        return null;
+    const target = call.arguments?.[argument];
+    return { shown: 'message', command: call.command, target: typeof target === 'string' ? target : null };
+}
+function decidedByLine(command, final) {
+    const line = typeof command === 'string' ? command : Array.isArray(command) ? command.at(-1) : undefined;
+    if (typeof line !== 'string')
+        return final ? COMMAND : null;
+    return houseMessage(line) ?? COMMAND;
+}
+function contentText(content) {
+    const text = (content ?? [])
+        .map((entry) => (entry.type === 'content' && entry.content?.type === 'text' ? entry.content.text : ''))
+        .filter((part) => part !== '')
+        .join('\n');
+    return text === '' ? null : text;
+}
+function plan(entries) {
+    return entries.map((entry) => ({ content: entry.content, status: entry.status }));
+}
+function merged(into, from) {
+    if (from === null || from === undefined)
+        return into;
+    const result = { ...into };
+    for (const [key, value] of Object.entries(from)) {
+        result[key] =
+            typeof value === 'object' && value !== null && !Array.isArray(value) && typeof into[key] === 'object'
+                ? merged(into[key], value)
+                : value;
+    }
+    return result;
+}
+function names(input, ids) {
+    const values = JSON.stringify(input ?? {});
+    for (const id of ids)
+        if (values.includes(id))
+            return true;
+    return false;
+}
+class Reader {
+    session = null;
+    calls = new Map();
+    subagents = new Set();
+    done = new Set();
+    seenOptions = new Map();
+    requestedOptions = new Map();
+    compactions = new Set();
+    jobs = new Map();
+    read(message) {
+        if (message.method === undefined)
+            return this.answered(message.result);
+        const session = message.params?.sessionId;
+        if (session !== undefined && this.session !== null && session !== this.session) {
+            return this.elsewhere(session, message);
+        }
+        return this.own(message);
+    }
+    requested(option, value) {
+        this.requestedOptions.set(option, value);
+    }
+    refused(option) {
+        this.requestedOptions.delete(option);
+    }
+    closeTurn() {
+        const events = [];
+        for (const [id, call] of this.calls) {
+            if (call.decided?.shown === 'subagent')
+                continue;
+            if (call.decided === null)
+                events.push(...this.shown(call, this.decide(call, true)));
+            this.calls.delete(id);
+        }
+        return events;
+    }
+    answered(result) {
+        if (typeof result?.sessionId === 'string' && this.session === null)
+            this.session = result.sessionId;
+        for (const option of (result?.configOptions ?? [])) {
+            this.seenOptions.set(option.id, option.currentValue);
+            this.requestedOptions.delete(option.id);
+        }
+        return [];
+    }
+    elsewhere(_session, _message) {
+        return [];
+    }
+    own(message) {
+        if (message.method !== 'session/update')
+            return this.extension(message);
+        return this.update(message.params.update);
+    }
+    extension(_message) {
+        return [];
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'agent_message_chunk':
+                if (update.content.type === 'image')
+                    return [{ kind: 'image', data: update.content.data, mediaType: update.content.mimeType }];
+                return update.content.type === 'text' ? [{ kind: 'text', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'agent_thought_chunk':
+                return update.content.type === 'text' ? [{ kind: 'reasoning', id: update.messageId ?? null, text: update.content.text }] : [];
+            case 'tool_call':
+            case 'tool_call_update':
+                return this.tool(update);
+            case 'plan':
+                return [{ kind: 'plan', entries: plan(update.entries) }];
+            case 'usage_update':
+                return [{ kind: 'context', used: update.used, window: update.size }];
+            case 'current_mode_update':
+                return [{ kind: 'marker', marker: 'mode', text: update.currentModeId }];
+            case 'available_commands_update':
+                return [{ kind: 'commands', commands: update.availableCommands }];
+            case 'config_option_update':
+                return [{ kind: 'options', options: update.configOptions }, ...this.optionsChanged(update.configOptions)];
+            case 'compaction_update':
+                if (update.status !== 'completed' || this.compactions.has(update.compactionId))
+                    return [];
+                this.compactions.add(update.compactionId);
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'async_task_spawned':
+                return this.job(update.asyncTaskId, update.name ?? update.description ?? '', 'running');
+            case 'async_task_state_update':
+                return RUNNING_JOB.has(update.state) ? [] : this.job(update.asyncTaskId, null, update.state);
+            default:
+                return [];
+        }
+    }
+    job(id, name, state) {
+        if (name !== null)
+            this.jobs.set(id, name);
+        const label = this.jobs.get(id) ?? '';
+        if (state !== 'running')
+            this.jobs.delete(id);
+        return [{ kind: 'marker', marker: 'job', text: `${label}: ${state}` }];
+    }
+    optionsChanged(options) {
+        const events = [];
+        for (const option of options) {
+            const marker = this.watchedOptions[option.id];
+            const before = this.seenOptions.get(option.id);
+            this.seenOptions.set(option.id, option.currentValue);
+            if (marker === undefined || before === undefined || before === option.currentValue)
+                continue;
+            if (this.requestedOptions.get(option.id) === option.currentValue) {
+                this.requestedOptions.delete(option.id);
+                continue;
+            }
+            events.push({ kind: 'marker', marker, text: String(option.currentValue) });
+        }
+        return events;
+    }
+    tool(update) {
+        let call = this.calls.get(update.toolCallId);
+        if (call === undefined) {
+            if (update.sessionUpdate !== 'tool_call')
+                return [];
+            call = { id: update.toolCallId, decided: null, meta: {}, imaged: false, status: 'in_progress' };
+            this.calls.set(call.id, call);
+        }
+        if (update.kind !== undefined)
+            call.kind = update.kind;
+        if (update.title !== undefined)
+            call.title = update.title;
+        if (update.status !== undefined)
+            call.status = update.status;
+        if (update.rawInput !== undefined)
+            call.rawInput = merged(call.rawInput ?? {}, update.rawInput);
+        if (update.content !== undefined)
+            call.content = update.content;
+        call.meta = merged(call.meta, update._meta);
+        const events = [];
+        const finished = FINISHED.has(call.status);
+        if (call.decided === null) {
+            const decided = this.decide(call, finished);
+            if (decided !== null)
+                events.push(...this.shown(call, decided));
+        }
+        events.push(...this.produced(call));
+        if (call.decided?.shown === 'subagent' && finished)
+            events.push(...this.subagentFinished(call));
+        else if (finished)
+            this.calls.delete(call.id);
+        return events;
+    }
+    shown(call, decided) {
+        call.decided = decided;
+        switch (decided.shown) {
+            case 'command':
+                return [{ kind: 'command' }];
+            case 'hidden':
+                return [];
+            case 'message':
+                return [{ kind: 'message', command: decided.command, target: decided.target }];
+            case 'marker':
+                return [{ kind: 'marker', marker: decided.marker, text: decided.text }];
+            case 'subagent':
+                this.subagents.add(call.id);
+                return [{ kind: 'subagent', id: call.id, description: decided.description }];
+        }
+    }
+    produced(_call) {
+        return [];
+    }
+    subagentFinished(call) {
+        this.calls.delete(call.id);
+        return this.finish(call.id, contentText(call.content));
+    }
+    finish(id, result) {
+        if (!this.subagents.has(id) || this.done.has(id))
+            return [];
+        this.done.add(id);
+        this.calls.delete(id);
+        return [{ kind: 'subagent-done', id, result }];
+    }
+}
+class ClaudeReader extends Reader {
+    watchedOptions = { model: 'model' };
+    tasks = new Map();
+    own(message) {
+        if (message.params?.update?._meta?.claudeCode?.parentToolUseId !== undefined)
+            return [];
+        return super.own(message);
+    }
+    update(update) {
+        if (update.sessionUpdate === 'usage_update' && update._meta?.['_claude/origin'] !== undefined) {
+            return [...super.update(update), { kind: 'ended' }];
+        }
+        if (update.sessionUpdate === 'session_info_update' && update._meta?.jetbrains?.air?.sessionFailure !== undefined) {
+            return [{ kind: 'marker', marker: 'retry', text: update._meta.jetbrains.air.sessionFailure.title }];
+        }
+        return super.update(update);
+    }
+    extension(message) {
+        if (message.method !== '_claude/sdkMessage')
+            return [];
+        const sdk = message.params.message;
+        switch (sdk.subtype) {
+            case 'task_started':
+                if (sdk.tool_use_id !== undefined)
+                    this.tasks.set(sdk.task_id, sdk.tool_use_id);
+                return [];
+            case 'task_notification':
+                return sdk.tool_use_id === undefined ? [] : this.finish(sdk.tool_use_id, sdk.summary ?? null);
+            default:
+                return [];
+        }
+    }
+    decide(call, final) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (tool === 'Agent' || tool === 'Task' || call.meta.jetbrains?.air?.subagent === true) {
+            const description = call.rawInput?.description;
+            if (description === undefined && !final)
+                return null;
+            return { shown: 'subagent', description: description ?? call.title ?? '' };
+        }
+        if (tool === 'TodoWrite' || tool === 'CronCreate')
+            return HIDDEN;
+        if (tool === 'ScheduleWakeup') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return call.rawInput.stop === true ? COMMAND : HIDDEN;
+        }
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (tool === 'Bash')
+            return decidedByLine(call.rawInput?.command, final);
+        if (tool === 'SendMessage' || tool === 'TaskStop') {
+            if (call.rawInput === undefined)
+                return final ? COMMAND : null;
+            return names(call.rawInput, this.tasks.keys()) ? HIDDEN : COMMAND;
+        }
+        return COMMAND;
+    }
+    produced(call) {
+        const tool = call.meta.claudeCode?.toolName;
+        if (call.status !== 'completed')
+            return [];
+        if (tool === 'CronCreate' || (tool === 'ScheduleWakeup' && call.rawInput?.stop !== true)) {
+            return [{ kind: 'marker', marker: 'job', text: `${call.rawInput?.prompt ?? call.title ?? ''}: scheduled` }];
+        }
+        return [];
+    }
+    subagentFinished(call) {
+        if (call.meta.claudeCode?.toolResponse?.isAsync === true)
+            return [];
+        return super.subagentFinished(call);
+    }
+}
+const COLLABORATION = new Set(['spawnAgent', 'sendInput', 'resumeAgent', 'wait', 'closeAgent', 'followupTask']);
+class CodexReader extends Reader {
+    watchedOptions = { mode: 'mode', collaboration_mode: 'mode' };
+    children = new Map();
+    own(message) {
+        if (message.method === 'session/request_permission' && message.params.toolCall?.kind === 'switch_mode') {
+            return [{ kind: 'started' }, { kind: 'marker', marker: 'mode', text: message.params.toolCall.title ?? '' }];
+        }
+        return super.own(message);
+    }
+    update(update) {
+        switch (update.sessionUpdate) {
+            case 'session_info_update': {
+                const codex = update._meta?.codex;
+                if (codex?.threadStatus?.type === 'active')
+                    return [{ kind: 'started' }];
+                if (codex?.threadStatus?.type === 'idle')
+                    return [{ kind: 'ended' }];
+                if (codex?.error !== undefined)
+                    return [{ kind: 'marker', marker: 'retry', text: codex.error.message ?? '' }];
+                return [];
+            }
+            case 'notice':
+                return update.severity === 'info' ? [{ kind: 'marker', marker: 'model', text: update.description ?? update.title }] : [];
+            case 'subagent_spawned':
+                this.children.set(update.subagentSessionId, { id: null, text: '' });
+                this.subagents.add(update.subagentSessionId);
+                return [{ kind: 'subagent', id: update.subagentSessionId, description: update.name }];
+            case 'subagent_state_update':
+                return this.finish(update.subagentSessionId, this.children.get(update.subagentSessionId)?.text || null);
+            default:
+                return super.update(update);
+        }
+    }
+    elsewhere(session, message) {
+        const child = this.children.get(session);
+        const update = message.params?.update;
+        if (child === undefined || update === undefined)
+            return [];
+        if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
+            const id = update.messageId ?? null;
+            if (child.id !== id)
+                child.text = '';
+            child.id = id;
+            child.text += update.content.text;
+        }
+        return [];
+    }
+    decide(call) {
+        const air = call.meta.jetbrains?.air;
+        if (COLLABORATION.has(call.title ?? ''))
+            return HIDDEN;
+        if (air?.subagent !== undefined)
+            return { shown: 'subagent', description: call.title ?? '' };
+        if (call.kind === 'switch_mode')
+            return { shown: 'marker', marker: 'mode', text: call.title ?? '' };
+        if (call.kind === 'execute')
+            return decidedByLine(call.rawInput?.command, true);
+        if (call.title === 'Image generation')
+            return HIDDEN;
+        return COMMAND;
+    }
+    produced(call) {
+        if (call.imaged || call.kind === 'read')
+            return [];
+        const image = (call.content ?? []).find((entry) => entry.type === 'content' && entry.content?.type === 'image');
+        if (image === undefined)
+            return [];
+        call.imaged = true;
+        return [{ kind: 'image', data: image.content.data, mediaType: image.content.mimeType }];
+    }
+}
+class GrokReader extends Reader {
+    watchedOptions = {};
+    children = new Map();
+    models = [];
+    model = null;
+    answered(result) {
+        if (result?.models !== undefined)
+            this.offered(result.models);
+        return super.answered(result);
+    }
+    read(message) {
+        const session = message.params?.sessionId;
+        if (this.session !== null && session !== undefined && session !== this.session && !this.children.has(session))
+            return [];
+        if (message.method === '_x.ai/queue/changed') {
+            return (message.params.runningPromptId ?? null) !== null && session === this.session ? [{ kind: 'started' }] : [];
+        }
+        if (message.params?.update?.sessionUpdate === 'turn_completed') {
+            return session === this.session ? [{ kind: 'ended' }] : [];
+        }
+        if (message.method === '_x.ai/models/update') {
+            this.offered(message.params);
+            return [];
+        }
+        return super.read(message);
+    }
+    offered(models) {
+        this.models = models.availableModels ?? this.models;
+        this.model = models.currentModelId ?? this.model;
+    }
+    window() {
+        return this.models.find((model) => model.modelId === this.model)?._meta?.totalContextTokens ?? null;
+    }
+    extension(message) {
+        const update = message.params?.update;
+        switch (message.method) {
+            case '_x.ai/task_backgrounded':
+                return this.job(update.task_id, update.description ?? update.command ?? '', 'running');
+            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: 'marker', marker: 'job', text: `${update.prompt}: next run ${update.next_fire_at}` }];
+            case '_x.ai/session_notification':
+                return this.notification(update);
+            default:
+                return [];
+        }
+    }
+    notification(update) {
+        switch (update.sessionUpdate) {
+            case 'response_completed': {
+                const usage = update.usage;
+                const window = this.window();
+                if (window === null)
+                    return [];
+                const used = usage.input_tokens + (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + usage.output_tokens;
+                return [{ kind: 'context', used, window }];
+            }
+            case 'subagent_spawned': {
+                const call = [...this.calls.values()].find((candidate) => candidate.decided?.shown === 'subagent' &&
+                    ![...this.children.values()].includes(candidate.id) &&
+                    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 [];
+            }
+            case 'subagent_finished': {
+                const call = this.children.get(update.child_session_id);
+                return typeof call === 'string' ? this.finish(call, update.output ?? null) : [];
+            }
+            case 'auto_compact_completed':
+                return [{ kind: 'marker', marker: 'compaction', text: '' }];
+            case 'model_auto_switched':
+                this.model = update.new_model_id;
+                return [{ kind: 'marker', marker: 'model', text: update.new_model_id }];
+            case 'retry_state':
+                return [{ kind: 'marker', marker: 'retry', text: update.message ?? update.reason ?? update.error_type ?? '' }];
+            default:
+                return [];
+        }
+    }
+    decide(call) {
+        const tool = (call.meta['x.ai/tool'] ?? {});
+        if (tool.name === 'spawn_subagent' || tool.kind === 'task') {
+            return { shown: 'subagent', description: call.rawInput?.description ?? call.title ?? '' };
+        }
+        if (tool.name === 'todo_write' || tool.name === 'scheduler_create')
+            return HIDDEN;
+        if (tool.name === 'enter_plan_mode' || tool.name === 'exit_plan_mode') {
+            return { shown: 'marker', marker: 'mode', text: tool.name };
+        }
+        if (tool.name === 'kill_command_or_subagent')
+            return names(call.rawInput, this.children.keys()) ? HIDDEN : COMMAND;
+        if (tool.name === 'run_terminal_command')
+            return decidedByLine(call.rawInput?.command, true);
+        return COMMAND;
+    }
+    subagentFinished(_call) {
+        return [];
+    }
+}
+export function readerFor(kind) {
+    if (kind === 'claude-agent-acp')
+        return new ClaudeReader();
+    if (kind === 'grok-build')
+        return new GrokReader();
+    return new CodexReader();
+}

package/dist/files.js

@@ -1,5 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { HouseRefusal, retrying } from './api.js';
 import { relayed } from './relay.js';
 export async function placeFiles(house, directory, files, signal) {
     const paths = [];
@@ -20,3 +21,16 @@ export async function placeFiles(house, directory, files, signal) {
     }
     return paths;
 }
+export function uploadBytes(upload, bytes) {
+    return retrying(async () => {
+        const answer = await fetch(relayed(upload.url), {
+            method: 'POST',
+            headers: { 'content-type': 'application/octet-stream', 'x-house-byte-operation': upload.operation },
+            body: bytes,
+        });
+        const text = await answer.text();
+        if (!answer.ok)
+            throw new HouseRefusal(upload.url, answer.status, text);
+        return JSON.parse(text);
+    });
+}

package/dist/house-main.js

@@ -3,14 +3,20 @@ import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
 import { request, setGlobalProxyFromEnv } from 'node:http';
 import { basename, join } from 'node:path';
+import { HOUSE_REF } from './git.js';
 import { kitHome, readOwnAgent } from './home.js';
 import { callHouse, rpc, UNREACHABLE } from './mcp.js';
 import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
+import { parse } from 'yaml';
 const USAGE = "usage: house <tool> ['<arguments as JSON>']";
 const PUSH_USAGE = 'usage: house push [commit] [--owner]';
 const PUSH = "push [commit]: sends the Local copy's committed changes to House";
+const FETCH_USAGE = 'usage: house fetch';
+const FETCH = `fetch: records House's changes on each Local copy's ${HOUSE_REF}`;
 const ARGUMENTS = `the arguments are one JSON object in single quotes, like house search '{"query":"invoice"}'`;
 const CLOSED = "this conversation's House connection is closed; nothing to do from here";
+const SANDBOXED = "your CLI's sandbox kept house from House; run house directly, not through another program";
 const REVOKED = 'this conversation no longer has House access; nothing to do from here';
 const UNCONNECTED = "this computer's own agent has no House connection; run kit login";
 const DISCONNECTED = "House no longer accepts this computer's own agent; run kit login";
@@ -42,7 +48,7 @@ function bridged(path, body, headers = { 'content-type': 'application/json' }, t
                     reject(new Error(refused(path, answer.statusCode, text)));
             });
         });
-        sent.on('error', () => reject(new Error(CLOSED)));
+        sent.on('error', (error) => reject(new Error(error.code === 'EPERM' || error.code === 'EACCES' ? SANDBOXED : CLOSED)));
         sent.end(body instanceof Buffer ? body : JSON.stringify(body));
     });
 }
@@ -78,11 +84,24 @@ async function localFile(path) {
             : `${path} is not a readable file`);
     }
 }
+async function sent(url, bytes, operation) {
+    const headers = { 'content-type': 'application/octet-stream', 'x-house-byte-operation': operation };
+    if (socketPath !== undefined)
+        return bridged(url, bytes, headers);
+    setGlobalProxyFromEnv();
+    const answer = await fetch(relayed(url), { method: 'POST', headers, body: bytes }).catch(() => {
+        throw new Error(UNREACHABLE);
+    });
+    const text = await answer.text();
+    if (answer.status === 200)
+        return text;
+    throw new Error(refused(url, answer.status, text));
+}
 async function upload(path, roomRef, missing) {
     if (typeof path !== 'string' || path === '')
         throw new Error(missing);
     const bytes = await localFile(path);
-    const declared = JSON.parse(await bridged('/kit/attachments/upload', {
+    const declared = parse(await called('upload', {
         ...(roomRef === undefined ? {} : { room_ref: roomRef }),
         name: basename(path),
         bytes: bytes.length,
@@ -90,10 +109,7 @@ async function upload(path, roomRef, missing) {
     }));
     if (declared.upload === undefined)
         return declared.attachment;
-    const saved = JSON.parse(await bridged(declared.upload.url, bytes, {
-        'content-type': 'application/octet-stream',
-        'x-house-byte-operation': declared.upload.operation,
-    }));
+    const saved = JSON.parse(await sent(declared.upload.url, bytes, declared.upload.operation));
     if (saved.upload_failure !== undefined)
         throw new Error(`${path} was not saved: ${saved.upload_failure}; call again later`);
     return saved.attachment;
@@ -112,6 +128,14 @@ async function push(args) {
         throw new Error(pushed.text);
     return pushed.text;
 }
+async function fetched(args) {
+    if (args.includes('--help'))
+        return FETCH_USAGE;
+    const answer = JSON.parse(await bridged('/git/fetch', {}, undefined, socketPath ?? join(kitHome(), 'owner.sock')));
+    if (answer.refused)
+        throw new Error(answer.text);
+    return answer.text;
+}
 function argumentsOf(argument) {
     if (argument === undefined)
         return {};
@@ -128,7 +152,7 @@ function argumentsOf(argument) {
 }
 async function house([verb, argument]) {
     if (verb === undefined || verb === '--help' || verb === 'help') {
-        return [USAGE, 'help', PUSH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
+        return [USAGE, 'help', PUSH, FETCH, ...(await tools()).map((tool) => (tool.description === undefined ? tool.name : `${tool.name}: ${tool.description}`))].join('\n');
     }
     if (argument === '--help') {
         const tool = (await tools()).find((listed) => listed.name === verb);
@@ -137,25 +161,30 @@ async function house([verb, argument]) {
         return [...(tool.description === undefined ? [] : [tool.description]), JSON.stringify(tool.inputSchema)].join('\n');
     }
     const args = argumentsOf(argument);
-    if (socketPath !== undefined && verb === 'upload_attachment') {
-        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload_attachment needs "path", a local file') });
+    if (verb === 'upload') {
+        return JSON.stringify({ attachment: await upload(args.path, args.room_ref, 'upload needs "path", a local file') });
     }
-    if (socketPath !== undefined && verb === 'append_record' && Array.isArray(args.attachments)) {
+    if (verb === 'append_record' && Array.isArray(args.attachments)) {
         const attachments = [];
         for (const path of args.attachments) {
             attachments.push(await upload(path, args.room_ref, 'each attachments entry is the path of a local file'));
         }
         args.attachments = attachments;
     }
-    const result = await mcp('tools/call', { name: verb, arguments: args });
+    return called(verb, args);
+}
+async function called(name, args) {
+    const result = await mcp('tools/call', { name, arguments: args });
     const text = result.content.map((content) => content.text).join('\n');
     if (result.isError === true)
         throw new Error(text.replace(/\n+$/, ''));
     return text;
 }
 const argv = process.argv.slice(2);
-(argv[0] === 'push' ? push(argv.slice(1)) : house(argv)).then((text) => {
+(argv[0] === 'push' ? push(argv.slice(1)) : argv[0] === 'fetch' ? fetched(argv.slice(1)) : house(argv)).then((text) => {
     process.stdout.write(`${text}\n`);
+    if (argv[0] === 'shell')
+        process.exitCode = Number(/^exit: (\d+)(?:\n|$)/.exec(text)?.[1] ?? 0);
 }, (error) => {
     process.stderr.write(`house: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;

package/dist/instructions.js

@@ -1,8 +1,9 @@
+import { HOUSE_REF } from './git.js';
 import { HOW_WE_WORK } from './skills.js';
 const HOUSE_LINE = 'Work with House through the `house` CLI: run `house --help`.';
-const FILE_LINE = 'To give the User a file or a page, upload it with `house upload_attachment` and link it; never start a server.';
-const READ_LINE = 'Before working in a Room, read `/private/rooms/<handle>/AGENTS.md`.';
-const COPIES_LINE = 'House Local copies; commit, then `house push`:';
+const FILE_LINE = 'To give the User a file or a page, upload it with `house upload` and link it; never start a server.';
+const READ_LINE = 'Before working in a Room, read `/rooms/private/rooms/<handle>/AGENTS.md`.';
+const COPIES_LINE = `House Local copies; before work run \`house fetch\` and rebase onto \`${HOUSE_REF}\`; after it commit, then \`house push\`:`;
 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: (.+)$/;