@genesislcap/ai-assistant 15.56.0 → 15.58.0

package/dist/chat-driver.mjs

@@ -4032,6 +4032,10 @@ var META_EVENT_IMPORTANCE = {
   "session.switched": "low",
   "session.switch-deferred": "low",
   "persistence.restored": "normal",
+  // Whether a restored flow will be re-activated and resumed (GENC-1662), and how much the trim cut.
+  "persistence.resume-planned": "normal",
+  // A planned resume that did not run, and why (GENC-1662) — the divider was put back to plain.
+  "persistence.resume-withdrawn": "normal",
   "persistence.suppressed": "normal",
   "persistence.not-resumable": "normal",
   "driver.wired": "low",
@@ -4825,6 +4829,8 @@ var AgentSession = class {
      * activation, then deleted so a later re-activation starts fresh.
      */
     this.restoredStates = {};
+    /** The tail of the activation queue — see {@link AgentSession.activate}. */
+    this.activation = Promise.resolve();
   }
   /** The active agent, or `undefined` before the first activation and after a release. */
   getActive() {
@@ -4873,8 +4879,19 @@ var AgentSession = class {
    *
    * Re-activating the same agent by name is not a switch: no hooks fire, no lock moves, and no
    * handoff is recorded. That guard matters because a per-turn re-resolve calls through here.
-   */
-  async activate(agent) {
+   *
+   * Single-flight (GENC-1662): calls run one after another, never interleaved. `active` is only
+   * set once the hooks have finished, so two overlapping calls for the same agent would otherwise
+   * both see a switch and run `onActivate` twice — and a restored `init` would be overwritten by a
+   * fresh one that finished later. That overlap became possible when a restore started activating
+   * the flow owner outside a turn, where a send can land mid-activation.
+   */
+  activate(agent) {
+    const run = this.activation.then(() => this.activateNow(agent));
+    this.activation = run.catch(() => void 0);
+    return run;
+  }
+  async activateNow(agent) {
     const previousAgent = this.active;
     const switched = !previousAgent || previousAgent.name !== agent.name;
     const transition = { previousAgent, switched };
@@ -7435,9 +7452,13 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   }
   /**
    * Continue the tool loop from current history without appending a new user message.
-   * Used by OrchestratingDriver after an agent handoff.
+   * Used by OrchestratingDriver after an agent handoff, and to resume a restored flow (GENC-1662).
+   *
+   * `options.tailNote` rides the framed tail of the FIRST model call only — after the history, where
+   * a note about the conversation belongs — and is dropped once the model has answered, so it
+   * cannot go stale over the rest of the loop. Contrast `transientPrimer`, which leads the request.
    */
-  async continueFromHistory(transientPrimer) {
+  async continueFromHistory(transientPrimer, options) {
     if (this.busy) return { reason: "done" };
     this.busy = true;
     if (this.messageController.signal.aborted) this.beginMessage();
@@ -7459,7 +7480,7 @@ var ChatDriver = class _ChatDriver extends EventTarget {
     this.activityBus.publish("tool-loop-start", void 0);
     let result = { reason: "done" };
     try {
-      result = await this.runToolLoop("", void 0, transientPrimer);
+      result = await this.runToolLoop("", void 0, transientPrimer, options?.tailNote);
       return result;
     } catch (e) {
       logger2.error("ChatDriver error:", e);
@@ -7496,7 +7517,7 @@ var ChatDriver = class _ChatDriver extends EventTarget {
   // splitting threads that state through signatures rather than removing it. `turn-setup.ts`
   // (docs/code-health.md §11.3) is the intended carve-up.
   // oxlint-disable-next-line complexity, max-lines-per-function
-  async runToolLoop(userInput, attachments, transientPrimer) {
+  async runToolLoop(userInput, attachments, transientPrimer, tailNote) {
     if (!this.systemPrompt) {
       logger2.warn(
         "ChatDriver: no systemPrompt set. The assistant will have no instructions \u2014 provide a systemPrompt via agents config or the foundation-ai-assistant property."
@@ -7557,7 +7578,10 @@ var ChatDriver = class _ChatDriver extends EventTarget {
 ${MALFORMED_CALL_NUDGE}` : emptyResponseAttempts > 0 ? `
 
 ${EMPTY_RESPONSE_NUDGE}` : "";
-      const frameworkSystemSuffix = `${foldSuffix}${retryNudge}`;
+      const firstCallNote = tailNote && iterations === 1 ? `
+
+${tailNote}` : "";
+      const frameworkSystemSuffix = `${foldSuffix}${firstCallNote}${retryNudge}`;
       const primer = normalizeForProvider([
         ...this.primerHistory ?? [],
         ...transientPrimer ?? []
@@ -8616,13 +8640,39 @@ var OrchestratingDriver = class extends EventTarget {
     }
     return lastResult?.reason === "done" ? lastResult : { reason: "done" };
   }
-  async continueFromHistory(transientPrimer) {
-    return this.chatDriver.continueFromHistory(transientPrimer);
+  async continueFromHistory(transientPrimer, options) {
+    return this.chatDriver.continueFromHistory(transientPrimer, options);
   }
   /** {@inheritDoc AiDriver.primeRestoredAgentState} */
   primeRestoredAgentState(snapshots) {
     this.agentSession.primeRestoredStates(snapshots);
   }
+  /** {@inheritDoc AiDriver.canRestoreFlowOwner} */
+  canRestoreFlowOwner(agentName) {
+    return this.agents.some((a) => a.name === agentName);
+  }
+  /** {@inheritDoc AiDriver.canResumeRestoredFlow} */
+  canResumeRestoredFlow(agentName) {
+    const agent = this.agents.find((a) => a.name === agentName);
+    return !!agent && agent.resumeOnRestore !== false;
+  }
+  /**
+   * {@inheritDoc AiDriver.resumeRestoredFlow}
+   *
+   * Installs the flow owner directly rather than through `handleTurn`: there is no user message
+   * to classify, and a restored lock already says which agent owns the flow. `continueFromHistory`
+   * on its own would not do — it neither routes nor installs, so it would run on whatever agent
+   * happened to be installed (none, straight after a reload).
+   */
+  async resumeRestoredFlow(resumeNote) {
+    const owner = this.agentSession.getFlowOwner();
+    const agent = owner ? this.agents.find((a) => a.name === owner) : void 0;
+    if (!agent) return void 0;
+    this.cancelled = false;
+    await this.installAgent(agent);
+    if (!resumeNote || agent.resumeOnRestore === false || this.cancelled) return void 0;
+    return this.chatDriver.continueFromHistory(void 0, { tailNote: resumeNote });
+  }
   /**
    * {@inheritDoc AiDriver.getContextReserve}
    *
@@ -9097,6 +9147,7 @@ function defineStatefulAgent(opts) {
     onUnresolvedTool: wrappedOnUnresolvedTool,
     resumable: wrappedResumable,
     notResumableMessage: opts.notResumableMessage,
+    resumeOnRestore: opts.resumeOnRestore,
     contextReserve: opts.contextReserve,
     onActivate: async (ctx) => {
       state = await opts.init(ctx);