@corenel/tools-web 0.8.0 → 0.10.0

package/dist/runtime.js

@@ -1,5 +1,6 @@
 import { createWorkerAgent } from './workerClient';
 import { nodeUsageOf } from './nodeUsage';
+import { publishSubagentEvent, publishSubagentParentEnded } from './subagentBus';
 import { foldLive } from './liveFold';
 import { createRunWatchdog } from './runWatchdog';
 import { listDocs, deleteDocsForSession } from './contextDocs';
@@ -11,15 +12,16 @@ import { sessionSystemPrompt } from './sessionSystemPrompt';
 import { sessionSystemConfig, freezeSessionSystemConfig, clearSessionSystemConfig } from './sessionSystemConfig';
 import { stateDirName, sessionsRoot, isCheckpointTool, unpricedCalleeRefusal } from '@corenel/protocol';
 import { listSystemPrompts, resolveSystemPrompt, readSystemPromptSource } from '@corenel/harness/prompts/systemPrompts';
-import { turnsFromSessionMessages } from '@corenel/harness/conversation';
+import { turnsFromSessionMessages, foldPoint, isFoldedTurn } from '@corenel/harness/conversation';
 import { allTools } from '@corenel/harness/tools/builtins';
 import { applyTodoWrite, addActivity, resolveActivity } from '@corenel/harness/todos';
 import { getPolicy, STANDARD_POLICY } from '@corenel/harness/guardrail';
 import { composeAgentSystem, TOOLS_MARKER } from '@corenel/harness/prompts';
 import { getSystemParts } from '@corenel/harness/systemParts';
-import { CHECKPOINT_MARKER } from '@corenel/harness/core/compactHistory';
+import { CHECKPOINT_MARKER, estimateTokens, COMPACT_AT_FILL } from '@corenel/harness/core/compactHistory';
 import { priceUsageWith, pricedForUsd } from '@corenel/harness/core/pricing';
 import { enabledSkillCatalog } from '@corenel/harness/skills';
+import { alog } from '@corenel/harness/log';
 // The agent's model is the user's picker selection (getModel) — a real
 // catalog entry, so pricing/context come from host.modelInfo, not hardcoded figures.
 const WATCHDOG_MS = 45000;
@@ -34,7 +36,8 @@ function emptyInternal() {
         pendingPerm: null, pendingAsk: null, approvalSuggestion: null, loaded: false, suggestions: [], recovery: null, abort: null, toolMs: {}, allowed: new Set(),
         pendingCommand: null, runId: null,
         recEvents: [], injectedIds: [], lastUsage: { promptTokens: 0, completionTokens: 0 },
-        offloadTick: 0, policyNotes: [], degradedModel: null,
+        offloadTick: 0, policyNotes: [], degradedModel: null, model: null, modelNotice: null, persistedLen: null,
+        saveBlocked: null, loadMissed: false, mergeTick: 0,
     };
 }
 /** Build the user message — a plain string, or multimodal parts when images are attached. */
@@ -62,6 +65,35 @@ function userImages(m) {
         return [];
     return m.content.filter((p) => p.type === 'image_url').map((p) => ('image_url' in p ? p.image_url.url : '')).filter(Boolean);
 }
+/** What a send hands the run: the raw included transcript, or -- once a run
+ * has folded -- the newest LIVE seam's folded view plus the included turns
+ * after the user turn that produced it. Turns at or before that turn are
+ * already in the view; sending them raw again re-folded the whole history
+ * every send. A view whose user turn is gone is skipped for the one before it,
+ * and with no live view at all the transcript goes raw (the next run re-folds). */
+function outgoingMessages(turns) {
+    const fp = foldPoint(turns);
+    if (fp)
+        return [...fp.view, ...turns.slice(fp.throughIndex + 1).filter((t) => t.included).flatMap((t) => t.messages)];
+    return turns.filter((t) => t.included).flatMap((t) => t.messages);
+}
+/** Stamp a run's folded view on its newest seam, and keep exactly ONE older
+ * view: each is a full copy of the window and persist rewrites every turn on
+ * every send, so views left on every seam grow without bound in a chat that
+ * never ends. The one kept is what `retry` of the folding turn falls back to
+ * (retry removes the newest seam with its user turn). */
+function stampFoldedView(turns, seamId, view, through) {
+    const older = turns.filter((t) => t.foldedView && t.id !== seamId).map((t) => t.id);
+    const keep = older[older.length - 1];
+    return turns.map((t) => {
+        if (t.id === seamId)
+            return { ...t, foldedView: view, foldedThrough: through };
+        if (!t.foldedView || t.id === keep)
+            return t;
+        const { foldedView: _view, foldedThrough: _through, ...rest } = t;
+        return rest;
+    });
+}
 /** Merge a form's freshly-emitted envelope into a per-run override, against the
  * currently saved default. The form only emits the keys it still wants set — a
  * cleared field (e.g. "No limit") is simply ABSENT from `emitted`, not `undefined`.
@@ -127,6 +159,14 @@ export class AgentRuntime {
             writable: true,
             value: getTemperature
         });
+        /** Stops the catalog listener the constructor installed. Only dispose()
+         * calls it: reset() keeps a long-lived runtime listening. */
+        Object.defineProperty(this, "offModels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         Object.defineProperty(this, "map", {
             enumerable: true,
             configurable: true,
@@ -157,9 +197,9 @@ export class AgentRuntime {
             writable: true,
             value: null
         });
-        /** Reuse the most-recent empty session if there is one, else create a fresh one.
-         * Returns the id to focus on page open — keeps a single throwaway "New chat"
-         * around instead of breeding empties. Concurrent calls are deduped (React
+        /** Reuse the most-recent empty saved session if there is one, else open a
+         * DRAFT (newDraft): opening the app, or landing after a delete, saves
+         * nothing until the user first sends. Concurrent calls are deduped (React
          * StrictMode double-invokes the mount effect) so the page never opens two. */
         Object.defineProperty(this, "initInFlight", {
             enumerable: true,
@@ -167,6 +207,52 @@ export class AgentRuntime {
             writable: true,
             value: null
         });
+        /* DRAFT CHATS. A draft is a chat id held only here: loaded, empty, in no
+         * store and so in no chat list. Its first write (the first send, or a note,
+         * a kept console command, /memory) creates it in the store under the SAME
+         * id (materialize), so nothing that already holds the id has to move. A
+         * model picked on a draft stays in memory and is saved with it. Its system
+         * config is frozen then too, so abandoned drafts leave nothing behind. */
+        Object.defineProperty(this, "drafts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "materializing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        /* The chat's estimated size in tokens, keyed by the turns array: turns are
+         * replaced, never mutated, so the same array means the same size. The picker
+         * asks canHold for every row on every render; this keeps that one flatten
+         * per transcript, not one per row. */
+        Object.defineProperty(this, "fill", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
+        /* ---- run ---- */
+        /* One store write at a time per session: every read-modify-write of the
+         * stored chat (persist, the first-send retitle) goes through here. Each
+         * re-reads the session first; two overlapping would let one read the other's
+         * write before persistedLen caught up and take it for another writer, or
+         * write back a list the other had just shortened (a retitle restoring a
+         * cleared chat, R37). */
+        Object.defineProperty(this, "writing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // Availability and the fallback are read live, so every open chat's
+        // notice must re-render when either moves.
+        if (host.perChatModel)
+            this.offModels = host.onModelsChange?.(() => { for (const id of this.subs.keys())
+                this.notify(id); }) ?? null;
     }
     ws() {
         if (!this._ws)
@@ -244,7 +330,13 @@ export class AgentRuntime {
         return () => { set.delete(cb); };
     }
     subscribeGlobal(cb) { this.globalSubs.add(cb); return () => { this.globalSubs.delete(cb); }; }
-    getState(id) { return this.map.get(id) ?? emptyInternal(); }
+    getState(id) {
+        const s = this.map.get(id);
+        if (!s)
+            return emptyInternal();
+        s.modelNotice = this.modelNotice(id, s);
+        return s;
+    }
     status(id) {
         const s = this.map.get(id);
         if (!s)
@@ -271,8 +363,31 @@ export class AgentRuntime {
         const s = this.ensure(id);
         if (s.loaded)
             return;
-        const ses = await this.host.sessions.get(id);
-        s.turns = turnsFromSessionMessages(ses?.messages);
+        /* A read that THROWS is a miss, not an error for the caller: send awaits
+         * this, and a rejected load would drop the send outright while the next
+         * attempt fails the same way. As a miss it goes down the path that is
+         * covered: the exchange runs, saveBlocked says it is not kept, and Retry
+         * (retryLoad) reads again. */
+        let ses;
+        try {
+            ses = await this.host.sessions.get(id);
+        }
+        catch {
+            ses = null;
+        }
+        // A concurrent load (the focus effect beside a send) landed first, and its
+        // merge already holds everything; merging again would double the chat.
+        if (s.loaded)
+            return;
+        /* MERGE, never replace: anything this page added before the stored chat
+         * arrived -- a /model notice, say -- comes after it rather than vanishing.
+         * A miss leaves those turns alone too. */
+        const pre = s.turns;
+        if (ses) {
+            s.turns = [...turnsFromSessionMessages(ses.messages), ...pre];
+            s.persistedLen = ses.messages.length;
+        }
+        s.model = ses?.model ?? null;
         /* ONLY ON A HIT. A miss used to be cached exactly like a hit, and that made
          * it permanent: the session could arrive a moment later and this would
          * never look again, because the guard above returns on `loaded`.
@@ -290,6 +405,11 @@ export class AgentRuntime {
          * -- not per render -- so a genuinely absent session does not spin. */
         if (ses)
             s.loaded = true;
+        s.loadMissed = !ses;
+        // Loaded with nothing of this page's to save: nothing is unsaved any more.
+        // With something, the persist below clears the flag once it lands.
+        if (ses && !pre.length)
+            s.saveBlocked = null;
         /* MIGRATION. A conversation from before the snapshot existed has none, and
          * would otherwise keep following the live Settings default forever. Opening
          * it freezes it at what it would have used at this moment, so nothing
@@ -298,6 +418,37 @@ export class AgentRuntime {
         if (!sessionSystemConfig(id))
             this.freezeSystemConfig(id);
         this.notify(id);
+        // What was added before the load could not be saved then (see persist).
+        if (ses && pre.length)
+            void this.persist(id);
+    }
+    /** Try the stored chat again after a load failed (the unsaved-chat notice's
+     * Retry): load it -- merging what this page added meanwhile after it, as
+     * `load` always does -- then save the merged list. True once it is saved;
+     * false when the load missed again (or threw), and `saveBlocked` stays. */
+    async retryLoad(id) {
+        await this.load(id);
+        const s = this.map.get(id);
+        if (!s?.loaded)
+            return false;
+        // persistNow swallows its own failures; this catch keeps the promise a
+        // Retry button awaits from ever rejecting.
+        await this.persist(id).catch(() => { });
+        /* GLOBAL, because the session list is. While the load kept missing, the
+         * list the page shows (and the header's title, read from it) could drop
+         * this chat; it is back now, and only a global change makes the page
+         * re-read the list. Without it the recovered chat stayed missing from the
+         * list, titled "New chat", until a reload. */
+        this.notifyGlobal();
+        return s.saveBlocked === null;
+    }
+    /** Raise the unsaved-chat flag when `id` is still not loaded after a load
+     * was tried, so the page says its new messages are not being kept. */
+    flagIfUnsaved(id) {
+        const s = this.map.get(id);
+        if (s && !s.loaded && s.loadMissed && s.turns.length && s.saveBlocked !== 'load-failed') {
+            this.patch(id, { saveBlocked: 'load-failed' });
+        }
     }
     async openInitial() {
         if (this.initInFlight)
@@ -310,10 +461,14 @@ export class AgentRuntime {
             // the traces, to be pruned with them.
             const empty = list.find((s) => !s.parent && (!s.messages || s.messages.length === 0));
             if (empty) {
-                this.ensure(empty.id).loaded = true;
+                const s = this.ensure(empty.id);
+                s.loaded = true;
+                s.persistedLen = 0;
+                // A model picked on this empty chat before the reload is still its model.
+                s.model = empty.model ?? null;
                 return empty.id;
             }
-            return this.newSession();
+            return this.newDraft();
         })();
         try {
             return await this.initInFlight;
@@ -322,6 +477,37 @@ export class AgentRuntime {
             this.initInFlight = null;
         }
     }
+    /** A new chat that is saved only when it is first used. */
+    async newDraft() {
+        this.ws();
+        const id = `ses_${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
+        const s = this.ensure(id);
+        s.loaded = true;
+        s.persistedLen = 0;
+        this.drafts.add(id);
+        return id;
+    }
+    /** Whether `id` is a draft that has not been saved yet. */
+    isDraft(id) { return this.drafts.has(id); }
+    /** Save a draft under its own id; a no-op for any other chat. Concurrent
+     * callers share one create. A failure leaves it a draft, so the next write
+     * tries again. */
+    materialize(id) {
+        if (!this.drafts.has(id))
+            return Promise.resolve();
+        const inFlight = this.materializing.get(id);
+        if (inFlight)
+            return inFlight;
+        const run = (async () => {
+            await this.host.sessions.create('New chat', this.surface, { id });
+            this.drafts.delete(id);
+            this.freezeSystemConfig(id);
+            this.notifyGlobal();
+        })();
+        this.materializing.set(id, run);
+        run.finally(() => this.materializing.delete(id)).catch(() => { });
+        return run;
+    }
     async newSession() {
         this.ws();
         /* A new chat starts with no tasks because the task store is KEYED BY
@@ -334,6 +520,7 @@ export class AgentRuntime {
         const ses = await this.host.sessions.create('New chat', this.surface);
         const s = this.ensure(ses.id);
         s.loaded = true;
+        s.persistedLen = 0;
         // The system prompt is the head of the cached prefix, so this conversation's
         // config is decided HERE and read from the snapshot after -- see
         // sessionSystemConfig. Settings decides what the next one starts with.
@@ -346,12 +533,86 @@ export class AgentRuntime {
         this.map.get(id)?.abort?.abort();
         this.map.delete(id);
         this.subs.delete(id);
+        this.drafts.delete(id);
         // The frozen system config goes with the conversation it described.
         clearSessionSystemConfig(id);
         await this.host.sessions.delete(id).catch(() => { });
         deleteDocsForSession(id);
         this.notifyGlobal();
     }
+    /* ---- model per chat ---- */
+    available(model) {
+        return this.host.isModelAvailable ? this.host.isModelAvailable(model) : true;
+    }
+    /** Is the chat's STORED model still usable? Trusted until the catalog has
+     * been consulted: before that, "not in the catalog" means "not looked yet",
+     * and acting on it would announce a fallback and fold for nothing. */
+    storedAvailable(model) {
+        if (this.host.modelsSettled && !this.host.modelsSettled())
+            return true;
+        return this.available(model);
+    }
+    /** The stored model when it is gone and the chat would run on a fallback. */
+    lostModel(s) {
+        if (!this.host.perChatModel || !s.model)
+            return null;
+        return this.storedAvailable(s.model) ? null : s.model;
+    }
+    modelNotice(id, s) {
+        const lost = this.lostModel(s);
+        if (!lost)
+            return null;
+        const fallback = this.getModel();
+        return `This chat used ${lost}, which is not available. It will run on ${fallback}`
+            + (this.canHold(id, fallback) ? '.' : ', and older history will be folded to fit.');
+    }
+    /** The model this chat runs on: its own if still available, else the
+     * last-used pick. Without `perChatModel`, always the last-used pick. */
+    chatModel(id) {
+        const s = this.map.get(id);
+        if (!this.host.perChatModel || !s?.model || this.lostModel(s))
+            return this.getModel();
+        return s.model;
+    }
+    fillTokens(turns) {
+        let n = this.fill.get(turns);
+        if (n === undefined) {
+            n = estimateTokens(outgoingMessages(turns));
+            this.fill.set(turns, n);
+        }
+        return n;
+    }
+    /** Can `model`'s window hold this chat as it stands (below the fold line)?
+     * Measured over what a send would actually hand the run -- the folded view
+     * plus the turns after it -- not the raw transcript, which overstates a chat
+     * that has already folded. */
+    canHold(id, model) {
+        const s = this.map.get(id);
+        if (!s)
+            return true;
+        const window = this.host.modelInfo(model).contextWindow ?? 128000;
+        if (window <= 0)
+            return true;
+        return this.fillTokens(s.turns) / window < COMPACT_AT_FILL;
+    }
+    /** Switch this chat (only) to `model`; null when it switched. Refused, with
+     * nothing changed: before the chat has loaded (there is nothing to measure,
+     * and persisting would write an empty transcript over the stored one); when
+     * the model is not available (it would silently run on the fallback); and
+     * when it cannot hold the chat (switching never folds, spec 3.5). */
+    setChatModel(id, model) {
+        if (!this.map.get(id)?.loaded)
+            return 'not-loaded';
+        if (!this.available(model))
+            return 'unavailable';
+        if (!this.canHold(id, model))
+            return 'too-large';
+        this.patch(id, { model });
+        // A draft keeps the pick in memory; picking a model is not using the chat.
+        if (!this.drafts.has(id))
+            void this.persist(id);
+        return null;
+    }
     /* ---- view mutators ---- */
     setInput(id, v) { this.patch(id, { input: v }); }
     setMode(id, m) { this.patch(id, { mode: m }); }
@@ -367,12 +628,15 @@ export class AgentRuntime {
         void this.persist(id);
     }
     /** Append a local assistant-style notice turn (e.g. a /model confirmation) — not
-     * sent to the model, just shown in the transcript. */
+     * sent to the model, just shown in the transcript. Returns the turn's id. */
     note(id, text, extra) {
         const s = this.ensure(id);
-        const turn = { id: `n${Date.now().toString(36)}`, included: false, messages: [{ role: 'assistant', content: text }], ...extra };
+        // The random suffix: two notes in one millisecond (a fold beside a budget
+        // warning) must not share an id, or a later update by id lands on both.
+        const turn = { id: `n${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`, included: false, messages: [{ role: 'assistant', content: text }], ...extra };
         this.patch(id, { turns: [...s.turns, turn] });
         void this.persist(id);
+        return turn.id;
     }
     /* The compaction seam. PERMANENT in the transcript, per the `checkpoint`
      * event's contract: compaction is lossy, and a person who cannot see that it
@@ -392,7 +656,7 @@ export class AgentRuntime {
          * The body rides along so the seam can be READ. It was dropped here before
          * -- the event carries it, and this took only the count -- which left the
          * one question a seam raises with no answer anywhere in the UI. */
-        this.note(id, `${CHECKPOINT_MARKER}${n} collapsed — earlier context is summarized from here`, body ? { checkpoint: body } : undefined);
+        return this.note(id, `${CHECKPOINT_MARKER}${n} collapsed — earlier context is summarized from here`, body ? { checkpoint: body } : undefined);
     }
     /** Show a message in the transcript as YOUR turn, without adding it to what
      * gets sent. Used for injected messages: the real copy is already in the
@@ -408,8 +672,13 @@ export class AgentRuntime {
     setAttachments(id, fn) {
         this.patch(id, { attachments: fn(this.ensure(id).attachments) });
     }
+    /** Flip whether turn `turnId` is sent. A FOLDED turn (see isFoldedTurn) is
+     * refused -- no state change, no persist: the folded view stands for it, so
+     * including or dropping it would change nothing the next request carries. */
     toggleInclude(id, turnId) {
         const s = this.ensure(id);
+        if (isFoldedTurn(s.turns, s.turns.findIndex((t) => t.id === turnId)))
+            return;
         this.patch(id, { turns: s.turns.map((t) => (t.id === turnId ? { ...t, included: !t.included } : t)) });
         void this.persist(id);
     }
@@ -548,16 +817,103 @@ export class AgentRuntime {
         this.getWorker().inject(s.runId, messages, hard);
         return true;
     }
-    /* ---- run ---- */
-    async persist(id) {
+    queueWrite(id, write) {
+        // Nothing queued: start now, at the same tick as before this queue existed.
+        // A failed write must not stop the ones queued behind it.
+        const prev = this.writing.get(id);
+        const next = prev ? prev.catch(() => { }).then(write) : write();
+        this.writing.set(id, next);
+        next.finally(() => { if (this.writing.get(id) === next)
+            this.writing.delete(id); }).catch(() => { });
+        return next;
+    }
+    persist(id) {
+        return this.queueWrite(id, async () => {
+            // The first write to a draft saves it first; a failed save skips this
+            // write, and the draft stays a draft for the next one.
+            if (this.drafts.has(id)) {
+                try {
+                    await this.materialize(id);
+                }
+                catch {
+                    return;
+                }
+            }
+            await this.persistNow(id);
+        });
+    }
+    async persistNow(id) {
         const s = this.map.get(id);
-        if (!s)
+        /* Never before the stored transcript has loaded (ruling R34). Until then
+         * `turns` holds only what this page added -- a /model notice, say -- and
+         * saving it would write that over the whole stored chat. Such notes stay
+         * in memory -- and once a load has actually failed, say so. */
+        if (!s?.loaded) {
+            this.flagIfUnsaved(id);
+            return;
+        }
+        // A read that throws is a save that did not happen: persistedLen and
+        // saveBlocked stay as they are, and the next write tries again.
+        let ses;
+        try {
+            ses = await this.host.sessions.get(id);
+        }
+        catch {
             return;
-        const ses = await this.host.sessions.get(id);
+        }
         if (!ses)
             return;
-        ses.messages = s.turns;
-        await this.host.sessions.save(ses).catch(() => { });
+        /* Shorten the stored chat (retry, /clear) only when it is the length this
+         * page last saw (ruling R36). Otherwise another writer appended since, and
+         * this page's shorter list would delete that writer's newer turns. */
+        const known = ses.messages.length === s.persistedLen;
+        let turns = s.turns;
+        if (!known) {
+            /* Another writer changed it since. Saving this page's list as it stands
+             * would write it BY POSITION -- a stale [q0] that sent q3 put q3 at index
+             * 1, over the other tab's q1 -- so merge by turn id instead, over what
+             * was just read: stored order first, this page's version of any turn
+             * both hold (last writer wins per turn), then this page's turns the
+             * store does not have, in this page's order. A flat (daemon) chat's
+             * turns get the same `stored-<i>` ids here as at load, so a turn this
+             * page loaded from it matches and is not added twice.
+             *
+             * The page then shows the merged chat. Nothing it holds is dropped, and
+             * the store loses nothing: the merge holds every stored turn, so the
+             * save may rewrite freely (allowTruncate below), which a flat store's
+             * conversion to turns needs. */
+            const stored = turnsFromSessionMessages(ses.messages);
+            const mine = new Map(s.turns.map((t) => [t.id, t]));
+            const storedIds = new Set(stored.map((t) => t.id));
+            /* Only the FIRST stored turn with an id takes this page's version. A
+             * second one with the same id is another turn that collided (ids are
+             * meant to be unique; turnsFromSessionMessages keeps its synthetic ones
+             * so), and replacing it too would write one turn twice and lose the
+             * other on this rewrite. */
+            const used = new Set();
+            const merged = stored.map((t) => {
+                const own = mine.get(t.id);
+                if (!own || used.has(t.id))
+                    return t;
+                used.add(t.id);
+                return own;
+            });
+            turns = [...merged, ...s.turns.filter((t) => !storedIds.has(t.id))];
+            alog(`session ${id}: stored has ${ses.messages.length} messages, this page last saw ${s.persistedLen}; another writer changed it, so this save merges both by turn (${turns.length} turns)`);
+            this.patch(id, { turns, mergeTick: s.mergeTick + 1 });
+        }
+        ses.messages = turns;
+        if (s.model)
+            ses.model = s.model;
+        try {
+            // Known: this page's list IS the chat, and may shorten it (R36). A
+            // merge: holds every stored turn, so rewriting cannot lose one.
+            await this.host.sessions.save(ses, { allowTruncate: true });
+            s.persistedLen = turns.length;
+            if (s.saveBlocked)
+                this.patch(id, { saveBlocked: null });
+        }
+        catch { /* a failed save leaves persistedLen as it was */ }
     }
     /** Filename of the system prompt this surface will run with next — what the
      * context drawer's active-prompt chip shows. Mirrors composeSystem's own
@@ -684,7 +1040,21 @@ export class AgentRuntime {
         const s = this.ensure(id);
         if ((!text && images.length === 0) || s.running)
             return;
-        const isFirst = s.turns.length === 0;
+        /* The stored chat first (ruling R35). Nothing stops the composer before it
+         * lands, and a send built on the empty pre-load list would run with no
+         * history, retitle the chat as if it were new, and then be wiped by the
+         * load or never saved. Also retries a load that missed. */
+        if (!s.loaded) {
+            await this.load(id);
+            // Another send started while this one waited (ruling R37): treat this
+            // one like a send during a run -- nothing happens, the draft stays.
+            if (s.running)
+                return;
+        }
+        // Only a LOADED empty chat is new. One whose load missed again is empty
+        // because it was never read, and retitling it would write this message's
+        // text over the stored chat's title while every other write is held back.
+        const isFirst = s.loaded && s.turns.length === 0;
         const userTurn = { id: `t${Date.now().toString(36)}`, included: true, messages: [buildUserMessage(text, images)] };
         const nextTurns = [...s.turns, userTurn];
         s.toolMs = {};
@@ -704,6 +1074,10 @@ export class AgentRuntime {
             turns: nextTurns, error: '', live: { text: '', tools: [] }, running: true, input: '', attachments: [], suggestions: [],
             policyNotes: [], degradedModel: null, injectedIds: [], lastStopReason: null,
         }, true);
+        // Still not loaded after that retry: this exchange runs and shows, but will
+        // not be saved. Flagged once the turn exists, so the notice is up for the
+        // whole run rather than only after it.
+        this.flagIfUnsaved(id);
         // Feature guard — the runtime is the chokepoint for every /agent run (send
         // and retry), so a quota/plan guard registered later covers this surface too.
         const gate = await this.host.guard('llm-execution');
@@ -722,23 +1096,34 @@ export class AgentRuntime {
             return;
         }
         const startedAt = Date.now();
+        // A draft becomes a saved chat now, after the guard allowed the send, so a
+        // refused send leaves nothing behind. A failed save does not stop the run:
+        // its first write after it tries again.
+        if (this.drafts.has(id))
+            await this.materialize(id).catch(() => { });
         // Title an untitled session from its first message, so the switcher is readable.
         // A hand-renamed session is locked, so its chosen title is left alone.
         if (isFirst && text) {
-            const ses = await this.host.sessions.get(id);
-            if (ses && !ses.titleLocked) {
-                ses.title = text.slice(0, 48);
-                await this.host.sessions.save(ses).catch(() => { });
-                this.notifyGlobal();
-            }
+            await this.queueWrite(id, async () => {
+                const ses = await this.host.sessions.get(id);
+                if (ses && !ses.titleLocked) {
+                    ses.title = text.slice(0, 48);
+                    await this.host.sessions.save(ses).catch(() => { });
+                    this.notifyGlobal();
+                }
+            }).catch(() => { });
         }
-        const outgoing = nextTurns.filter((t) => t.included).flatMap((t) => t.messages);
+        const outgoing = outgoingMessages(nextTurns);
         /* Transcript-only turns noteUser() added for messages injected mid-run.
          * They exist so the pivot is visible WHILE the run is in flight; once the
          * run returns, its own copy of each injected message arrives in `created`
          * and folds into the user turn, so keeping these would render the text a
          * second time below the final reply, where it reads as unanswered. */
         const injectedTurnIds = [];
+        /* The seams THIS run wrote. The last one carries the run's folded view
+         * once the run returns, so the next send starts from the fold instead of
+         * re-folding the raw transcript. */
+        const seamIds = [];
         let verification;
         let auditIncomplete;
         const ac = new AbortController();
@@ -779,7 +1164,14 @@ export class AgentRuntime {
                 this.composeSystem(id, opts.persona, opts.partsOverride),
                 enabledSkillCatalog((name) => !skillDeny.includes(name)).catch(() => []),
             ]);
-            const model = this.getModel();
+            const model = this.chatModel(id);
+            /* Decided now, from what is true now: the chat's own model is gone and
+             * the one it falls back to cannot hold it. A model picked since load, or
+             * a catalog that has caught up, changes the answer. */
+            const forceFold = !!this.lostModel(s) && !this.canHold(id, model);
+            // The chat now runs on `model`; storing it is what clears the notice.
+            if (this.host.perChatModel && s.model !== model)
+                this.patch(id, { model });
             // Live model for onBreach pricing — reassigned when a degrade breach
             // switches the run onto a cheaper model (see onBreach below).
             let activeModel = model;
@@ -846,6 +1238,7 @@ export class AgentRuntime {
                     : (getPolicy(opts.policyName) ?? STANDARD_POLICY),
                 ...(this.host.sessionsRoot ? { sessionsRoot: this.host.sessionsRoot() } : {}),
                 compression: { mode: this.host.compression(), contextWindow },
+                ...(forceFold ? { forceFold: true } : {}),
                 signal: ac.signal,
                 sessionId: id,
                 toolNames,
@@ -888,6 +1281,7 @@ export class AgentRuntime {
                 // fallback exactly as before.
                 editorFile: opts.editorFile,
                 onNodeEvent: (e) => {
+                    publishSubagentEvent({ sessionId: id, surface: this.surface, event: e });
                     const c = nodeUsageOf(e);
                     if (c) {
                         calleeSpend.inTok += c.usage.promptTokens;
@@ -997,7 +1391,7 @@ export class AgentRuntime {
                         return;
                     }
                     if (e.type === 'checkpoint') {
-                        this.noteCheckpoint(id, e.collapsed, e.checkpoint);
+                        seamIds.push(this.noteCheckpoint(id, e.collapsed, e.checkpoint));
                         return;
                     }
                     if (e.type === 'tools-loaded') {
@@ -1085,11 +1479,13 @@ export class AgentRuntime {
                     ...(res.calls ? { calls: res.calls } : {}),
                 }
                 : undefined;
+            const lastSeam = seamIds[seamIds.length - 1];
+            const stitched = s.turns
+                .filter((t) => !injectedTurnIds.includes(t.id))
+                .map((t) => (t.id === userTurn.id ? { ...t, messages: [userTurn.messages[0], ...created], stats, ...(verification ? { verification } : {}), ...(auditIncomplete ? { auditIncomplete } : {}) } : t));
             this.patch(id, {
                 lastStopReason: res.stopReason,
-                turns: s.turns
-                    .filter((t) => !injectedTurnIds.includes(t.id))
-                    .map((t) => (t.id === userTurn.id ? { ...t, messages: [userTurn.messages[0], ...created], stats, ...(verification ? { verification } : {}), ...(auditIncomplete ? { auditIncomplete } : {}) } : t)),
+                turns: lastSeam ? stampFoldedView(stitched, lastSeam, res.messages.filter((m) => m.role !== 'system'), userTurn.id) : stitched,
             });
             void this.persist(id);
             if (stats) {
@@ -1132,6 +1528,8 @@ export class AgentRuntime {
             s.abort = null;
             s.runId = null;
             this.patch(id, { running: false, live: null, recovery: null }, true);
+            // Any callee still marked running under this session will never report.
+            publishSubagentParentEnded(id);
             // Upsert the session recording with everything captured so far (this turn's
             // events appended to prior turns), under one stable id so the whole session
             // replays as a single stream. Skipped until something replayable happened.
@@ -1158,12 +1556,21 @@ export class AgentRuntime {
         if (!userText || s.running)
             return;
         this.ws();
+        // As in send: never build on a transcript that has not loaded, and never
+        // start a second turn that began while the load was pending.
+        if (!s.loaded) {
+            await this.load(id);
+            if (s.running)
+                return;
+        }
         const userTurn = { id: `t${Date.now().toString(36)}`, included: true, messages: [{ role: 'user', content: userText }] };
         const ac = new AbortController();
         s.abort = ac;
         // Optimistic, for the same reason as `send` above: the guard is a network
         // call, and a host-driven turn that waits on it looks like nothing happened.
         this.patch(id, { turns: [...s.turns, userTurn], error: '', live: { text: '', tools: [] }, running: true, suggestions: [] }, true);
+        // As in send: a load that missed again leaves this turn unsaved; say so now.
+        this.flagIfUnsaved(id);
         const gate = await this.host.guard('llm-execution');
         if (!gate.allowed) {
             s.abort = null;
@@ -1192,13 +1599,16 @@ export class AgentRuntime {
      * with the full content — the context drawer's per-item Restore, transplanted
      * from the harness/conversation.ts singleton (same marker-matching and
      * identity-swap semantics; see that module for the rationale). Returns false
-     * (state untouched, no persist) when the turn or the matching stub is absent. */
+     * (state untouched, no persist) when the turn or the matching stub is absent,
+     * or when the turn is FOLDED (see isFoldedTurn): the folded view stands for
+     * it, so content restored into it would never be sent. */
     restoreToolResult(id, turnId, blobId, content) {
         const marker = `recall_result({ id: "${blobId}" })`;
         const s = this.ensure(id);
-        const turn = s.turns.find((t) => t.id === turnId);
-        if (!turn)
+        const at = s.turns.findIndex((t) => t.id === turnId);
+        if (at < 0 || isFoldedTurn(s.turns, at))
             return false;
+        const turn = s.turns[at];
         const idx = turn.messages.findIndex((m) => m.role === 'tool' && typeof m.content === 'string' && m.content.includes(marker));
         if (idx < 0)
             return false;
@@ -1232,8 +1642,13 @@ export class AgentRuntime {
     /** Drop all in-memory state and abort every run — called on a scope change so
      * one identity's sessions and runs never carry into another's. */
     reset() {
+        const runningIds = [...this.map.entries()].filter(([, s]) => s.abort).map(([sid]) => sid);
         for (const s of this.map.values())
             s.abort?.abort();
+        // The worker is disposed below, which never settles an in-flight run, so
+        // its `finally` (and the parent-ended signal there) never runs: say it here.
+        for (const sid of runningIds)
+            publishSubagentParentEnded(sid);
         const ids = [...this.subs.keys()];
         this.map.clear();
         this.worker?.dispose();
@@ -1243,5 +1658,13 @@ export class AgentRuntime {
             this.notify(id);
         this.notifyGlobal();
     }
+    /** End this runtime for good: reset, and stop listening to the catalog. For
+     * a runtime that is recreated rather than reused (a project's, rebuilt on
+     * every open); a long-lived one is reset() instead and keeps listening. */
+    dispose() {
+        this.reset();
+        this.offModels?.();
+        this.offModels = null;
+    }
 }
 //# sourceMappingURL=runtime.js.map