@ordewell/core 0.10.6 → 0.10.8

package/dist/index.js

@@ -21289,14 +21289,13 @@ var Supervisor = class {
     return { policy: this.policy.snapshot(), wakeUps: [...this.wakeUps] };
   }
   /**
-   * Put back a save's gathered state after a restart, and re-arm the debounce
-   * from when it was due, so a batch that was inside the window is delivered.
+   * Keep a save's gathered state without waking the planner just because the
+   * session was opened (ADR-0029). A new run event may arm it again.
    */
   restore(snapshot) {
     this.disarm();
     this.policy.restore(snapshot?.policy);
     this.wakeUps = [...snapshot?.wakeUps ?? []];
-    this.arm();
   }
   /**
    * A run started. One the user started gives its supervisor a clean record;
@@ -30847,14 +30846,11 @@ var PlannerResend = class {
   landed() {
     this.resentAt = null;
   }
-  /** A plan adopted off disk: re-arm the wait it saved. A time already past resends at once. */
+  /** Loading a session preserves the inputs, without scheduling a model call. */
   restore() {
     this.reset();
     const saved = this.host.plan()?.plannerResend;
-    if (saved?.at === void 0) return;
-    const at = Date.parse(saved.at);
-    if (Number.isNaN(at)) delete saved.at;
-    else this.waits.arm(WAIT, new Date(at));
+    if (saved) delete saved.at;
   }
   /** The plan is gone: nothing it waited on carries over. */
   reset() {
@@ -30925,6 +30921,8 @@ var PlanTurns = class {
   refusalTold = null;
   /** The user stopped the turn wake-ups waited behind: they wait for the next input to open one, not for the stop's release. */
   quiet = false;
+  /** A loaded session stays idle even if an outgoing turn's release pumps the queue. */
+  restored = false;
   seq = 0;
   resend;
   /** A turn ended on the planner's usage limit: arm the wait for its inputs. Saved with the failure the turn records. */
@@ -30949,8 +30947,9 @@ var PlanTurns = class {
     this.host.persist();
     for (const t of plan.pendingTurns) if (t.source === "user") this.settle(t.id, (w) => w.resolve(plan));
   }
-  /** A plan adopted off disk: the wait it saved is armed again. */
+  /** A plan adopted off disk keeps its inputs until a new input asks for a turn. */
   restoreResend() {
+    this.restored = true;
     this.resend.restore();
   }
   /** Whether a turn this module opened is in flight. */
@@ -30995,6 +30994,7 @@ var PlanTurns = class {
     const plan = this.host.plan();
     if (!plan) return Promise.reject(new Error("No planning conversation to continue"));
     const entry = this.pending(input, forced);
+    this.restored = false;
     this.quiet = false;
     if (this.resend.arrived()) this.host.announce();
     const pending = plan.pendingTurns ?? [];
@@ -31024,14 +31024,14 @@ var PlanTurns = class {
   /**
    * Start the next turn if one is due: nothing of ours is in flight, the
    * conversation is free, and inputs wait. The host calls it when any planner
-   * turn lets the conversation go, and after a load, to replay what waited.
+   * turn lets the conversation go. A loaded session waits for a new input.
    *
    * Every turn passes the planner gate here, whatever brought its input: it
    * waits for the installed-planner probe, then everything is judged afresh —
    * the plan, what still waits, and the planner in use at that moment.
    */
   pump() {
-    if (this.running || this.detecting || this.resend.holds()) return;
+    if (this.restored || this.running || this.detecting || this.resend.holds()) return;
     const plan = this.host.plan();
     if (!plan || this.host.conversationBusy()) return;
     const batch = this.liveBatch(plan);
@@ -31115,6 +31115,7 @@ var PlanTurns = class {
     this.running?.release();
     this.running = null;
     this.quiet = false;
+    this.restored = false;
     for (const waiter of this.waiters.values()) waiter.reject(new PlannerTurnDiscardedError());
     this.waiters.clear();
   }
@@ -35214,6 +35215,9 @@ var Session = class {
     }
     if (adopting) this.usage.restore(plan.plannerUsage);
     if (opts?.sessionId) this.currentSessionId = opts.sessionId;
+    if (adopting) {
+      for (const task of flattenTasks(plan.tasks)) delete task.resumeAt;
+    }
     this.orchestrator.loadPlan(plan.tasks, plan.runners);
     this.syncPlanTasks();
     migratePlanStateIsolation(plan);
@@ -35228,7 +35232,6 @@ var Session = class {
     }
     if (opts?.persist !== false) this.persist();
     if (this.usage.hasUsage) this.broadcast(this.usage.message());
-    this.turns.pump();
   }
   destroy() {
     this.closed = true;