@compilr-dev/sdk 0.23.1 → 0.23.2

package/dist/team/team-agent.d.ts

@@ -272,6 +272,28 @@ export declare class TeamAgent {
      * `thought_signature`) that do not transfer across a rebuild.
      */
     private stashForRebuild;
+    /**
+     * A turn is in flight: the host has called `run()`/`stream()` and is awaiting it.
+     *
+     * ⚠️ HOSTS MUST BRACKET EVERY RUN, IN A `finally`. `TeamAgent` does not own the run call —
+     * the host holds the unwrapped `Agent` — so it cannot observe this for itself.
+     */
+    private turnStartedAt;
+    /**
+     * How long a turn may be in flight before this stops believing the host.
+     *
+     * ⚠️ A FLAG THAT ONLY EVER GETS SET IS WORSE THAN THE BUG IT GUARDS. A host that throws past
+     * its `endTurn()` would block every edit to that agent for the life of the process, with no
+     * way back short of a restart. Going stale bounds that to one window; the edit that slips
+     * through after it is the same edit that would have been allowed before this guard existed.
+     */
+    private static readonly TURN_STALE_AFTER_MS;
+    /** Mark the start of a turn. Pair with `endTurn()` in a `finally`. */
+    beginTurn(): void;
+    /** Mark the end of a turn, however it ended — completed, aborted or thrown. */
+    endTurn(): void;
+    /** Whether a turn is in flight and recent enough to still be believed. */
+    get isTurnInFlight(): boolean;
     /**
      * Apply an edit to this agent in place.
      *

package/dist/team/team-agent.js

@@ -337,6 +337,36 @@ export class TeamAgent {
         this.storedState = state;
         this._agent = null;
     }
+    /**
+     * A turn is in flight: the host has called `run()`/`stream()` and is awaiting it.
+     *
+     * ⚠️ HOSTS MUST BRACKET EVERY RUN, IN A `finally`. `TeamAgent` does not own the run call —
+     * the host holds the unwrapped `Agent` — so it cannot observe this for itself.
+     */
+    turnStartedAt = null;
+    /**
+     * How long a turn may be in flight before this stops believing the host.
+     *
+     * ⚠️ A FLAG THAT ONLY EVER GETS SET IS WORSE THAN THE BUG IT GUARDS. A host that throws past
+     * its `endTurn()` would block every edit to that agent for the life of the process, with no
+     * way back short of a restart. Going stale bounds that to one window; the edit that slips
+     * through after it is the same edit that would have been allowed before this guard existed.
+     */
+    static TURN_STALE_AFTER_MS = 10 * 60 * 1000;
+    /** Mark the start of a turn. Pair with `endTurn()` in a `finally`. */
+    beginTurn() {
+        this.turnStartedAt = Date.now();
+    }
+    /** Mark the end of a turn, however it ended — completed, aborted or thrown. */
+    endTurn() {
+        this.turnStartedAt = null;
+    }
+    /** Whether a turn is in flight and recent enough to still be believed. */
+    get isTurnInFlight() {
+        if (this.turnStartedAt === null)
+            return false;
+        return Date.now() - this.turnStartedAt < TeamAgent.TURN_STALE_AFTER_MS;
+    }
     /**
      * Apply an edit to this agent in place.
      *
@@ -360,6 +390,25 @@ export class TeamAgent {
           when it is not. Its `rebuilt` contribution is folded in below.
         */
         const tierChanged = patch.modelTier !== undefined && patch.modelTier !== this._modelTier;
+        /*
+          ⚠️ REFUSED MID-TURN, BEFORE ANYTHING IS MUTATED. A rebuild snapshots the history with
+          `serialize()` and drops the instance — but the in-flight `run()` holds its own reference
+          and finishes anyway, appending to an agent nobody will read again. Measured: the user
+          watches a reply stream in, and the rebuilt agent is handed the snapshot from BEFORE it,
+          with no memory of having said it.
+    
+          Not a broken conversation — `setHistory` repairs tool pairing, so nothing 400s. It is
+          worse than that: the agent silently forgets a turn the user just watched, and the next
+          thing it says is built on a history the user can see is wrong.
+    
+          Only rebuilding edits are refused. A rename or a new face is read from the roster at
+          render time and cannot tear anything, so those still apply mid-turn.
+        */
+        if ((needsRebuild || tierChanged) && this.isTurnInFlight) {
+            throw new Error(`Agent '${this.id}' is mid-reply. Changing its prompt, model, tools or skills rebuilds ` +
+                `it and would drop the turn it is in the middle of — wait for the reply to finish, ` +
+                `or stop it, then save.`);
+        }
         if (patch.modelTier !== undefined)
             this.setModelTier(patch.modelTier);
         if (patch.displayName !== undefined)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/sdk",
-  "version": "0.23.1",
+  "version": "0.23.2",
   "description": "Universal agent runtime for building AI-powered applications",
   "type": "module",
   "main": "dist/index.js",