@agentshouse/kit 0.2.1-alpha.9 → 0.2.1-c02dacffca87c

package/dist/conversations.js

@@ -1,65 +1,156 @@
 import { client, } from '@agentclientprotocol/sdk';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
-import { killMarked, startAdapter, TURN_ENDED, TURN_STARTED } from './acp.js';
-import { blocksOf, firstChange } from './blocks.js';
+import { unlessAborted } from './abort.js';
+import { signedOut, startAdapter } from './acp.js';
+import { finalRefusal, HouseRefusal } from './api.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
-import { placeFiles } from './files.js';
+import { answeredFailure, readerFor } from './events.js';
+import { inspectedFile, linkedPaths, storeRefusal, uploaded } from './files.js';
+import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
+import { Parts } from './parts.js';
+import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
+import { killMarked, Scope } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
-import { createHowWeWork } from './skills.js';
-const LAUNCH_BASE = '/agents/house';
+import { transcribe } from './transcription.js';
+import { workFor } from './work.js';
 const KILLED = 'the conversation was killed';
+const INTERRUPTED = 'the conversation was interrupted';
+const REFUSED = 'the CLI refused the prompt';
+const NO_CONNECTION = "the Agent's computer could not open this conversation; try again";
+const GONE = 'House no longer holds this conversation; start a new one';
+const RETIRED = "this conversation's Agent is retired, so it cannot start";
+const ENDED = {
+    conversation_not_found: GONE,
+    conversation_historical: RETIRED,
+};
+const NO_START = "the Agent's CLI did not start";
+const NO_SESSION = "the Agent's CLI did not open a session";
+const NO_RESUME = "the Agent's CLI could not resume this conversation";
+const NOT_SIGNED_IN = "the Agent's CLI is not signed in; sign it in on the Agent's machine";
+const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
+const UNSTEERED = "the Agent's CLI did not take the message into its running turn";
+class NotStarted extends Error {
+}
+class ResumeRefused extends NotStarted {
+}
+async function step(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
+    }
+}
+function unopened(reason) {
+    return (error) => (signedOut(error) ? NOT_SIGNED_IN : reason);
+}
+// A start-up step is shown only once it has lasted a second, so a quick start shows none of them.
+const STARTING_SHOWN_AFTER_MS = 1_000;
+function unbridged(error) {
+    return (finalRefusal(error) ? ENDED[refusalOf(error.text)?.code ?? ''] : undefined) ?? NO_CONNECTION;
+}
+const EXIT_PLAN_MODE = {
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error('_x.ai/exit_plan_mode needs an object');
+        }
+        return value;
+    },
+};
+export const CONVERSATION_METHODS = new Set(['open', 'message', 'interrupt', 'kill', 'done', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function answeredWith(error) {
+    return { failure: signedOut(error) ? 'signed_out' : 'error', cause: causeOf(error) };
+}
+function exitedWith(running, cause) {
+    if (running.killed)
+        return { failure: 'killed', cause: KILLED };
+    return { failure: running.adapter.silent() ? 'silent' : 'exited', cause };
+}
 function answerMessage(request, response) {
     return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
 }
+async function sentPart(url, bytes, headers) {
+    const answer = await fetch(relayed(url), { method: 'PUT', headers, body: bytes });
+    await answer.arrayBuffer();
+    if (!answer.ok)
+        throw storeRefusal('upload', answer.status);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
-function unlessKilled(work, signal) {
-    return new Promise((resolve, reject) => {
-        const killed = () => reject(signal.reason);
-        signal.addEventListener('abort', killed, { once: true });
-        if (signal.aborted)
-            killed();
-        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', killed));
-    });
+function refusal(conversation, error) {
+    if (conversation.kills > 0)
+        return KILLED;
+    const cause = error instanceof Error && error.cause !== undefined ? `${error.message}: ${causeOf(error.cause)}` : causeOf(error);
+    logged(new Error(`conversation ${conversation.id} did not start: ${cause}`));
+    return causeOf(error);
+}
+function audioOf(result) {
+    if (result.isError === true)
+        return null;
+    const file = inspectedFile(result.content.map((content) => content.text).join('\n'));
+    return file?.media_type?.startsWith('audio/') === true ? file : null;
 }
-function stop(bridge) {
-    killMarked(`HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`);
+function marker(bridge) {
+    return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
+}
+function steers(adapter) {
+    return adapter.initialized._meta?.steering?.supported === true;
 }
 class Turn {
     id = randomUUID();
-    text = '';
-    sent = [];
-    unsentFrom = null;
-    draftSequence = 0;
-    planSequence = 0;
-    entries = null;
+    parts;
     questions = 0;
     secrets = 0;
-    prompt = null;
+    prompted = false;
+    steered = false;
+    taken = null;
     ended = false;
+    images = 0;
+    uploads = [];
+    constructor(emit) {
+        this.parts = new Parts(emit);
+    }
 }
 class Conversation {
     id;
     running = null;
+    session = null;
     turn = null;
     commands = null;
-    jobs = new Set();
-    queued = [];
-    late = [];
+    options = null;
+    exitUntold = false;
+    context = null;
+    leftovers = new Set();
+    waiting = [];
+    done = false;
+    sending = null;
+    subagents = new Map();
+    held = [];
     opening = null;
+    bridge = null;
+    launch = null;
+    prompted = null;
     kills = 0;
     killed = new AbortController();
-    open = 0;
+    interrupts = 0;
+    interrupted = new AbortController();
+    turns = new Set();
     queue = Promise.resolve();
     reports = Promise.resolve();
+    starting = null;
+    preparing = null;
+    told = null;
+    untold = false;
+    shown = null;
     constructor(id) {
         this.id = id;
     }
@@ -75,51 +166,82 @@ function asksSecret(request) {
 export class Conversations {
     kit;
     conversations = new Map();
-    acks = new Map();
     questions = new Map();
-    carrying = 0;
     reporting = 0;
+    watched = false;
     constructor(kit) {
         this.kit = kit;
+        // A process or a durable schedule ends without a report, so the Kit looks at both again every two seconds.
+        setInterval(() => this.look(), 2_000);
     }
-    input(input) {
-        this.carrying++;
-        const carried = this.acks.get(input.input_id) ??
-            (() => {
-                const conversation = this.conversation(input.conversation_id);
-                if (input.kind === 'kill') {
-                    conversation.kills++;
-                    conversation.killed.abort(new Error(KILLED));
-                    this.halt(conversation);
-                }
-                const work = conversation.queue.then(() => this.carry(conversation, input));
-                conversation.queue = work.catch(() => undefined);
-                this.acks.set(input.input_id, work);
-                return work;
-            })();
-        carried
-            .then((body) => this.kit.house.deliver(`/kit/inputs/${input.input_id}/ack`, body))
-            .catch(logged)
-            .finally(() => {
-            this.carrying--;
-            this.kit.changed();
+    call(call) {
+        void this.kit.calls.carry(call.input_id, () => {
+            const conversation = this.conversation(call.conversation_id);
+            if (call.kind === 'kill') {
+                conversation.kills++;
+                conversation.killed.abort(new Error(KILLED));
+                for (const waiting of conversation.waiting.splice(0))
+                    waiting.settle({ refused: KILLED });
+                this.halt(conversation);
+            }
+            if (call.kind === 'interrupt') {
+                conversation.interrupts++;
+                conversation.interrupted.abort();
+            }
+            const handled = conversation.queue.then(() => this.carry(conversation, call));
+            conversation.queue = handled.catch(() => undefined);
+            return handled.then(async ({ result }) => ({ result: await result }));
         });
     }
     idle() {
-        if (this.carrying > 0 || this.reporting > 0)
+        if (this.reporting > 0)
             return false;
         for (const conversation of this.conversations.values()) {
             const turn = conversation.turn;
             const asking = turn !== null && turn.questions > 0 && turn.secrets === 0;
-            if (conversation.jobs.size > 0 || conversation.open > (asking ? 1 : 0))
+            if (conversation.turns.size > (asking ? 1 : 0))
                 return false;
         }
-        return true;
+        const conversations = [...this.conversations.values()];
+        if (conversations.some((conversation) => conversation.running?.work.busy()))
+            return false;
+        return !conversations.some((conversation) => conversation.running?.scope.working() || [...conversation.leftovers].some((scope) => scope.working()));
+    }
+    quiet() {
+        return this.idle() && [...this.conversations.values()].every((conversation) => conversation.turns.size === 0);
+    }
+    look() {
+        for (const conversation of this.conversations.values()) {
+            for (const scope of conversation.leftovers) {
+                if (!scope.empty())
+                    continue;
+                scope.close();
+                conversation.leftovers.delete(scope);
+            }
+        }
+        this.kit.changed();
     }
     opened() {
+        this.watched = false;
+        for (const conversation of this.conversations.values()) {
+            if (conversation.running !== null) {
+                this.facts(conversation);
+                this.subagentsChanged(conversation);
+            }
+            else if (conversation.exitUntold)
+                this.process(conversation, false);
+            if (conversation.untold || conversation.told !== null)
+                this.retell(conversation);
+        }
+    }
+    watching(watched) {
+        const resend = watched && !this.watched;
+        this.watched = watched;
+        if (!resend)
+            return;
         for (const conversation of this.conversations.values()) {
             if (conversation.turn !== null)
-                conversation.turn.unsentFrom = 0;
+                this.replay(conversation, conversation.turn);
         }
     }
     conversation(id) {
@@ -130,72 +252,320 @@ export class Conversations {
         }
         return conversation;
     }
-    async carry(conversation, input) {
-        if (input.kind === 'open')
-            return this.open(conversation, input);
-        if (input.kind === 'message')
-            return this.message(conversation, input);
-        if (input.kind === 'interrupt')
-            await this.interrupt(conversation, String(input.turn_id));
-        if (input.kind === 'kill') {
+    async carry(conversation, call) {
+        if (call.kind === 'open')
+            return this.open(conversation, call);
+        if (call.kind === 'message')
+            return this.message(conversation, call);
+        if (call.kind === 'done') {
+            conversation.done = true;
+            this.next(conversation);
+            return { result: Promise.resolve({}) };
+        }
+        await this.launched(conversation);
+        if (call.kind === 'interrupt') {
+            if (--conversation.interrupts === 0)
+                conversation.interrupted = new AbortController();
+            await this.interrupt(conversation, String(call.turn_id));
+        }
+        if (call.kind === 'kill') {
             await this.kill(conversation);
+            await conversation.sending;
             if (--conversation.kills === 0)
                 conversation.killed = new AbortController();
         }
-        if (input.kind === 'option')
-            await this.option(conversation, String(input.option), input.value);
-        if (input.kind === 'answer') {
-            const question = this.questions.get(String(input.interaction_id));
+        if (call.kind === 'option')
+            await this.option(conversation, String(call.option), call.value);
+        if (call.kind === 'answer') {
+            const question = this.questions.get(String(call.interaction_id));
             if (question === undefined) {
-                return this.message(conversation, { ...input, text: answerMessage(input.request, input.response), files: [], first: false });
+                const text = answerMessage(call.request, call.response);
+                return this.message(conversation, { ...call, text, first: false, message_id: null });
             }
-            question.answer(input.response);
+            question.answer(call.response);
         }
-        return {};
+        return { result: Promise.resolve({}) };
+    }
+    async open(conversation, call) {
+        await this.stop(conversation);
+        const launch = conversation.launch ?? this.launch(conversation, this.route(conversation, call.agent_id), null, true);
+        return {
+            result: launch.session.then((session) => ({ provider_session_id: session }), (error) => ({ refused: refusal(conversation, error) })),
+        };
+    }
+    async stop(conversation) {
+        const running = conversation.running;
+        running?.scope.kill();
+        await running?.adapter.exited;
+    }
+    launch(conversation, route, sessionId, empty) {
+        let opened;
+        let failed;
+        const bridge = new Promise((resolve, reject) => {
+            opened = resolve;
+            failed = reject;
+        });
+        bridge.catch(() => undefined);
+        const session = this.start(conversation, route, sessionId, empty, opened);
+        session.catch(failed);
+        const launch = { bridge, session };
+        conversation.launch = launch;
+        void session
+            .catch(() => undefined)
+            .then(() => {
+            if (conversation.launch !== launch)
+                return;
+            conversation.launch = null;
+            this.closeIdleBridge(conversation);
+            this.next(conversation);
+        });
+        this.next(conversation);
+        return launch;
+    }
+    async launched(conversation) {
+        while (conversation.launch !== null)
+            await conversation.launch.session.catch(() => undefined);
+    }
+    instructed(conversation, route) {
+        const bridge = conversation.running === null ? conversation.launch?.bridge : Promise.resolve(conversation.running.bridge);
+        if (bridge === undefined)
+            return null;
+        const read = Promise.all([bridge, this.kit.copies.mapping()]).then(([opened, copies]) => instructions(opened, route.base_instructions, copies));
+        read.catch(() => undefined);
+        return read;
     }
-    async open(conversation, input) {
-        if (conversation.running !== null)
-            return {};
+    async message(conversation, call) {
+        const content = [
+            ...(typeof call.recent === 'string' ? [{ type: 'text', text: call.recent }] : []),
+            { type: 'text', text: String(call.text) },
+        ];
+        let route;
+        let instructing = null;
         try {
-            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null) };
+            route = await this.route(conversation, call.agent_id);
+            if (call.first === true)
+                instructing = this.instructed(conversation, route);
+            if (call.message_id !== null)
+                content.push(...(await this.transcribed(conversation, String(call.message_id), String(call.text))));
+            if (conversation.kills > 0)
+                throw new Error(KILLED);
         }
         catch (error) {
-            return { refused: causeOf(error) };
+            this.closeIdleBridge(conversation);
+            this.prepares(conversation, null);
+            return { result: Promise.resolve({ refused: refusal(conversation, error) }) };
+        }
+        conversation.preparing = null;
+        const { promise, resolve: settle } = Promise.withResolvers();
+        const waiting = { call, route, content, instructing, settle };
+        if (call.at_once === true && conversation.turns.size > 0)
+            await this.atOnce(conversation, waiting);
+        else
+            conversation.waiting.push(waiting);
+        this.next(conversation);
+        return { result: promise };
+    }
+    async atOnce(conversation, waiting) {
+        while (conversation.sending !== null)
+            await conversation.sending;
+        const running = conversation.running;
+        if (running !== null && conversation.turns.size > 0 && steers(running.adapter)) {
+            conversation.sending = this.steer(conversation, running, waiting);
+            await conversation.sending;
+            conversation.sending = null;
+            return;
         }
+        this.ahead(conversation, waiting);
+        if (conversation.turns.size > 0)
+            await this.cancel(conversation);
+    }
+    ahead(conversation, waiting) {
+        const behind = conversation.waiting.findIndex((held) => held.call.at_once !== true);
+        conversation.waiting.splice(behind === -1 ? conversation.waiting.length : behind, 0, waiting);
     }
-    async message(conversation, input) {
-        let ack = {};
+    async steer(conversation, running, waiting) {
+        let outcome;
+        try {
+            ({ outcome } = await running.adapter.connection.agent.request('_session/steering', {
+                sessionId: running.sessionId,
+                prompt: waiting.content,
+                _meta: { steering: { idleBehavior: 'promptRequired' } },
+            }));
+        }
+        catch (error) {
+            outcome = error;
+        }
+        if (outcome === 'promptRequired') {
+            this.ahead(conversation, waiting);
+        }
+        else if (outcome === 'injected' || outcome === 'startedNewTurn') {
+            if (outcome === 'injected') {
+                for (const turn of conversation.turns)
+                    turn.steered ||= turn.prompted;
+            }
+            this.kit.calls.keepResult(String(waiting.call.input_id), {});
+            waiting.settle({});
+        }
+        else {
+            const cause = outcome instanceof Error ? outcome : new Error(`the CLI answered ${JSON.stringify(outcome)}`);
+            waiting.settle({ refused: refusal(conversation, new NotStarted(UNSTEERED, { cause })) });
+        }
+    }
+    next(conversation) {
+        if (conversation.sending !== null || conversation.turns.size > 0)
+            return;
+        const waiting = conversation.waiting.shift();
+        if (waiting === undefined) {
+            const step = conversation.preparing ?? (conversation.launch === null ? null : 'session');
+            if (conversation.starting !== step)
+                this.starts(conversation, step);
+            if (conversation.done && conversation.launch === null)
+                void this.stop(conversation).catch(logged);
+            return;
+        }
+        conversation.sending = this.send(conversation, waiting).finally(() => {
+            conversation.sending = null;
+            this.next(conversation);
+        });
+    }
+    async send(conversation, waiting) {
+        const { call } = waiting;
+        let result = {};
+        let started = false;
+        let instructing = waiting.instructing;
         const prompt = [];
         try {
-            const route = await this.route(conversation, input.agent_id);
-            const paths = await placeFiles(this.kit.house, route.working_directory, input.files, conversation.killed.signal);
             if (conversation.running === null) {
-                const opened = await this.start(conversation, route, input.provider_session_id);
-                if (input.provider_session_id === null)
-                    ack = { provider_session_id: opened };
+                this.starts(conversation, 'session');
+                await this.launched(conversation);
+            }
+            if (conversation.running === null) {
+                const stored = conversation.session ?? call.provider_session_id;
+                const empty = call.first === true && conversation.prompted !== stored;
+                const launch = this.launch(conversation, Promise.resolve(waiting.route), stored, empty);
+                if (call.first === true)
+                    instructing = this.instructed(conversation, waiting.route);
+                started = (await launch.session) !== stored;
+            }
+            const session = conversation.running.sessionId;
+            if (started || (call.first === true && session !== call.provider_session_id)) {
+                result = { provider_session_id: session };
             }
-            if (input.first === true) {
-                prompt.push({
-                    type: 'text',
-                    text: await instructions(conversation.running.bridge, route.base_instructions, await this.kit.copies.mapping()),
-                });
+            if (call.first === true) {
+                prompt.push({ type: 'text', text: await (instructing ?? this.instructed(conversation, waiting.route)) });
             }
-            prompt.push({ type: 'text', text: String(input.text) });
-            if (paths.length > 0)
-                prompt.push({ type: 'text', text: paths.join('\n') });
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
         catch (error) {
-            if ('provider_session_id' in ack)
+            this.starts(conversation, null);
+            if (started) {
+                conversation.session = null;
                 await this.kill(conversation);
-            return { refused: conversation.kills > 0 ? KILLED : causeOf(error) };
+            }
+            const refused = refusal(conversation, error);
+            const resumeRefused = call.kind === 'message' && conversation.kills === 0 && error instanceof ResumeRefused;
+            waiting.settle(resumeRefused ? { refused, resume_refused: true } : { refused });
+            return;
+        }
+        this.starts(conversation, null);
+        this.prompt(conversation, [...prompt, ...waiting.content], () => this.kit.calls.keepResult(String(call.input_id), result));
+        waiting.settle(result);
+    }
+    starts(conversation, step) {
+        conversation.starting = step;
+        if (conversation.shown !== null)
+            clearTimeout(conversation.shown);
+        conversation.shown = null;
+        if (step === null || conversation.told !== null) {
+            this.tell(conversation, step);
+            return;
+        }
+        conversation.shown = setTimeout(() => {
+            conversation.shown = null;
+            if (conversation.starting === step)
+                this.tell(conversation, step);
+        }, STARTING_SHOWN_AFTER_MS);
+    }
+    prepares(conversation, step) {
+        conversation.preparing = step;
+        this.next(conversation);
+    }
+    tell(conversation, step) {
+        if (conversation.told === step && !conversation.untold)
+            return;
+        conversation.told = step;
+        this.retell(conversation);
+    }
+    retell(conversation) {
+        conversation.untold = !this.kit.send({ type: 'starting', conversation_id: conversation.id, step: conversation.told });
+    }
+    async transcribed(conversation, messageId, text) {
+        const paths = linkedPaths(text);
+        if (paths.length === 0)
+            return [];
+        const killed = conversation.killed.signal;
+        const interrupted = conversation.interrupted.signal;
+        const transcribing = AbortSignal.any([killed, interrupted]);
+        let signal = killed;
+        const blocks = [];
+        try {
+            const bridge = await step(unbridged, unlessAborted(this.bridged(conversation), killed));
+            const read = async (path) => audioOf(await step(unbridged, unlessAborted(bridge.tool('inspect', { path }), signal)));
+            for (const path of paths) {
+                let answered = await read(path);
+                if (answered === null)
+                    continue;
+                signal = transcribing;
+                this.prepares(conversation, 'transcription');
+                const said = await transcribe(async () => {
+                    const address = answered ?? (await read(path));
+                    answered = null;
+                    if (address === null)
+                        throw new Error(`${path} is no longer an audio file`);
+                    return address;
+                }, signal);
+                const transcript = `/kit/conversations/${conversation.id}/messages/${messageId}/transcripts`;
+                await step(unbridged, unlessAborted(this.kit.house.deliver(transcript, { path, text: said }, () => !signal.aborted), signal));
+                blocks.push({ type: 'text', text: `${path}\nTranscript: ${said}` });
+            }
+        }
+        catch (error) {
+            if (signal === transcribing && interrupted.aborted && conversation.kills === 0)
+                throw new NotStarted(INTERRUPTED, { cause: error });
+            throw error;
+        }
+        return blocks;
+    }
+    bridged(conversation) {
+        if (conversation.bridge === null) {
+            const bridging = openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
+            conversation.bridge = bridging;
+            bridging.catch(() => {
+                if (conversation.bridge === bridging)
+                    conversation.bridge = null;
+            });
         }
-        this.prompt(conversation, prompt);
-        return ack;
+        return conversation.bridge;
+    }
+    closeBridge(conversation, bridging, bridge) {
+        bridge.close();
+        if (conversation.bridge === bridging)
+            conversation.bridge = null;
+    }
+    closeIdleBridge(conversation) {
+        const bridging = conversation.bridge;
+        if (bridging === null || conversation.running !== null || conversation.launch !== null)
+            return;
+        conversation.bridge = null;
+        void bridging.then((bridge) => bridge.close(), () => undefined);
     }
     async interrupt(conversation, turnId) {
-        if (conversation.running === null || conversation.turn?.id !== turnId)
+        if ([...conversation.turns].some((turn) => turn.id === turnId))
+            await this.cancel(conversation);
+    }
+    async cancel(conversation) {
+        if (conversation.running === null)
             return;
         await conversation.running.adapter.connection.agent.notify('session/cancel', {
             sessionId: conversation.running.sessionId,
@@ -203,11 +573,13 @@ export class Conversations {
     }
     halt(conversation) {
         if (conversation.opening !== null)
-            stop(conversation.opening);
+            killMarked(marker(conversation.opening));
+        for (const scope of conversation.leftovers)
+            scope.kill();
         if (conversation.running === null)
             return;
         conversation.running.killed = true;
-        stop(conversation.running.bridge);
+        conversation.running.scope.kill();
     }
     async kill(conversation) {
         const running = conversation.running;
@@ -219,6 +591,7 @@ export class Conversations {
         if (running === null)
             return;
         try {
+            running.reader.requested(option, value);
             const answered = await running.adapter.connection.agent.request('session/set_config_option', {
                 sessionId: running.sessionId,
                 configId: option,
@@ -227,73 +600,99 @@ export class Conversations {
             this.options(conversation, answered.configOptions);
         }
         catch (error) {
+            running.reader.refused(option);
             logged(error);
         }
     }
     async route(conversation, agentId) {
         const signal = conversation.killed.signal;
-        await unlessKilled(this.kit.agents.read(), signal);
+        await unlessAborted(this.kit.agents.read(), signal);
         if (this.kit.agents.route(agentId) === undefined)
-            await unlessKilled(this.kit.agents.refresh(), signal);
+            await unlessAborted(this.kit.agents.refresh(), signal);
         const route = this.kit.agents.route(agentId);
         if (route === undefined)
             throw new Error(`this Environment hosts no Agent ${agentId}`);
-        if (route.working_directory === join(LAUNCH_BASE, route.agent_id)) {
+        if (route.working_directory === join(agentBase(), route.agent_id)) {
             await mkdir(route.working_directory, { recursive: true });
         }
         return route;
     }
-    async start(conversation, route, sessionId) {
+    async start(conversation, routed, sessionId, empty, bridged) {
+        const route = await routed;
+        const reader = readerFor(route.kind);
+        reader.session = sessionId;
         const app = client({ name: '@agentshouse/kit' })
-            .onNotification('session/update', ({ params }) => this.update(conversation, params))
-            .onNotification(TURN_STARTED, (params) => params, () => void this.started(conversation))
-            .onNotification(TURN_ENDED, (params) => params, () => this.ended(conversation))
             .onRequest('session/request_permission', ({ params, signal }) => this.ask(conversation, 'session/request_permission', params, false, signal))
-            .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal));
-        await unlessKilled(this.kit.agents.installed(), conversation.killed.signal);
-        const bridge = await openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
+            .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal))
+            .onRequest('_x.ai/exit_plan_mode', EXIT_PLAN_MODE, ({ params, signal }) => this.ask(conversation, '_x.ai/exit_plan_mode', params, false, signal));
+        const cli = await unlessAborted(this.kit.agents.cli(route.kind), conversation.killed.signal);
+        const bridging = this.bridged(conversation);
+        const bridge = await step(unbridged, bridging);
         if (conversation.kills > 0) {
-            bridge.close();
+            this.closeBridge(conversation, bridging, bridge);
             throw new Error(KILLED);
         }
         conversation.opening = bridge;
+        const work = workFor(route.kind, route.working_directory, () => this.kit.changed());
+        const scope = new Scope(marker(bridge), randomUUID(), cli);
+        let adapter = null;
         try {
-            await unlessKilled(createHowWeWork(bridge), conversation.killed.signal);
-            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
-            void adapter.exited.then(() => bridge.close());
+            bridged(bridge);
+            await CLIS[route.kind].allowHouse(bridge.env.PATH);
+            const streamed = await step(NO_CONNECTION, work.open(cli));
+            adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+                work.read(message);
+                this.read(conversation, reader, message);
+            }, { ...bridge.env, ...streamed }, undefined, scope));
+            void adapter.exited.then(() => this.closeBridge(conversation, bridging, bridge));
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
-            const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [] })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [] })), sessionId };
-            const running = {
-                adapter,
-                bridge,
-                sessionId: opened.sessionId,
-                killed: false,
-                queues: CLIS[route.kind].queues,
-            };
-            const options = await this.launchSettings(running, route, opened.configOptions ?? []);
+            const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
+            const resumed = sessionId === null ? null : await this.resume(conversation, route.kind, adapter, { sessionId, cwd, mcpServers: [], _meta }, empty);
+            const opened = resumed ?? (await step(unopened(NO_SESSION), agent.request('session/new', { cwd, mcpServers: [], _meta })));
+            reader.session = opened.sessionId;
+            if (opened.sessionId !== sessionId && CLIS[route.kind].renames) {
+                const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
+                await step(unopened(NO_SESSION), agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
+            }
+            const running = { adapter, bridging, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
+            const options = await step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
+            void work.settled().then(() => scope.record());
             conversation.running = running;
-            this.kit.send({ type: 'process', conversation_id: conversation.id, running: true });
-            if (conversation.commands !== null)
-                this.commands(conversation, conversation.commands);
-            this.options(conversation, options);
-            void adapter.exited.then((cause) => this.exited(conversation, adapter, cause));
+            adapter.turn(conversation.turns.size > 0);
+            conversation.session = running.sessionId;
+            conversation.options = options;
+            this.facts(conversation);
+            void adapter.lost.then((cause) => this.exited(conversation, running, cause));
             return running.sessionId;
         }
         catch (error) {
-            stop(bridge);
-            bridge.close();
+            adapter?.retire();
+            work.close();
+            conversation.leftovers.add(scope);
+            this.closeBridge(conversation, bridging, bridge);
             throw conversation.kills > 0 ? new Error(KILLED) : error;
         }
         finally {
             conversation.opening = null;
         }
     }
+    async resume(conversation, kind, adapter, request, empty) {
+        try {
+            return { ...(await adapter.connection.agent.request('session/resume', request)), sessionId: request.sessionId };
+        }
+        catch (error) {
+            if (!empty || conversation.kills > 0 || !CLIS[kind].unknownSession(error)) {
+                throw signedOut(error) ? new NotStarted(NOT_SIGNED_IN, { cause: error }) : new ResumeRefused(NO_RESUME, { cause: error });
+            }
+            logged(new Error(`conversation ${conversation.id} opens a new session: ${NO_RESUME}: ${causeOf(error)}`));
+            return null;
+        }
+    }
     async launchSettings(running, route, offered) {
         let options = offered;
         const settings = [
+            ['mode', route.mode ?? CLIS[route.kind].fullAccess],
             ['model', route.model],
             ['thought_level', route.effort],
         ];
@@ -301,6 +700,7 @@ export class Conversations {
             if (value === null)
                 continue;
             const option = options.find((candidate) => candidate.category === category);
+            running.reader.requested(option?.id ?? category, value);
             const answered = await running.adapter.connection.agent.request('session/set_config_option', {
                 sessionId: running.sessionId,
                 configId: option?.id ?? category,
@@ -310,23 +710,45 @@ export class Conversations {
         }
         return options;
     }
-    exited(conversation, adapter, cause) {
-        const running = conversation.running;
-        if (running?.adapter !== adapter)
-            return;
+    exited(conversation, running, cause) {
+        this.detach(conversation, running);
+        if (conversation.turn !== null) {
+            this.end(conversation, conversation.turn, exitedWith(running, cause));
+        }
+        this.next(conversation);
+        this.kit.changed();
+    }
+    detach(conversation, running) {
+        if (conversation.bridge === running.bridging)
+            conversation.bridge = null;
+        running.work.close();
+        conversation.leftovers.add(running.scope);
         conversation.running = null;
         conversation.commands = null;
-        conversation.jobs.clear();
-        conversation.queued.length = 0;
+        conversation.options = null;
+        if (conversation.subagents.size > 0) {
+            conversation.subagents.clear();
+            this.subagentsChanged(conversation);
+        }
         for (const [id, question] of this.questions) {
             if (question.conversation === conversation)
                 this.questions.delete(id);
         }
-        this.kit.send({ type: 'process', conversation_id: conversation.id, running: false });
-        if (conversation.turn !== null) {
-            this.end(conversation, conversation.turn, { failed: running.killed ? KILLED : cause });
-        }
-        this.kit.changed();
+        this.process(conversation, false);
+    }
+    process(conversation, running) {
+        conversation.exitUntold = !this.kit.send({ type: 'process', conversation_id: conversation.id, running }) && !running;
+    }
+    facts(conversation) {
+        this.process(conversation, true);
+        if (conversation.commands !== null)
+            this.commands(conversation, conversation.commands);
+        if (conversation.options !== null)
+            this.options(conversation, conversation.options);
+    }
+    subagentsChanged(conversation) {
+        const subagents = [...conversation.subagents.values()].map(({ description, activity }) => ({ description, activity }));
+        this.kit.send({ type: 'subagents', conversation_id: conversation.id, subagents });
     }
     commands(conversation, commands) {
         conversation.commands = commands;
@@ -337,11 +759,12 @@ export class Conversations {
     options(conversation, options) {
         if (conversation.running === null)
             return;
+        conversation.options = options;
         this.kit.send({ type: 'options', conversation_id: conversation.id, options });
     }
     deliver(conversation, turn, event, body) {
         this.reporting++;
-        const delivered = conversation.reports.then(() => this.kit.house.deliver(`/kit/conversations/${conversation.id}/turns/${turn.id}/${event}`, body));
+        const delivered = conversation.reports.then(async () => this.kit.house.deliver(`/kit/conversations/${conversation.id}/turns/${turn.id}/${event}`, await body));
         conversation.reports = delivered
             .catch(() => undefined)
             .finally(() => {
@@ -350,108 +773,103 @@ export class Conversations {
         });
         return delivered;
     }
-    report(conversation) {
-        const turn = new Turn();
-        conversation.open++;
-        void this.deliver(conversation, turn, 'started', {})
-            .then(() => this.admitted(conversation, turn))
-            .catch(logged);
-        return turn;
+    write(conversation, turn, operation) {
+        if (turn.ended || !this.watched)
+            return;
+        this.kit.send({ type: 'turn', conversation_id: conversation.id, turn_id: turn.id, ...operation });
     }
-    admitted(conversation, turn) {
-        if (turn.text !== '') {
-            turn.unsentFrom = 0;
-            this.draft(conversation, turn);
-        }
-        if (turn.entries !== null)
-            this.plan(conversation, turn);
+    replay(conversation, turn) {
+        for (const operation of turn.parts.operations())
+            this.write(conversation, turn, operation);
     }
     begin(conversation) {
-        const turn = this.report(conversation);
+        const turn = new Turn((operation) => this.write(conversation, turn, operation));
+        conversation.turns.add(turn);
+        conversation.running?.adapter.turn(true);
+        void this.deliver(conversation, turn, 'started', {}).catch(logged);
         conversation.turn = turn;
+        if (conversation.context !== null)
+            turn.parts.measure(conversation.context);
+        for (const part of conversation.held.splice(0))
+            turn.parts.start(part);
         this.kit.changed();
         return turn;
     }
-    end(conversation, turn, outcome) {
+    end(conversation, turn, failed, notice = null) {
         if (turn.ended)
             return;
+        if (failed !== null)
+            logged(new Error(`conversation ${conversation.id} turn ${turn.id} failed: ${failed.cause}`));
+        if (conversation.turn === turn) {
+            for (const event of conversation.running?.reader.closeTurn() ?? [])
+                this.apply(conversation, turn, event);
+        }
+        if (notice !== null)
+            turn.parts.start({ type: 'marker', marker: 'retry', text: notice });
         turn.ended = true;
-        conversation.open--;
+        conversation.turns.delete(turn);
+        conversation.running?.adapter.turn(conversation.turns.size > 0);
         if (conversation.turn === turn)
             conversation.turn = null;
-        void this.deliver(conversation, turn, 'ended', outcome).catch(logged);
-        const late = conversation.open === 0 ? conversation.late.shift() : undefined;
-        if (late !== undefined)
-            this.failed(conversation, late);
+        const body = Promise.allSettled(turn.uploads).then(() => ({
+            parts: turn.parts.saved(),
+            context: turn.parts.context,
+            ...(failed === null ? {} : { failed: failed.failure }),
+        }));
+        void this.deliver(conversation, turn, 'ended', body).catch(logged);
+        this.next(conversation);
         this.kit.changed();
     }
-    failed(conversation, cause) {
-        if (conversation.open > 0)
-            conversation.late.push(cause);
-        else
-            this.end(conversation, this.report(conversation), { failed: cause });
-    }
-    prompt(conversation, prompt) {
+    prompt(conversation, prompt, taken) {
         const running = conversation.running;
-        const sent = { turn: null };
-        if (running.queues && (conversation.turn !== null || conversation.queued.length > 0)) {
-            conversation.queued.push(sent);
-        }
-        else {
-            this.attach(conversation.turn ?? this.begin(conversation), sent);
-        }
-        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then(() => this.answered(conversation, sent, null), async (error) => {
-            if (!running.adapter.connection.signal.aborted)
-                this.answered(conversation, sent, causeOf(error));
-            else if (sent.turn !== null) {
-                this.end(conversation, sent.turn, { failed: running.killed ? KILLED : await running.adapter.exited });
+        const turn = this.begin(conversation);
+        turn.prompted = true;
+        turn.taken = taken;
+        conversation.prompted = running.sessionId;
+        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
+            this.took(turn);
+            const notice = answeredFailure(answer);
+            if (notice !== null) {
+                this.end(conversation, turn, { failure: notice.limit ? 'limit' : 'error', cause: notice.title }, notice.title);
+            }
+            else {
+                this.end(conversation, turn, answer.stopReason === 'refusal' ? { failure: 'refused', cause: REFUSED } : null);
+            }
+        }, async (error) => {
+            if (running.adapter.connection.signal.aborted) {
+                this.end(conversation, turn, exitedWith(running, await running.adapter.exited));
+            }
+            else {
+                this.took(turn);
+                if (conversation.turns.size === 1 && conversation.turns.has(turn) && conversation.running === running) {
+                    running.adapter.retire();
+                    this.detach(conversation, running);
+                }
+                this.end(conversation, turn, answeredWith(error));
             }
         });
     }
-    attach(turn, sent) {
-        turn.prompt = sent;
-        sent.turn = turn;
-    }
-    answered(conversation, sent, failed) {
-        const turn = sent.turn;
-        if (turn === null) {
-            const queued = conversation.queued.indexOf(sent);
-            if (queued < 0)
-                return;
-            conversation.queued.splice(queued, 1);
-            if (failed !== null)
-                this.failed(conversation, failed);
-        }
-        else if (failed !== null) {
-            if (turn.ended)
-                this.failed(conversation, failed);
-            else
-                this.end(conversation, turn, { failed });
-        }
-        else if (turn.prompt === sent) {
-            this.end(conversation, turn, { text: turn.text });
-        }
-    }
     started(conversation) {
-        if (conversation.turn !== null)
-            return conversation.turn;
-        const turn = this.begin(conversation);
-        const queued = conversation.queued.shift();
-        if (queued !== undefined)
-            this.attach(turn, queued);
+        const turn = conversation.turn ?? this.begin(conversation);
+        this.took(turn);
         return turn;
     }
-    ended(conversation) {
+    ended(conversation, stop) {
         const turn = conversation.turn;
         if (turn === null)
             return;
-        if (turn.prompt === null) {
-            this.end(conversation, turn, { text: turn.text });
-        }
-        else {
-            conversation.turn = null;
-            this.kit.changed();
+        const held = stop !== null && !turn.steered && [...conversation.subagents.values()].some((subagent) => subagent.turn === turn);
+        if (!turn.prompted || held) {
+            this.took(turn);
+            this.end(conversation, turn, stop === 'refusal' ? { failure: 'refused', cause: REFUSED } : null);
+            return;
         }
+        if (stop !== null)
+            return;
+        for (const event of conversation.running?.reader.closeTurn() ?? [])
+            this.apply(conversation, turn, event);
+        conversation.turn = null;
+        this.kit.changed();
     }
     async ask(conversation, method, params, secret, signal) {
         const turn = this.started(conversation);
@@ -497,65 +915,126 @@ export class Conversations {
         if (content !== null)
             this.questions.get(interactionId)?.answer({ action: 'accept', content });
     }
-    update(conversation, notification) {
-        const update = notification.update;
-        if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
-            const turn = this.started(conversation);
-            turn.text += update.content.text;
-            this.draft(conversation, turn);
-        }
-        else if (update.sessionUpdate === 'plan') {
-            const turn = this.started(conversation);
-            turn.entries = update.entries;
-            this.plan(conversation, turn);
-        }
-        else if (update.sessionUpdate === 'agent_thought_chunk' || update.sessionUpdate === 'tool_call') {
-            this.started(conversation);
-        }
-        else if (update.sessionUpdate === 'available_commands_update') {
-            this.commands(conversation, update.availableCommands);
+    read(conversation, reader, message) {
+        for (const event of reader.read(message))
+            this.event(conversation, event);
+    }
+    event(conversation, event) {
+        switch (event.kind) {
+            case 'started':
+                this.started(conversation);
+                return;
+            case 'ended':
+                this.ended(conversation, event.stop);
+                return;
+            case 'commands':
+                this.commands(conversation, event.commands);
+                return;
+            case 'options':
+                this.options(conversation, event.options);
+                return;
+            case 'context':
+                conversation.context = { used: event.used, window: event.window };
+                conversation.turn?.parts.measure(conversation.context);
+                return;
+            case 'subagent-done':
+                this.subagentDone(conversation, event.id, event.result);
+                return;
+            case 'subagent-activity':
+                this.subagentActivity(conversation, event.id, event.activity);
+                return;
+            case 'marker':
+            case 'image':
+                if (conversation.turn !== null)
+                    break;
+                if (event.kind === 'marker' && event.marker === 'job')
+                    conversation.held.push({ type: 'marker', marker: 'job', text: event.text });
+                return;
         }
-        else if (update.sessionUpdate === 'config_option_update') {
-            this.options(conversation, update.configOptions);
+        this.apply(conversation, this.started(conversation), event);
+    }
+    took(turn) {
+        const taken = turn.taken;
+        turn.taken = null;
+        taken?.();
+    }
+    apply(conversation, turn, event) {
+        switch (event.kind) {
+            case 'text':
+            case 'reasoning':
+                turn.parts.write(event.kind, event.id, event.text);
+                return;
+            case 'command':
+                turn.parts.command();
+                return;
+            case 'subagent': {
+                const index = turn.parts.start({ type: 'subagent', description: event.description, status: 'running', result: null });
+                conversation.subagents.set(event.id, { description: event.description, turn, index, activity: null });
+                this.subagentsChanged(conversation);
+                return;
+            }
+            case 'message':
+                turn.parts.start({ type: 'message', command: event.command, target: event.target });
+                return;
+            case 'marker':
+                turn.parts.start({ type: 'marker', marker: event.marker, text: event.text });
+                return;
+            case 'plan':
+                turn.parts.plan(event.entries);
+                return;
+            case 'image':
+                turn.uploads.push(this.image(conversation, turn, turn.parts.reserve(), event.data, event.mediaType));
+                this.kit.changed();
+                return;
         }
     }
-    job(conversation, job) {
-        if (job.running)
-            conversation.jobs.add(job.id);
+    subagentDone(conversation, id, result) {
+        const subagent = conversation.subagents.get(id);
+        if (subagent === undefined)
+            return;
+        conversation.subagents.delete(id);
+        this.subagentsChanged(conversation);
+        if (subagent.turn === conversation.turn) {
+            subagent.turn.parts.done(subagent.index, result);
+            return;
+        }
+        const part = { type: 'subagent', description: subagent.description, status: 'done', result };
+        if (conversation.turn === null)
+            conversation.held.push(part);
         else
-            conversation.jobs.delete(job.id);
-        this.kit.changed();
+            conversation.turn.parts.start(part);
     }
-    draft(conversation, turn) {
-        const blocks = blocksOf(turn.text);
-        const from = Math.min(firstChange(turn.sent, blocks), turn.unsentFrom ?? Infinity);
-        const sent = this.kit.send({
-            type: 'draft',
-            conversation_id: conversation.id,
-            turn_id: turn.id,
-            sequence: turn.draftSequence + 1,
-            from,
-            blocks: blocks.slice(from),
-        });
-        if (sent) {
-            turn.draftSequence++;
-            turn.sent = blocks;
-            turn.unsentFrom = null;
+    subagentActivity(conversation, id, activity) {
+        const subagent = conversation.subagents.get(id);
+        if (subagent === undefined || subagent.activity === activity)
+            return;
+        subagent.activity = activity;
+        this.subagentsChanged(conversation);
+    }
+    async image(conversation, turn, reserved, data, mediaType) {
+        const bytes = Buffer.from(data, 'base64');
+        const name = `image-${++turn.images}.${mediaType.split('/')[1]}`;
+        const sha256 = createHash('sha256').update(bytes).digest('hex');
+        try {
+            const declared = (await this.deliver(conversation, turn, 'images', {
+                name,
+                media_type: mediaType,
+                bytes: bytes.length,
+                sha256,
+            }));
+            const saved = await uploaded(declared.upload, {
+                name,
+                bytes: bytes.length,
+                sha256,
+                read: (start, end) => [bytes.subarray(start, end)],
+                send: (url, start, end, headers) => sentPart(url, bytes.subarray(start, end), headers),
+                finish: (upload, partSha256) => this.kit.house.deliver('/kit/uploads/finish', { upload, part_sha256: partSha256 }),
+            });
+            turn.parts.arrive({ type: 'image', file: saved.path, name, media_type: mediaType }, reserved);
         }
-        else {
-            turn.unsentFrom = from;
+        catch (error) {
+            const cause = error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+            turn.parts.arrive({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${cause}` }, reserved);
         }
     }
-    plan(conversation, turn) {
-        const sent = this.kit.send({
-            type: 'plan',
-            conversation_id: conversation.id,
-            turn_id: turn.id,
-            sequence: turn.planSequence + 1,
-            from: 0,
-            steps: turn.entries.map((entry) => ({ label: entry.content, priority: entry.priority, status: entry.status })),
-        });
-        if (sent)
-            turn.planSequence++;
-    }
 }